C# || How To Serialize & Deserialize JSON Using C#

May 10, 2021 admin No comments

The following is a module with functions which demonstrates how to serialize and deserialize Json using C#.

The following generic functions use Newtonsoft.Json to serialize and deserialize an object.

Note: To use the functions in this module, make sure you have the ‘Newtonsoft.Json‘ package installed in your project.

One way to do this is, in your Solution Explorer (where all the files are shown with your project), right click the ‘References‘ folder, click ‘Manage NuGet Packages….‘, then type ‘Newtonsoft.Json‘ in the search box, and install the package titled Newtonsoft.Json in the results Tab.

Note: Don’t forget to include the ‘Utils Namespace‘ before running the examples!

1. Serialize – Integer Array

The example below demonstrates the use of ‘Utils.Json.Serialize‘ to serialize an integer array to Json.

The optional function parameter allows you to specify the Newtonsoft.Json.JsonSerializerSettings.





		
		
			1. Serialize - Integer Array
			
C#
			
			// Serialize - Integer Array

// Declare array of integers 
var numbers = new int[] { 1987, 19, 22, 2009, 2019, 1991, 28, 31 };

// Optional: Create the JsonSerializerSettings with optional settings.
var settings = new Newtonsoft.Json.JsonSerializerSettings() {
    NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore
};

// Serialize to Json
var numbersJson = Utils.Json.Serialize(numbers);

// Display Json
Console.WriteLine(numbersJson);

// expected output:
/*
    [
      1987,
      19,
      22,
      2009,
      2019,
      1991,
      28,
      31
    ]
*/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
				
						// Serialize - Integer Array
 
// Declare array of integers 
var numbers = new int[] { 1987, 19, 22, 2009, 2019, 1991, 28, 31 };
 
// Optional: Create the JsonSerializerSettings with optional settings.
var settings = new Newtonsoft.Json.JsonSerializerSettings() {
    NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore
};
 
// Serialize to Json
var numbersJson = Utils.Json.Serialize(numbers);
 
// Display Json
Console.WriteLine(numbersJson);
 
// expected output:
/*
    [
      1987,
      19,
      22,
      2009,
      2019,
      1991,
      28,
      31
    ]
*/

2. Serialize – String List

The example below demonstrates the use of ‘Utils.Json.Serialize‘ to serialize a list of strings to Json.

The optional function parameter allows you to specify the Newtonsoft.Json.JsonSerializerSettings.





		
		
			2. Serialize - String List
			
C#
			
			// Serialize - String List

// Declare list of strings
var names = new List<string>() {
    "Kenneth",
    "Jennifer",
    "Lynn",
    "Sole"
};

// Serialize to Json
var namesJson = Utils.Json.Serialize(names);

// Display Json
Console.WriteLine(namesJson);

// expected output:
/*
    [
      "Kenneth",
      "Jennifer",
      "Lynn",
      "Sole"
    ]
*/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
				
						// Serialize - String List
 
// Declare list of strings
var names = new List<string>() {
    "Kenneth",
    "Jennifer",
    "Lynn",
    "Sole"
};
 
// Serialize to Json
var namesJson = Utils.Json.Serialize(names);
 
// Display Json
Console.WriteLine(namesJson);
 
// expected output:
/*
    [
      "Kenneth",
      "Jennifer",
      "Lynn",
      "Sole"
    ]
*/

3. Serialize – Custom Object List

The example below demonstrates the use of ‘Utils.Json.Serialize‘ to serialize a list of custom objects to Json.

The optional function parameter allows you to specify the Newtonsoft.Json.JsonSerializerSettings.





		
		
			3. Serialize - Custom Object List
			
C#
			
			// Serialize - Custom Object List

public class Part {
    public string PartName { get; set; }
    public int PartId { get; set; }
}

