Logo
Back

Is there a way to deserialize JSON content into a C# dynamic type?

Yes, you can! In C#, you can leverage dynamic to handle JSON objects whose structure isn’t fully known at compile time. This is especially convenient for rapid prototyping, parsing external APIs with unpredictable data, or when you simply don’t want to define strict classes. Below are two popular ways to approach this.

1. Using Newtonsoft.Json (Json.NET)

Newtonsoft.Json—commonly referred to as “Json.NET”—makes dynamic deserialization straightforward:

using Newtonsoft.Json;
using System;

class Program
{
    static void Main()
    {
        string jsonString = @"{
            'name': 'Alice',
            'age': 25,
            'languages': ['C#', 'JavaScript', 'Python']
        }";

        dynamic data = JsonConvert.DeserializeObject<dynamic>(jsonString);
        
        // Access properties dynamically
        Console.WriteLine($"Name: {data.name}");
        Console.WriteLine($"Age: {data.age}");
        Console.WriteLine($"First Language: {data.languages[0]}");
    }
}

What’s Happening Here?

  • JsonConvert.DeserializeObject<dynamic>(jsonString) tells Json.NET to parse the JSON into a dynamic object.
  • You can access properties like data.name or data.age without explicit type definitions.
  • Arrays also work as expected with data.languages[i].

Pros

  • Flexible and quick to implement.
  • Minimal boilerplate—no need for dedicated data-transfer objects (DTOs).

Cons

  • Less compile-time safety—typos or incorrect property names will only be caught at runtime.
  • Harder to refactor or maintain large codebases.

2. Using System.Text.Json with ExpandoObject

Starting with .NET 5 and later, you can use System.Text.Json for many JSON tasks. Although it doesn’t directly support dynamic the way Newtonsoft.Json does, you can deserialize into an ExpandoObject, which essentially behaves like a dynamic object:

using System;
using System.Text.Json;
using System.Dynamic;

class Program
{
    static void Main()
    {
        string jsonString = @"{
            ""name"": ""Bob"",
            ""age"": 30,
            ""languages"": [""C#"", ""Go"", ""TypeScript""]
        }";

        var options = new JsonSerializerOptions
        {
            PropertyNameCaseInsensitive = true
        };

        dynamic data = JsonSerializer.Deserialize<ExpandoObject>(jsonString, options);

        Console.WriteLine($"Name: {data.name}");
        Console.WriteLine($"Age: {data.age}");
        Console.WriteLine($"Second Language: {data.languages[1]}");
    }
}

What’s Happening Here?

  • JsonSerializer.Deserialize<ExpandoObject>: Converts your JSON into an ExpandoObject.
  • dynamic data: Tells the compiler that we’ll treat data’s properties and methods dynamically.
  • PropertyNameCaseInsensitive = true: Allows you to access properties even if the JSON property names don’t match C# casing conventions.

Pros

  • Leverages the modern, built-in JSON library (no extra NuGet for most .NET projects).
  • Good performance for many scenarios.

Cons

  • A bit more manual work compared to Newtonsoft.Json, especially if you need advanced configuration.
  • Dynamic usage still means no compile-time checking for property names.

When to Use Dynamic Deserialization

  1. Prototyping: Quick experiments or working with unstructured data.
  2. 3rd-Party APIs: If the payload frequently changes or is only partially documented, going dynamic can save time.
  3. Rapid Iteration: In early stages, you might not have your final data model designed, so dynamic parsing can be a stopgap.

However, for production-ready applications, it’s often better to define robust data-transfer objects (DTOs). Strongly typed DTOs give you compile-time checks, easier refactoring, and more transparent maintainability.

Strengthen Your C# and Coding Skills

Working with JSON dynamically is handy, but building maintainable, high-performing applications requires a deeper grasp of coding best practices. If you’re honing your C# or preparing for technical interviews, here are two courses from DesignGurus.io you might find valuable:

Final Thoughts

Yes, you can deserialize JSON into a dynamic type in C#. Depending on your project’s needs, you might choose the tried-and-true Newtonsoft.Json approach or the built-in System.Text.Json combined with ExpandoObject. Both methods let you skip explicit class definitions—perfect for when you need speed and flexibility in parsing.

That said, dynamic objects can introduce maintenance challenges in the long run, so balance ease-of-use with maintainability. As your application scales, transitioning to strongly typed classes usually becomes the better practice.

CONTRIBUTOR
TechGrind