C# Mastery: Mastering JSON-to-Class Generation for .NET

JSON to C# Class: Generating Strongly-Typed Models from JSON

Every .NET API integration starts the same way: you have a JSON payload and you need a C# class to deserialize it into. Writing those classes by hand — matching property names, inferring types, marking nullables — is mechanical work that should be automated. Generating C# classes from JSON gives you a correct starting point in seconds, with [Required] annotations inferred from your data and nullable reference types handled correctly.

Live Example: API Response to C# Classes

// Input JSON
{
  "order_id": "ord_7821",
  "customer": {
    "name": "Jane Smith",
    "email": "jane@example.com",
    "loyalty_tier": null
  },
  "items": [
    { "sku": "WDG-001", "quantity": 3, "unit_price": 19.99 }
  ],
  "placed_at": "2024-11-15T14:30:00Z",
  "notes": null
}

// Generated C# Classes
using System.ComponentModel.DataAnnotations;

public class Customer
{
    [Required]
    public string Name { get; set; }
    [Required]
    public string Email { get; set; }
    public string? LoyaltyTier { get; set; }
}

public class Item
{
    [Required]
    public string Sku { get; set; }
    [Required]
    public int Quantity { get; set; }
    [Required]
    public double UnitPrice { get; set; }
}

public class Root
{
    [Required]
    public string OrderId { get; set; }
    [Required]
    public Customer Customer { get; set; }
    [Required]
    public List<Item> Items { get; set; }
    [Required]
    public string PlacedAt { get; set; }
    public string? Notes { get; set; }
}

snake_case JSON vs PascalCase C# Properties

REST APIs commonly use snake_case or camelCase in JSON, while C# convention is PascalCase. The generated classes use PascalCase for all properties. To deserialize correctly from a snake_case API, add a naming policy:

// System.Text.Json (recommended in .NET 6+)
var options = new JsonSerializerOptions
{
    PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower
};
var order = JsonSerializer.Deserialize<Root>(json, options);

// Or per-property with [JsonPropertyName]
public class Item
{
    [JsonPropertyName("unit_price")]
    public double UnitPrice { get; set; }
}

// Newtonsoft.Json equivalent
[JsonProperty("unit_price")]
public double UnitPrice { get; set; }

For greenfield projects, configure the naming policy globally at startup rather than decorating every property.

Nullable Reference Types and [Required]

The generator infers nullability from your JSON sample: fields present with a non-null value get [Required]; fields that are null in the sample become T?. With C# 8+ nullable reference types enabled (<Nullable>enable</Nullable> in your csproj), this distinction is enforced at compile time:

// Required field — must be provided
[Required]
public string Name { get; set; }

// Nullable field — may be absent or null
public string? LoyaltyTier { get; set; }

Always generate from the most complete JSON sample available. A sparse sample will mark fields as nullable that are actually always present in production, weakening your type safety.

Date and DateTime Fields

JSON has no native date type — timestamps arrive as ISO 8601 strings. The generated class represents them as string, which is accurate at the deserialization boundary. Swap them for DateTime or DateTimeOffset in your domain model:

// At the API boundary (generated class)
public class OrderDto
{
    public string PlacedAt { get; set; }
}

// In your domain model
public class Order
{
    public DateTimeOffset PlacedAt { get; set; }
}

// System.Text.Json handles ISO 8601 natively
// Just change the property type to DateTimeOffset:
public class Root
{
    [JsonPropertyName("placed_at")]
    public DateTimeOffset PlacedAt { get; set; }
}

DateTimeOffset is preferred over DateTime for API data because it preserves timezone offset information from the ISO string.

After Generation: What to Review

The generated class is a starting point, not a finished product. Check these before committing:

• Numeric precision: The generator uses double for decimal values. For monetary amounts, switch to decimal to avoid floating-point rounding errors.
• Integer vs double: JSON doesn't distinguish integers from floats — 3 and 3.0 look the same. Verify that count, quantity, and ID fields are int or long, not double.
• Enums: String fields with a fixed set of values (status codes, types) are better modeled as enum than string. The generator uses string as a safe default.
• Root class name: Rename Root to reflect what the object actually is — OrderResponse, UserProfile, etc.

Frequently Asked Questions

Does it handle nested objects and arrays? Yes. Nested objects become separate classes, and JSON arrays become List<T> properties. The full object graph is generated in one pass.

Should I use System.Text.Json or Newtonsoft.Json? System.Text.Json ships with .NET 6+ and is faster. Newtonsoft.Json has more features (custom converters, LINQ-to-JSON). Generated classes work with both — the difference is only in serialization attributes and configuration.

Is my JSON sent to a server? No. TypeMorph processes everything locally in your browser. No data leaves your machine.

What about inheritance? When TypeMorph detects shared fields across multiple sibling objects, it generates a common base class automatically.