// Declare list of objects
var parts = new List<Part>() {
    new Part() {
        PartName = "crank arm",
        PartId = 1234
    },
    new Part() {
        PartName = "chain ring",
        PartId = 1334
    },
    new Part() {
        PartName = "regular seat",
        PartId = 1434
    },
    new Part() {
        PartName = "banana seat",
        PartId = 1444
    },
    new Part() {
        PartName = "cassette",
        PartId = 1534
    },
    new Part() {
        PartName = "shift lever",
        PartId = 1634
    }
};

// Serialize to Json
var partsJson = Utils.Json.Serialize(parts);

// Display Json
Console.WriteLine(partsJson);

// expected output:
/*
    [
      {
        "PartName": "crank arm",
        "PartId": 1234
      },
      {
        "PartName": "chain ring",
        "PartId": 1334
      },
      {
        "PartName": "regular seat",
        "PartId": 1434
      },
      {
        "PartName": "banana seat",
        "PartId": 1444
      },
      {
        "PartName": "cassette",
        "PartId": 1534
      },
      {
        "PartName": "shift lever",
        "PartId": 1634
      }
    ]
*/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
				
						// Serialize - Custom Object List
 
public class Part {
    public string PartName { get; set; }
    public int PartId { get; set; }
}
 
// Declare list of objects
var parts = new List<Part>() {
    new Part() {
        PartName = "crank arm",
        PartId = 1234
    },
    new Part() {
        PartName = "chain ring",
        PartId = 1334
    },
    new Part() {
        PartName = "regular seat",
        PartId = 1434
    },
    new Part() {
        PartName = "banana seat",
        PartId = 1444
    },
    new Part() {
        PartName = "cassette",
        PartId = 1534
    },
    new Part() {
        PartName = "shift lever",
        PartId = 1634
    }
};
 
// Serialize to Json
var partsJson = Utils.Json.Serialize(parts);
 
// Display Json
Console.WriteLine(partsJson);
 
// expected output:
/*
    [
      {
        "PartName": "crank arm",
        "PartId": 1234
      },
      {
        "PartName": "chain ring",
        "PartId": 1334
      },
      {
        "PartName": "regular seat",
        "PartId": 1434
      },
      {
        "PartName": "banana seat",
        "PartId": 1444
      },
      {
        "PartName": "cassette",
        "PartId": 1534
      },
      {
        "PartName": "shift lever",
        "PartId": 1634
      }
    ]
*/

4. Deserialize – Integer Array

The example below demonstrates the use of ‘Utils.Json.Deserialize‘ to deserialize Json to an integer array.

The optional function parameter allows you to specify the Newtonsoft.Json.JsonSerializerSettings.





		
		
			4. Deserialize - Integer Array
			
C#
			
			// Deserialize - Integer Array

// Declare Json array of integers
var numbersJson = @"
    [
        1987,
        19,
        22,
        2009,
        2019,
        1991,
        28,
        31
    ]
";

// Optional: Create the JsonSerializerSettings with optional settings.
var settings = new Newtonsoft.Json.JsonSerializerSettings() {
    NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore
};

// Deserialize from Json to specified type
var numbers = Utils.Json.Deserialize<int[]>(numbersJson);

// Display the items
foreach (var item in numbers) { 
    Console.WriteLine($"{item}");
}

// expected output:
/*
    1987
    19
    22
    2009
    2019
    1991
    28
    31
*/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
				
						// Deserialize - Integer Array
 
// Declare Json array of integers
var numbersJson = @"
    [
        1987,
        19,
        22,
        2009,
        2019,
        1991,
        28,
        31
    ]
";
 
// Optional: Create the JsonSerializerSettings with optional settings.
var settings = new Newtonsoft.Json.JsonSerializerSettings() {
    NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore
};
 
// Deserialize from Json to specified type
var numbers = Utils.Json.Deserialize<int[]>(numbersJson);
 
// Display the items
foreach (var item in numbers) { 
    Console.WriteLine($"{item}");
}
 
// expected output:
/*
    1987
    19
    22
    2009
    2019
    1991
    28
    31
*/

