JSON a C#

Relacionats

About JSON to C#: Turning JSON data into compilable C# POCO classes

Casos d'ús

• ASP.NET Core Web API: Convert example JSON from OpenAPI / Swagger docs to DTO classes, receive frontend requests with [FromBody] model binding
• ASP.NET Core MVC: Convert form/JSON request bodies to strongly-typed Models with automatic ModelState validation
• Newtonsoft.Json deserialization: Convert third-party interface response JSON to POCO classes with [JsonProperty], no manual field mapping needed
• System.Text.Json high-performance scenarios: Convert JSON to record types or init-only properties with JsonSerializer.Deserialize<T> for faster startup
• Unity game scripts: Convert JSON returned by network APIs (player data, level config, shop items, leaderboards) to serializable ScriptableObject data models
• .NET MAUI cross-platform apps: Convert backend API JSON to Model classes for XAML data binding, sharing business models across iOS / Android / Windows
• Blazor Server / WebAssembly: Convert API JSON to strongly-typed component parameters / server models, consuming shared frontend-backend types with @inject HttpClient
• Entity Framework Core: Convert JSON documents exported from databases to entity classes as reference base classes for EF Core model migrations, with [Key] / [Required] data annotations
• Azure Functions / AWS Lambda: Convert Event Grid / SNS / API Gateway / Cosmos DB trigger event JSON to strongly-typed event parameters, simplifying serverless function signatures
• SignalR real-time communication: Convert server-pushed JSON messages (chat, notifications, market data, IoT) to C# types for strongly-typed consumption in Hub methods
• Microservice interface contracts: Convert inter-service RPC (gRPC-Web / HTTP / WCF) JSON request/response examples to C# classes as shared contract definitions across teams
• Config file loading: Convert appsettings.json substructures to Options pattern classes (e.g., MyOptions : IOptions<MyOptions> with IConfiguration.Bind)
• Test data preparation: Convert JSON fixtures to C# classes then deserialize with Newtonsoft / System.Text.Json for unit test driving, with xUnit / NUnit / MSTest
• Web crawler data parsing: Convert JSON data scraped by HtmlAgilityPack / AngleSharp / PuppeteerSharp to C# classes, avoiding missing fields from dynamic JObject access
• API documentation writing: Embed C# class examples as schema definitions in Swagger / OpenAPI docs, ReDoc, Knife4j, Swagger UI for better documentation readability
• Code review collaboration: Convert API response JSON directly to readable POCOs for easier discussion of field naming, type selection, and annotation usage during Code Review
• Legacy project refactoring: Refactor dynamic JObject / Dictionary<string, object> based access to strongly-typed POCO access, improving compile-time type checking and maintainability
• Teaching & training: Convert sample JSON to POCO in C# courses / .NET introductory teaching to demonstrate object-oriented modeling, property accessors, and serialization principles

Com usar-ho

1. Paste JSON content in the left editor, or click the upload button to select .json / .txt files, or click the example button to load built-in data
2. Wait 400ms for auto-conversion; the right side shows generated C# POCO class code
3. If JSON format errors occur, click the 'Fix JSON' button to auto-repair common syntax issues then reconvert
4. Click the 'Copy' button to copy an individual class to the clipboard and paste into Visual Studio / Rider / VS Code, or click 'Download' to save as .cs file

Característiques

• Pure browser-local generation: JSON parsing and C# code generation all done in-browser via JavaScript + quicktype-core, input data never uploaded to any server
• POCO + record dual modes: defaults to serializable POCO class, one-click switch to C# 9+ record types matching modern .NET coding style
• Newtonsoft [JsonProperty] annotations: each field auto-generates [JsonProperty("original key")], compatible with Newtonsoft.Json default behavior; PascalCase field names don't affect deserialization
• Automatic nested object splitting: JSON nested objects recursively generated as independent C# classes, named by capitalizing the field name (e.g., address → Address), avoiding type duplication
• List generics auto-expansion: JSON arrays automatically converted to List<T>, T auto-inferred from first array element (["a","b"] → List<string>, [{...}] → List<Item>)
• Nullable<T> auto-inference: JSON null value fields automatically marked as Nullable<T> (e.g., long? / string? / bool?), avoiding null reference exceptions at compile time
• PascalCase field naming: snake_case input automatically converted to PascalCase (e.g., user_name → UserName), while [JsonProperty] annotations retain original keys for deserialization compatibility
• Multiple value type mappings: string → string, integer → long, float → double, bool → bool, array → List<T>, null → Nullable<T>
• Complete .cs template: generates standard C# files including using System.Collections.Generic; + namespace + public class + fields + properties, directly compilable
• Copy & download: one-click copy of individual classes to clipboard, or download as .cs files directly dragged into Visual Studio / Rider / VS Code
• One-click JSON error repair: automatically fixes common format errors like trailing commas, single quotes, missing quotes, continuing C# code generation after successful repair
• Local history: auto-saves recent inputs based on localStorage, quickly recovers to continue editing after refresh or accidental page close

