Convert C# Objects to JSON: A Step‑by‑Step Developer Guide

JSON (JavaScript Object Notation) is one of the most widely used data formats for exchanging information between applications, particularly in web services and APIs. As a C# developer, understanding how to efficiently convert objects to JSON is essential for building modern applications.

In this guide, we'll explore various techniques for serializing and deserializing C# objects into JSON, covering:

  • The built-in System.Text.Json namespace

  • The popular Newtonsoft.Json (Json.NET) library

  • Best practices for JSON serialization

  • Handling complex objects and special cases

  • Performance considerations

Let's dive in!

1. Using System.Text.Json for JSON Serialization

With .NET Core 3.0 and later, Microsoft introduced System.Text.Json, a high-performance, lightweight alternative to Newtonsoft.Json.

1.1 Basic Serialization

The JsonSerializer class in System.Text.Json is used to convert C# objects to JSON.

using System;
using System.Text.Json;

class Program
{
    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }

    static void Main()
    {
        var person = new Person { Name = "John Doe", Age = 30 };
        string jsonString = JsonSerializer.Serialize(person);
        Console.WriteLine(jsonString);
    }
}

Output:

{"Name":"John Doe","Age":30}

1.2 Customizing JSON Output

You can customize JSON output using JsonSerializerOptions.

JsonSerializerOptions options = new JsonSerializerOptions
{
    WriteIndented = true,
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
};

string jsonString = JsonSerializer.Serialize(person, options);
Console.WriteLine(jsonString);

Indented Output:

{
  "name": "John Doe",
  "age": 30
}

1.3 Ignoring Properties

Use [JsonIgnore] to exclude properties from serialization.

public class Employee
{
    public string Name { get; set; }
    public int Age { get; set; }
    [JsonIgnore] public string SSN { get; set; }
}

2. Using Newtonsoft.Json (Json.NET) for JSON Serialization

Newtonsoft.Json is a widely used library for handling JSON in C# and provides more flexibility than System.Text.Json.

2.1 Basic Serialization with Newtonsoft.Json

using Newtonsoft.Json;

var person = new Person { Name = "Jane Doe", Age = 25 };
string jsonString = JsonConvert.SerializeObject(person);
Console.WriteLine(jsonString);

2.2 Formatting JSON Output

string formattedJson = JsonConvert.SerializeObject(person, Formatting.Indented);
Console.WriteLine(formattedJson);

2.3 Ignoring Properties with Newtonsoft.Json

public class Customer
{
    public string Name { get; set; }
    public int Age { get; set; }
    [JsonIgnore] public string Password { get; set; }
}

3. Handling Complex Objects and Collections

3.1 Serializing Lists

var people = new List<Person>
{
    new Person { Name = "Alice", Age = 28 },
    new Person { Name = "Bob", Age = 35 }
};

string jsonArray = JsonSerializer.Serialize(people);
Console.WriteLine(jsonArray);

3.2 Serializing Dictionaries

var dictionary = new Dictionary<string, string>
{
    { "FirstName", "John" },
    { "LastName", "Doe" }
};

string jsonDictionary = JsonSerializer.Serialize(dictionary);
Console.WriteLine(jsonDictionary);

4. Best Practices for JSON Serialization in C#

4.1 Use System.Text.Json for Performance

  • System.Text.Json is faster and more memory-efficient than Newtonsoft.Json.

  • Use JsonSerializerOptions to control output format.

4.2 Handle Null Values Gracefully

JsonSerializerOptions options = new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull };

4.3 Use Camel Case Naming for API Consistency

options.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;

4.4 Avoid Serializing Sensitive Information

Use [JsonIgnore] or custom DTOs to exclude sensitive data like passwords.

4.5 Optimize Large JSON Objects with Streaming

For large JSON objects, consider using Utf8JsonWriter for efficient streaming serialization.

using var stream = new MemoryStream();
using var writer = new Utf8JsonWriter(stream);
writer.WriteStartObject();
writer.WriteString("Name", "John Doe");
writer.WriteNumber("Age", 30);
writer.WriteEndObject();
writer.Flush();

string jsonString = Encoding.UTF8.GetString(stream.ToArray());
Console.WriteLine(jsonString);

Conclusion

Converting C# objects to JSON is a crucial skill for modern application development. System.Text.Json provides a high-performance alternative to Newtonsoft.Json, but both libraries have their own strengths.

By following best practices, such as handling null values, ignoring sensitive data, and optimizing serialization performance, you can ensure efficient JSON processing in your applications.

If you're building APIs, microservices, or working with external JSON data, mastering these techniques will enhance your development workflow.

What’s Next?

  • Explore JSON deserialization techniques in C#.

  • Learn about custom converters for advanced serialization needs.

  • Optimize JSON handling in ASP.NET Core applications.

Further Reading