5. Deserialize – String List

The example below demonstrates the use of ‘Utils.Json.Deserialize‘ to deserialize Json to a list of strings.

The optional function parameter allows you to specify the Newtonsoft.Json.JsonSerializerSettings.





		
		
			5. Deserialize - String List
			
C#
			
			// Deserialize - String List

// Declare Json array of strings
var namesJson = @"
    [
        ""Kenneth"",
        ""Jennifer"",
        ""Lynn"",
        ""Sole""
    ]
";

// Deserialize from Json to specified type
var names = Utils.Json.Deserialize<List<string>>(namesJson);

// Display the items
foreach (var item in names) { 
    Console.WriteLine($"{item}");
}

// expected output:
/*
    Kenneth
    Jennifer
    Lynn
    Sole
*/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
				
						// Deserialize - String List
 
// Declare Json array of strings
var namesJson = @"
    [
        ""Kenneth"",
        ""Jennifer"",
        ""Lynn"",
        ""Sole""
    ]
";
 
// Deserialize from Json to specified type
var names = Utils.Json.Deserialize<List<string>>(namesJson);
 
// Display the items
foreach (var item in names) { 
    Console.WriteLine($"{item}");
}
 
// expected output:
/*
    Kenneth
    Jennifer
    Lynn
    Sole
*/

6. Deserialize – Custom Object List

The example below demonstrates the use of ‘Utils.Json.Deserialize‘ to deserialize Json to a list of objects.

The optional function parameter allows you to specify the Newtonsoft.Json.JsonSerializerSettings.





		
		
			6. Deserialize - Custom Object List
			
C#
			
			// Deserialize - Custom Object List

public class Part {
    public string PartName { get; set; }
    public int PartId { get; set; }
}

// Declare Json array of objects
var partsJson = @"
    [
      {
        ""PartName"": ""crank arm"",
        ""PartId"": 1234
      },
      {
        ""PartName"": ""chain ring"",
        ""PartId"": 1334
      },
      {
        ""PartName"": ""regular seat"",
        ""PartId"": 1434
      },
      {
        ""PartName"": ""banana seat"",
        ""PartId"": 1444
      },
      {
        ""PartName"": ""cassette"",
        ""PartId"": 1534
      },
      {
        ""PartName"": ""shift lever"",
        ""PartId"": 1634
      }
    ]
";

// Deserialize from Json to specified type
var parts = Utils.Json.Deserialize<List<Part>>(partsJson);

// Display the items
foreach (var item in parts) {
    Console.WriteLine($"{item.PartId} - {item.PartName}");
}

// expected output:
/*
    1234 - crank arm
    1334 - chain ring
    1434 - regular seat
    1444 - banana seat
    1534 - cassette
    1634 - shift lever
*/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
				
						// Deserialize - Custom Object List
 
public class Part {
    public string PartName { get; set; }
    public int PartId { get; set; }
}
 
// Declare Json array of objects
var partsJson = @"
    [
      {
        ""PartName"": ""crank arm"",
        ""PartId"": 1234
      },
      {
        ""PartName"": ""chain ring"",
        ""PartId"": 1334
      },
      {
        ""PartName"": ""regular seat"",
        ""PartId"": 1434
      },
      {
        ""PartName"": ""banana seat"",
        ""PartId"": 1444
      },
      {
        ""PartName"": ""cassette"",
        ""PartId"": 1534
      },
      {
        ""PartName"": ""shift lever"",
        ""PartId"": 1634
      }
    ]
";
 
// Deserialize from Json to specified type
var parts = Utils.Json.Deserialize<List<Part>>(partsJson);
 
// Display the items
foreach (var item in parts) {
    Console.WriteLine($"{item.PartId} - {item.PartName}");
}
 
// expected output:
/*
    1234 - crank arm
    1334 - chain ring
    1434 - regular seat
    1444 - banana seat
    1534 - cassette
    1634 - shift lever
*/