Exemples de codi

using Newtonsoft.Json;
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class ApiClient
{
    private static readonly HttpClient _http = new HttpClient();

    // POCO generated by this tool:
    public class User
    {
        [JsonProperty("id")]
        public long Id { get; set; }

        [JsonProperty("name")]
        public string Name { get; set; }

        [JsonProperty("email")]
        public string Email { get; set; }

        [JsonProperty("is_active")]
        public bool? IsActive { get; set; }
    }

    public static async Task<User> GetUserAsync(int userId)
    {
        // 1) Call API to get JSON string
        var json = await _http.GetStringAsync($"https://api.example.com/users/{userId}");

        // 2) Deserialize to POCO generated by this tool
        //    Internally maps snake_case JSON via [JsonProperty("id")] etc. annotations
        var user = JsonConvert.DeserializeObject<User>(json);

        Console.WriteLine($"User: {user.Name} ({user.Email})");
        return user;
    }
}

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using System.Linq;

// POCO generated by this tool (defaults to Newtonsoft [JsonProperty]):
public class CreateOrderRequest
{
    [Newtonsoft.Json.JsonProperty("user_id")]
    public long UserId { get; set; }

    [Newtonsoft.Json.JsonProperty("items")]
    public List<OrderItem> Items { get; set; }
}

public class OrderItem
{
    [Newtonsoft.Json.JsonProperty("product_id")]
    public long ProductId { get; set; }

    [Newtonsoft.Json.JsonProperty("quantity")]
    public long Quantity { get; set; }
}

[ApiController]
[Route("api/[controller]")]
public class OrdersController : ControllerBase
{
    [HttpPost]
    public IActionResult Create([FromBody] CreateOrderRequest request)
    {
        if (request == null || request.Items == null || !request.Items.Any())
        {
            return BadRequest("Items cannot be empty");
        }

        // Business logic: save order
        // var order = OrderService.Create(request);

        return Ok(new { order_id = 12345, status = "created" });
    }
}

/*
 * Corresponding .csproj dependencies:
 * <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="7.0.0" />
 * <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
 */

using System.Net.Http.Json;
using System.Text.Json.Serialization;
using System.Threading.Tasks;

// This tool defaults to generating POCO class; manually change to record type below (immutable data carrier):
public record User
{
    [JsonPropertyName("id")]
    public long Id { get; init; }

    [JsonPropertyName("name")]
    public string Name { get; init; }

    [JsonPropertyName("email")]
    public string Email { get; init; }

    [JsonPropertyName("is_active")]
    public bool? IsActive { get; init; }
}

public class ApiClient
{
    private static readonly HttpClient _http = new HttpClient();

    public static async Task<User> GetUserAsync(int userId)
    {
        // System.Text.Json: GetFromJsonAsync accomplishes HTTP + deserialization in one line
        var user = await _http.GetFromJsonAsync<User>(
            $"https://api.example.com/users/{userId}");

        System.Console.WriteLine($"User: {user.Name} ({user.Email})");
        return user;
    }
}

/*
 * Corresponding .csproj dependencies (System.Text.Json is built-in, no extra installation needed):
 * <TargetFramework>net7.0</TargetFramework>
 *
 * If your project is .NET 7+ and you want to use [JsonProperty] compatible with Newtonsoft syntax,
 * add in Program.cs:
 *   builder.Services.AddControllers()
 *       .AddNewtonsoftJson(options =>
 *       {
 *           options.SerializerSettings.ContractResolver =
 *               new Newtonsoft.Json.Serialization.DefaultContractResolver();
 *       });
 */

Best Practices

Preguntes freqients

Solució de problemes

Glossari

POCO (Plain Old CLR Object)

Abbreviation for 'Plain Old CLR Object' in C# / .NET, constrained to: public default constructor + private fields + public { get; set; } properties + no framework dependencies. This tool generates standard POCOs.

record

Immutable data carrier type introduced in C# 9+, using value equality rather than reference equality. Can be manually changed to record after generation, suitable for DTOs, API response models, immutable configurations, etc.

