JSON to C# Class Generator

JSON in the .NET Ecosystem

JSON is the universal data format for .NET applications. Whether you are building a ASP.NET Core web API, a Blazor frontend, a MAUI mobile app, or a Azure Function, you will spend a significant portion of your time working with JSON - parsing API responses, deserializing request bodies, reading configuration, and serializing data for external services.

The standard approach in C# is to define a class whose properties map to the JSON keys, then use a serialization library to convert between the class instance and the JSON string. This gives you full IntelliSense support, compile-time type checking, and clean code that is easy to maintain and test.

A C# class generated from a JSON user object looks like this:

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
    public bool IsActive { get; set; }
    public Address Address { get; set; }
}

public class Address
{
    public string Street { get; set; }
    public string City { get; set; }
    public string ZipCode { get; set; }
}

Writing these classes manually for every API integration is tedious and introduces typos. This generator automates the process: paste your JSON, get your C# classes instantly.

Newtonsoft.Json vs System.Text.Json

There are two major JSON serialization libraries in .NET, and choosing the right one determines which attributes you add to your generated classes.

Newtonsoft.Json (Json.NET) has been the industry standard for over a decade. It supports a wider range of scenarios including polymorphic deserialization, custom converters, and LINQ to JSON. Add it via NuGet: dotnet add package Newtonsoft.Json. Key attributes:

• [JsonProperty("field_name")] - Maps a JSON key to a differently named C# property
• [JsonIgnore] - Excludes a property from serialization
• [JsonConverter(typeof(...))] - Specifies a custom converter for a property

System.Text.Json is the built-in library in .NET Core 3.0+ and .NET 5+. It is faster and allocates less memory than Newtonsoft.Json, and requires no external package. It is the recommended choice for new projects. Key attributes:

• [JsonPropertyName("field_name")] - Maps a JSON key to a C# property name
• [JsonIgnore] - Excludes a property from serialization
• [JsonConverter(typeof(...))] - Specifies a custom converter

If your project is on .NET Framework or uses legacy libraries that depend on Newtonsoft.Json, stick with Json.NET. For .NET 6, .NET 7, .NET 8, or .NET 9 projects without legacy constraints, System.Text.Json is the better choice for performance-critical paths.

How to Use the JSON to C# Generator

Generating C# classes from JSON is a straightforward process with this tool:

1. Get a sample JSON payload from your API, test data, or documentation
2. Click "Open JSON to C# Generator" above to launch the tool
3. Paste the JSON into the input field
4. Select your preferred library style: plain C#, Newtonsoft.Json, or System.Text.Json
5. The generator outputs ready-to-use C# class definitions
6. Copy the classes into your Visual Studio or VS Code project
7. Add the appropriate using statement and start deserializing

The generator follows C# naming conventions: JSON keys in snake_case or camelCase are converted to PascalCase C# property names. When the property name differs from the JSON key, the appropriate attribute ([JsonProperty] or [JsonPropertyName]) is automatically added.

Common C# JSON Patterns

Working with JSON in C# follows several well-established patterns that the generated classes support out of the box.

Records (C# 9+) - Instead of classes, you can use records for immutable data models:

public record User(
    int Id,
    string Name,
    string Email
);

Nullable reference types (C# 8+) - Enable NRT in your project to get compile-time null safety. Properties that may be null in JSON should be declared as string? instead of string.

DTOs vs domain models - It is good practice to keep your JSON classes (DTOs) separate from your domain models and map between them using AutoMapper or manual mapping. This protects your domain model from changes in external API schemas.

List vs array - JSON arrays can be deserialized into either List<T> or T[]. Use List<T> when you need to modify the collection, and arrays when immutability and memory efficiency are priorities.

Frequently Asked Questions

How do I deserialize JSON to a C# class?

With Newtonsoft.Json: var obj = JsonConvert.DeserializeObject<MyClass>(jsonString);. With System.Text.Json: var obj = JsonSerializer.Deserialize<MyClass>(jsonString);. Both methods require a C# class that matches the JSON structure. Use this tool to generate the class from your JSON, then paste it into your project before calling deserialization. For async HTTP responses, use JsonSerializer.DeserializeAsync<MyClass>(stream) with System.Text.Json for best performance.

What is the difference between Newtonsoft.Json and System.Text.Json?

Newtonsoft.Json (Json.NET) is the mature, feature-rich library that dominated .NET JSON processing for over a decade. It supports complex scenarios like polymorphic deserialization, circular reference handling, and has a large ecosystem of extensions. System.Text.Json is the modern built-in library shipped with .NET Core 3.0+. It is significantly faster, allocates less memory, and requires no NuGet package. For greenfield .NET 6/7/8/9 projects, System.Text.Json is the recommended default. Legacy projects on .NET Framework or relying on Newtonsoft-specific features should stay with Json.NET.

How are nullable types handled in generated C# classes?

Reference types (string, nested classes, arrays) are inherently nullable in C# without NRT enabled. When a JSON field can be null or absent, value types are generated as nullable value types: int?, bool?, double?. If your project has nullable reference types enabled (via <Nullable>enable</Nullable> in the csproj), annotate optional string properties as string? and add = null! or = default! initializers to required string properties to suppress CS8618 warnings.

How are nested JSON objects handled in C# class generation?

Each nested JSON object generates a separate C# class. A JSON field "address": {"street": "...", "city": "..."} produces an Address class and a property public Address Address { get; set; } in the parent class. Arrays of objects become List<T> properties where T is the generated nested class. All classes are output together so you can copy the entire block into a single C# file or split them into separate files as needed.