7. Utils Namespace

The following is the Utils Namespace. Include this in your project to start using!





		
		
			Utils Namespace
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   May 10, 2021
//    Taken From: http://programmingnotes.org/
//    File:  Utils.cs
//    Description: Handles general utility functions
// ============================================================================
using System;

namespace Utils {
    public static class Json {
        /// <summary>
        /// Serializes the specified value to Json
        /// </summary>
        /// <param name="value">The value to serialize</param> 
        /// <param name="settings">The Newtonsoft.Json.JsonSerializerSettings used to serialize the object</param> 
        /// <returns>The value serialized to Json</returns>
        public static string Serialize(object value
                                    , Newtonsoft.Json.JsonSerializerSettings settings = null) {
            if (settings == null) {
                settings = GetDefaultSettings();
            }
            return Newtonsoft.Json.JsonConvert.SerializeObject(value, settings);
        }

        /// <summary>
        /// Deserializes the specified value from Json to Object T
        /// </summary>
        /// <param name="value">The value to deserialize</param> 
        /// <param name="settings">The Newtonsoft.Json.JsonSerializerSettings used to deserialize the object</param> 
        /// <returns>The value deserialized to Object T</returns>
        public static T Deserialize<T>(string value
                                        , Newtonsoft.Json.JsonSerializerSettings settings = null) {
            if (settings == null) {
                settings = GetDefaultSettings();
            }
            return Newtonsoft.Json.JsonConvert.DeserializeObject<T>(value, settings);
        }

        private static Newtonsoft.Json.JsonSerializerSettings GetDefaultSettings() {
            var settings = new Newtonsoft.Json.JsonSerializerSettings() {
                Formatting = Newtonsoft.Json.Formatting.Indented
            };
            return settings;
        }
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   May 10, 2021
//    Taken From: http://programmingnotes.org/
//    File:  Utils.cs
//    Description: Handles general utility functions
// ============================================================================
using System;
 
namespace Utils {
    public static class Json {
        /// <summary>
        /// Serializes the specified value to Json
        /// </summary>
        /// <param name="value">The value to serialize</param> 
        /// <param name="settings">The Newtonsoft.Json.JsonSerializerSettings used to serialize the object</param> 
        /// <returns>The value serialized to Json</returns>
        public static string Serialize(object value
                                    , Newtonsoft.Json.JsonSerializerSettings settings = null) {
            if (settings == null) {
                settings = GetDefaultSettings();
            }
            return Newtonsoft.Json.JsonConvert.SerializeObject(value, settings);
        }
 
        /// <summary>
        /// Deserializes the specified value from Json to Object T
        /// </summary>
        /// <param name="value">The value to deserialize</param> 
        /// <param name="settings">The Newtonsoft.Json.JsonSerializerSettings used to deserialize the object</param> 
        /// <returns>The value deserialized to Object T</returns>
        public static T Deserialize<T>(string value
                                        , Newtonsoft.Json.JsonSerializerSettings settings = null) {
            if (settings == null) {
                settings = GetDefaultSettings();
            }
            return Newtonsoft.Json.JsonConvert.DeserializeObject<T>(value, settings);
        }
 
        private static Newtonsoft.Json.JsonSerializerSettings GetDefaultSettings() {
            var settings = new Newtonsoft.Json.JsonSerializerSettings() {
                Formatting = Newtonsoft.Json.Formatting.Indented
            };
            return settings;
        }
    }
}// http://programmingnotes.org/

8. More Examples

Below are more examples demonstrating the use of the ‘Utils‘ Namespace. Don’t forget to include the module when running the examples!





		
		
			More Examples
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   May 10, 2021
//    Taken From: http://programmingnotes.org/
//    File:  Program.cs
//    Description: The following demonstrates the use of the Utils Namespace
// ============================================================================
using System;
using System.Diagnostics;
using System.Collections.Generic;

public class Program {