[JsonProperty]

Newtonsoft.Json's field mapping attribute; this tool defaults to adding [JsonProperty("original key")] for each field, ensuring PascalCase field names correctly deserialize snake_case JSON.

Newtonsoft.Json

Also known as Json.NET, the most popular JSON library in the .NET ecosystem with the richest ecosystem and best compatibility, supported by almost all .NET projects. Default before ASP.NET Core 3.0; System.Text.Json became default after 3.0 but Newtonsoft remains compatible via NuGet packages.

System.Text.Json

High-performance JSON library built into .NET Core 3.0+, faster startup, less memory, AOT-friendly. Features include [JsonPropertyName] (corresponding to Newtonsoft's [JsonProperty]) and JsonNamingPolicy for custom naming strategies.

Nullable<T>

Form in C# for indicating nullable value types (e.g., long? / bool?). This tool auto-infers JSON null fields as Nullable<T>, helping avoid null reference exceptions at compile time.

List<T>

Generic list type in the .NET collections framework; this tool automatically converts JSON arrays to List<T>, with T auto-inferred from the first array element (e.g., ["a"] → List<string>).

namespace

Keyword in C# for organizing classes into namespaces, similar to Java's package. Code generated by this tool has no namespace by default; can be added manually (e.g., namespace MyApp.Models).

ASP.NET Core

Microsoft's open-source cross-platform web framework; POCO classes generated by this tool can be directly used for ASP.NET Core Controller [FromBody] model binding, Minimal APIs, Blazor component parameters, and more.

Unity

The world's most popular game engine, using C# as its scripting language. POCO classes generated by this tool can be used for Unity network API response parsing, ScriptableObject configuration data modeling.

Snake_case → PascalCase

Field naming strategy conversion, snake_case naming (e.g., user_name, created_at) converted to PascalCase naming (e.g., UserName, CreatedAt), conforming to .NET official naming conventions.

quicktype-core

The open-source multi-language JSON type generation library (quicktype project) this tool depends on, supporting over a dozen languages including C#, Java, TypeScript, Rust, Go, Swift, executing in-browser based on TypeScript + WebAssembly.

.NET MAUI

Microsoft's cross-platform UI framework (.NET Multi-platform App UI), C# code shared across iOS / Android / Windows / macOS. POCOs generated by this tool are suitable as Models for MAUI XAML data binding.

Blazor

Microsoft's WebAssembly-based SPA framework, in both Server and WebAssembly modes. C# classes generated by this tool can be used for Blazor component parameters, strongly-typed API response models, improving single-language full-stack development efficiency.

HttpClient.GetFromJsonAsync

.NET 5+ / System.Net.Http.Json extension method that accomplishes HTTP GET + JSON deserialization in one line. Combined with POCOs generated by this tool, greatly simplifies HTTP API client code.

JsonNamingPolicy

Class in System.Text.Json for controlling mapping strategy between JSON field names and C# property names (e.g., CamelCase, SnakeCaseLower). Newtonsoft.Json implements this via [JsonProperty] annotations or ContractResolver.

IOptions<T>

Core interface of the .NET Options pattern for binding appsettings.json substructures to strongly-typed classes. POCOs generated by this tool can directly serve as IOptions<T> implementations with IConfiguration.Bind.

JSON Type to C# Type Mapping Quick Reference

The tool automatically infers corresponding C# / .NET types based on JSON value types:

Newtonsoft.Json vs System.Text.Json Annotation Comparison Table

Comparison of field mapping attributes between the two mainstream JSON libraries in the .NET ecosystem; this tool defaults to generating Newtonsoft-compatible [JsonProperty]:

Privacy & Security

Totes les operacions d'aquesta eina JSON a C# es completen íntegrament al vostre navegador: anàlisi JSON, generació de codi C# i descàrregues s'executen al costat del client via JavaScript + WebAssembly (quicktype-core). Cap contingut JSON, fitxers pujats o codi generat s'envia per xarxa. Les pujades utilitzen FileReader nadiu directament a memòria. Sense rastreig de Cookies, sense recollida de dades. En tancar la pàgina tot s'esborra.

Authoritative References

• MicrosoftMicrosoft Learn - C# Programming Guide
• MicrosoftMicrosoft Learn - System.Text.Json Overview
• NewtonsoftNewtonsoft.Json Official Documentation
• MicrosoftMicrosoft Learn - ASP.NET Core Web API Model Binding
• MicrosoftMicrosoft Learn - C# 9 record types