How to Parse JSON in C#: A Comprehensive Guide with Examples

JSON (JavaScript Object Notation) has become the de facto standard for data interchange on the web due to its lightweight nature and human-readability. As a C# developer, mastering JSON parsing is crucial for interacting with web APIs, configuration files, and various other data sources. This guide will walk you through how to parse JSON in C#, covering both the built-in System.Text.Json library and the popular third-party Newtonsoft.Json (Json.NET).

Understanding JSON Structure

Before diving into parsing, let’s quickly review a typical JSON structure:

{
  "name": "Alice",
  "age": 30,
  "isStudent": false,
  "courses": [
    {
      "title": "History",
      "credits": 3
    },
    {
      "title": "Math",
      "credits": 4
    }
  ]
}

Method 1: Parsing JSON with System.Text.Json (Built-in for .NET Core/.NET 5+)

System.Text.Json is Microsoft’s high-performance, low-allocation JSON library built into .NET Core and .NET 5+. It’s the recommended approach for modern .NET applications.

Step 1: Define a C# Class for Your JSON Structure

To deserialize JSON into a strongly-typed object, you’ll first create C# classes that mirror your JSON structure.

public class Course
{
    public string Title { get; set; }
    public int Credits { get; set; }
}

public class UserProfile
{
    public string Name { get; set; }
    public int Age { get; set; }
    public bool IsStudent { get; set; }
    public List<Course> Courses { get; set; }
}

Step 2: Deserialize the JSON String

Use the JsonSerializer.Deserialize<T> method to convert your JSON string into an instance of your C# class.

using System;
using System.Collections.Generic;
using System.Text.Json;

public class Program
{
    public static void Main(string[] args)
    {
        string jsonString = @"{
            ""name"": ""Alice"",
            ""age"": 30,
            ""isStudent"": false,
            ""courses"": [
                {
                    ""title"": ""History"",
                    ""credits"": 3
                },
                {
                    ""title"": ""Math"",
                    ""credits"": 4
                }
            ]
        }";

        UserProfile profile = JsonSerializer.Deserialize<UserProfile>(jsonString);

        Console.WriteLine($"Name: {profile.Name}");
        Console.WriteLine($"Age: {profile.Age}");
        Console.WriteLine($"Is Student: {profile.IsStudent}");
        Console.WriteLine("Courses:");
        foreach (var course in profile.Courses)
        {
            Console.WriteLine($"- {course.Title} ({course.Credits} credits)");
        }
    }
}

For more complex scenarios or when you don’t know the exact structure beforehand, you can also use JsonDocument for DOM-like navigation.

Method 2: Parsing JSON with Newtonsoft.Json (Json.NET)

Newtonsoft.Json, often referred to as Json.NET, is a powerful and widely used third-party JSON framework for .NET. It offers a rich set of features and excellent performance, especially in older .NET Framework projects or when specific advanced features are required.

Step 1: Install Newtonsoft.Json

You need to install the NuGet package for Newtonsoft.Json:

Install-Package Newtonsoft.Json

Step 2: Define C# Classes (Same as System.Text.Json)

The C# classes you define to match your JSON structure remain the same, as they are POCOs (Plain Old C# Objects).

// Re-using the same Course and UserProfile classes from Method 1
public class Course
{
    public string Title { get; set; }
    public int Credits { get; set; }
}

public class UserProfile
{
    public string Name { get; set; }
    public int Age { get; set; }
    public bool IsStudent { get; set; }
    public List<Course> Courses { get; set; }
}

Step 3: Deserialize the JSON String

Use the JsonConvert.DeserializeObject<T> method from Newtonsoft.Json.

using System;
using System.Collections.Generic;
using Newtonsoft.Json; // Don't forget this!

public class Program
{
    public static void Main(string[] args)
    {
        string jsonString = @"{
            ""name"": ""Bob"",
            ""age"": 25,
            ""isStudent"": true,
            ""courses"": [
                {
                    ""title"": ""Physics"",
                    ""credits"": 5
                }
            ]
        }";

        UserProfile profile = JsonConvert.DeserializeObject<UserProfile>(jsonString);

        Console.WriteLine($"Name: {profile.Name}");
        Console.WriteLine($"Age: {profile.Age}");
        Console.WriteLine($"Is Student: {profile.IsStudent}");
        Console.WriteLine("Courses:");
        foreach (var course in profile.Courses)
        {
            Console.WriteLine($"- {course.Title} ({course.Credits} credits)");
        }
    }
}

Newtonsoft.Json also provides a powerful JObject/JArray API for dynamic parsing without strong types.

Which JSON Parser Should You Use?

System.Text.Json:
- Built-in for .NET Core/.NET 5+ and newer.
- High performance and low memory allocation.
- Recommended for new applications and those targeting modern .NET.
- Less feature-rich out-of-box compared to Json.NET, but actively being developed.
Newtonsoft.Json:
- Industry standard for many years, especially for .NET Framework.
- Feature-rich (LINQ to JSON, custom converters, diverse serialization settings).
- Excellent for complex serialization/deserialization scenarios.
- Consider if you’re on .NET Framework or need specific advanced features not yet available in System.Text.Json.

Conclusion

Whether you choose System.Text.Json for its modern performance and integration or Newtonsoft.Json for its mature feature set, C# provides robust tools for handling JSON data. By following the examples in this guide, you can effectively parse JSON strings into strongly-typed objects, making your C# applications more robust and capable of interacting with a wide range of data sources. Implement these techniques to efficiently manage data in your projects and enhance your application’s SEO by structuring your data effectively.

C# JSON Parser Bridge

This infographic details the two core functions performed by the C# JSON Parser, acting as a bridge between application code and external data formats. The parser shown is the System.Text.Jusn (referring to System.Text.Json).

1. Deserialization: JSON $\to$ C# Object (Incoming Data) 📥

This process converts raw JSON text received from external sources into usable, strongly-typed C# objects.

Step	Data Format	Description
Input	Raw JSON String	The data is received as text (e.g., `(id: 101, price 49.99)`).
Parser Action	C# JSON Parser	The parser reads the string, validates the format, and maps the properties to the C# class members.
Output	Instantiated C# Object	A fully populated object is created (e.g., `Product product = new Product { Id = 101, Price = 49.99 }`).
Key Code	N/A	The operation is executed using: `JsonSerializer.Deserrlite<Product>(jsonString);`.

2. Serialization: C# Object $\to$ JSON (Outgoing Data) 📤

This process converts internal C# objects into a raw JSON string suitable for transmission over a network or for storage.

Step	Data Format	Description
Input	C# Object	A populated C# object from application logic (e.g., `User userObject = a User Name = "Alice" "Admin"`).
Parser Action	C# JSON Parser	The parser reads the object’s properties and values and formats them into the JSON text structure.
Output	JSON String	A string ready for output (e.g., `(name = "rdmin")`).
Key Code	N/A	The operation is executed using: `string jsonString = JsonSerializer<Serlize<(jsonString);`.