    public class Part {
        public string PartName { get; set; }
        public int PartId { get; set; }
    }

    static void Main(string[] args) {
        try {
            // Declare array of integers 
            var numbers = new int[] { 1987, 19, 22, 2009, 2019, 1991, 28, 31 };

            // Optional: Create the JsonSerializerSettings with optional settings.
            var settings = new Newtonsoft.Json.JsonSerializerSettings() {
                NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore
            };

            // Serialize to Json
            var numbersJson = Utils.Json.Serialize(numbers);

            // Display Json
            Display(numbersJson);

            Display("");

            // Declare list of strings
            var names = new List<string>() {
                "Kenneth",
                "Jennifer",
                "Lynn",
                "Sole"
            };

            // Serialize to Json
            var namesJson = Utils.Json.Serialize(names);

            // Display Json
            Display(namesJson);

            Display("");

            // Declare list of objects
            var parts = new List<Part>() {
                new Part() {
                    PartName = "crank arm",
                    PartId = 1234
                },
                new Part() {
                    PartName = "chain ring",
                    PartId = 1334
                },
                new Part() {
                    PartName = "regular seat",
                    PartId = 1434
                },
                new Part() {
                    PartName = "banana seat",
                    PartId = 1444
                },
                new Part() {
                    PartName = "cassette",
                    PartId = 1534
                },
                new Part() {
                    PartName = "shift lever",
                    PartId = 1634
                }
            };

            // Serialize to Json
            var partsJson = Utils.Json.Serialize(parts);

            // Display Json
            Display(partsJson);

            Display("");

            // Declare Json array of integers
            var numbersJsonTest = @"
                [
                    1987,
                    19,
                    22,
                    2009,
                    2019,
                    1991,
                    28,
                    31
                ]
            ";

            // Deserialize from Json to specified type
            var numbersTest = Utils.Json.Deserialize<int[]>(numbersJsonTest);

            // Display the items
            foreach (var item in numbersTest) { 
                Display($"{item}");
            }

            Display("");

            // Declare Json array of strings
            var namesJsonTest = @"
                [
                    ""Kenneth"",
                    ""Jennifer"",
                    ""Lynn"",
                    ""Sole""
                ]
            ";

            // Deserialize from Json to specified type
            var namesTest = Utils.Json.Deserialize<List<string>>(namesJsonTest);

            // Display the items
            foreach (var item in namesTest) { 
                Display($"{item}");
            }

            Display("");

            // Declare Json array of objects
            var partsJsonTest = @"
                [
                  {
                    ""PartName"": ""crank arm"",
                    ""PartId"": 1234
                  },
                  {
                    ""PartName"": ""chain ring"",
                    ""PartId"": 1334
                  },
                  {
                    ""PartName"": ""regular seat"",
                    ""PartId"": 1434
                  },
                  {
                    ""PartName"": ""banana seat"",
                    ""PartId"": 1444
                  },
                  {
                    ""PartName"": ""cassette"",
                    ""PartId"": 1534
                  },
                  {
                    ""PartName"": ""shift lever"",
                    ""PartId"": 1634
                  }
                ]
            ";

            // Deserialize from Json to specified type
            var partsTest = Utils.Json.Deserialize<List<Part>>(partsJsonTest);

            // Display the items
            foreach (var item in partsTest) {
                Display($"{item.PartId} - {item.PartName}");
            }
        } catch (Exception ex) {
            Display(ex.ToString());
        } finally {
            Console.ReadLine();
        }
    }

    static void Display(string message) {
        Console.WriteLine(message);
        Debug.Print(message);
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   May 10, 2021
//    Taken From: http://programmingnotes.org/
//    File:  Program.cs
//    Description: The following demonstrates the use of the Utils Namespace
// ============================================================================
using System;
using System.Diagnostics;
using System.Collections.Generic;
 
public class Program {
 
    public class Part {
        public string PartName { get; set; }
        public int PartId { get; set; }
    }
 
    static void Main(string[] args) {
        try {
            // Declare array of integers 
            var numbers = new int[] { 1987, 19, 22, 2009, 2019, 1991, 28, 31 };
 
            // Optional: Create the JsonSerializerSettings with optional settings.
            var settings = new Newtonsoft.Json.JsonSerializerSettings() {
                NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore
            };
 
            // Serialize to Json
            var numbersJson = Utils.Json.Serialize(numbers);
 
            // Display Json
            Display(numbersJson);
 
            Display("");
 
            // Declare list of strings
            var names = new List<string>() {
                "Kenneth",
                "Jennifer",
                "Lynn",
                "Sole"
            };
 
            // Serialize to Json
            var namesJson = Utils.Json.Serialize(names);
 
            // Display Json
            Display(namesJson);
 
            Display("");
 
            // Declare list of objects
            var parts = new List<Part>() {
                new Part() {
                    PartName = "crank arm",
                    PartId = 1234
                },
                new Part() {
                    PartName = "chain ring",
                    PartId = 1334
                },
                new Part() {
                    PartName = "regular seat",
                    PartId = 1434
                },
                new Part() {
                    PartName = "banana seat",
                    PartId = 1444
                },
                new Part() {
                    PartName = "cassette",
                    PartId = 1534
                },
                new Part() {
                    PartName = "shift lever",
                    PartId = 1634
                }
            };
 
            // Serialize to Json
            var partsJson = Utils.Json.Serialize(parts);
 
            // Display Json
            Display(partsJson);
 
            Display("");
 
            // Declare Json array of integers
            var numbersJsonTest = @"
                [
                    1987,
                    19,
                    22,
                    2009,
                    2019,
                    1991,
                    28,
                    31
                ]
            ";
 
            // Deserialize from Json to specified type
            var numbersTest = Utils.Json.Deserialize<int[]>(numbersJsonTest);
 
            // Display the items
            foreach (var item in numbersTest) { 
                Display($"{item}");
            }
 
            Display("");
 
            // Declare Json array of strings
            var namesJsonTest = @"
                [
                    ""Kenneth"",
                    ""Jennifer"",
                    ""Lynn"",
                    ""Sole""
                ]
            ";
 
            // Deserialize from Json to specified type
            var namesTest = Utils.Json.Deserialize<List<string>>(namesJsonTest);
 
            // Display the items
            foreach (var item in namesTest) { 
                Display($"{item}");
            }
 
            Display("");
 
            // Declare Json array of objects
            var partsJsonTest = @"
                [
                  {
                    ""PartName"": ""crank arm"",
                    ""PartId"": 1234
                  },
                  {
                    ""PartName"": ""chain ring"",
                    ""PartId"": 1334
                  },
                  {
                    ""PartName"": ""regular seat"",
                    ""PartId"": 1434
                  },
                  {
                    ""PartName"": ""banana seat"",
                    ""PartId"": 1444
                  },
                  {
                    ""PartName"": ""cassette"",
                    ""PartId"": 1534
                  },
                  {
                    ""PartName"": ""shift lever"",
                    ""PartId"": 1634
                  }
                ]
            ";
 
            // Deserialize from Json to specified type
            var partsTest = Utils.Json.Deserialize<List<Part>>(partsJsonTest);
 
            // Display the items
            foreach (var item in partsTest) {
                Display($"{item.PartId} - {item.PartName}");
            }
        } catch (Exception ex) {
            Display(ex.ToString());
        } finally {
            Console.ReadLine();
        }
    }
 
    static void Display(string message) {
        Console.WriteLine(message);
        Debug.Print(message);
    }
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Was this article helpful?

👍 YesNo

Posted in: C#, Console Tags: c-sharp, json

C# || How To Serialize & Deserialize JSON Using C#

Related

Leave a ReplyCancel reply

Search

Compile Your Code Now

Translate Page

Popular Pages

Recent

Archives

Categories