logo
GeekFormat

JSON в C#

Бесплатный онлайн-инструмент JSON в C#. Преобразуйте ответ API или конфигурационный JSON в стандартные классы C# одним кликом для непосредственного использования в проектах ASP.NET Core, Unity, Blazor, .NET MAUI. Поддержка аннотаций [JsonProperty], обобщений List, Nullable<T>, автоматическое разделение вложенных классов, полная локальная генерация в браузере.

Похожие

Введение в JSON в C#: Преобразование данных JSON в компилируемые классы C# POCO

JSON в C# — это процесс преобразования данных в формате JSON (объекты или массивы) в определения классов C# (POCO, Plain Old CLR Object). C# — основной язык экосистемы .NET, широко используемый в сценариях, таких как бэкенд ASP.NET Core, игры Unity, кроссплатформенные приложения .NET MAUI, Blazor WebAssembly, настольные приложения (WPF/WinForms), облачные сервисы Azure и т.д. В процессе разработки часто требуется преобразовать пример JSON из документации API или реального ответа в типы C#, ручное написание классов не только требует много повторяющейся работы, но и подвержено ошибкам в типах полей и аннотациях, поэтому этот инструмент направлен на автоматизацию этого процесса.

Этот инструмент выполняется локально в браузере на основе quicktype-core, использует рендерер C# для генерации кода стандартных классов POCO, вывод по умолчанию включает using System.Collections.Generic; и аннотации [JsonProperty("исходный ключ")] (режим совместимости с Newtonsoft.Json), можно напрямую открыть в Visual Studio для компиляции. Это не просто черновик типов, а класс C#, который можно использовать сразу после размещения в проекте .NET в сочетании с пакетом NuGet.

Вывод типов — ядро JSON в C#. Инструмент сопоставляет базовые типы JSON со стандартными типами .NET: строка→string, целое число→long, число с плавающей точкой→double, булево→bool, массив→List<T>, вложенный объект→независимый class, значение null→Nullable<T> (например long? / bool? / string?). Для вложенных объектов инструмент автоматически генерирует новый класс для каждого уровня и именует его, делая заглавной первую букву имени поля, например поле address генерирует класс Address, объект в массиве items генерирует класс Item.

Интеграция с современным синтаксисом C#: этот инструмент по умолчанию генерирует сериализуемые POCO (открытые свойства { get; set; }). Для проектов, подчеркивающих неизменяемость, разработчики могут изменить class на тип record C# 9+ и изменить { get; set; } на init-only свойства (public string Name { get; init; }), в сочетании с JsonSerializer.Deserialize<T>(jsonString) можно гарантировать во время компиляции, что данные не будут изменены, это соответствует тенденциям проектирования неизменяемых сущностей в ASP.NET Core 7+ Minimal API, Entity Framework Core 8+.

В отличие от некоторых онлайн-инструментов, требующих загрузки JSON на сервер для обработки, все вычисления этого инструмента полностью выполняются в браузере. quicktype-core загружается и выполняется через Web Worker, парсинг JSON, вывод типов, генерация кода C# и загрузка файлов — все выполняется локально, данные не отправляются на какие-либо серверы. Это особенно важно для JSON, содержащего ключи API, поля конфиденциальности пользователей, неопубликованные бизнес-структуры, после закрытия страницы данные удаляются из памяти.

Следует отметить, что автоматически сгенерированный код — это отправная точка, а не конечный пункт. Инструмент выводит типы на основе примера JSON, не может определить более точные типы в бизнес-логике (например семантические типы, такие как URL, Email, ID, все будут выведены как string). Для полей JSON snake_case поля C# сохраняют именование PascalCase (user_name → UserName), но аннотация [JsonProperty] сохраняет исходный ключ, автоматическое сопоставление при десериализации. Рекомендуется рассматривать сгенерированный результат как первый черновик, затем тонко настроить имена полей, типы, атрибуты в соответствии со спецификациями проекта.

Варианты использования

  • ASP.NET Core Web API: преобразование примера JSON в документации OpenAPI/Swagger в классы DTO, в сочетании с привязкой модели [FromBody] для получения запросов от frontend
  • ASP.NET Core MVC: преобразование тела запроса формы/JSON в Model строгого типа, в сочетании с автоматической проверкой ModelState
  • Десериализация Newtonsoft.Json: преобразование JSON ответа стороннего интерфейса в классы POCO с [JsonProperty], не требуется ручное сопоставление полей
  • Высокопроизводительные сценарии System.Text.Json: преобразование JSON в тип record или init-only свойства, в сочетании с JsonSerializer.Deserialize<T> для повышения скорости запуска
  • Скрипты игр Unity: преобразование JSON, возвращаемого сетевым API (данные игрока, конфигурация уровня, товары магазина, рейтинг), в сериализуемые модели данных ScriptableObject
  • Кроссплатформенные приложения .NET MAUI: преобразование JSON от бэкенд API в классы Model, использование в привязке данных XAML, совместное использование бизнес-модели на iOS/Android/Windows
  • Blazor Server / WebAssembly: преобразование JSON от API в параметры компонентов/серверные модели строгого типа, в сочетании с @inject HttpClient для потребления общих типов frontend/backend
  • Entity Framework Core: преобразование документов JSON, экспортированных из базы данных, в классы сущностей, использование в качестве базовых ссылочных классов для миграций моделей EF Core, в сочетании с аннотациями данных, такими как [Key]/[Required]
  • Azure Functions / AWS Lambda: преобразование JSON событий триггеров Event Grid/SNS/API Gateway/Cosmos DB в параметры событий строгого типа, упрощение сигнатур бессерверных функций
  • Общение в реальном времени SignalR: преобразование JSON-сообщений, отправляемых сервером (чат, уведомления, котировки, данные IoT), в типы C#, потребление строгого типа в методах Hub
  • Контракты интерфейсов микросервисов: преобразование примеров JSON запросов/ответов RPC между сервисами (gRPC-Web/HTTP/WCF) в классы C#, использование в качестве определений общих контрактов между несколькими командами
  • Загрузка конфигурационных файлов: преобразование подструктуры appsettings.json в классы шаблона Options (например MyOptions : IOptions<MyOptions> в сочетании с IConfiguration.Bind)
  • Подготовка тестовых данных: преобразование фикстур JSON в классы C#, затем десериализация с помощью Newtonsoft/System.Text.Json в качестве драйвера модульных тестов, в сочетании с xUnit/NUnit/MSTest
  • Парсинг данных краулера: преобразование данных JSON, собранных HtmlAgilityPack/AngleSharp/PuppeteerSharp, в классы C#, избежание пропуска полей при динамическом доступе JObject
  • Написание документации API: включение примеров классов C# в определения schema в документации Swagger/OpenAPI, ReDoc, Knife4j, Swagger UI для повышения читаемости документации
  • Сотрудничество при ревью кода: прямое преобразование JSON ответа API в удобочитаемые POCO, удобство обсуждения именования полей, выбора типов, использования аннотаций во время Code Review
  • Рефакторинг старых проектов: рефакторинг динамического доступа на основе JObject/Dictionary<string, object> в доступ строгого типа на основе POCO, повышение проверки типов во время компиляции и поддерживаемости
  • Обучение и тренировка: преобразование примера JSON в POCO на курсах C#, вводном обучении .NET для демонстрации объектно-ориентированного моделирования, аксессоров свойств, принципов сериализации

Как использовать

  1. Вставьте содержимое JSON в редактор слева, или нажмите кнопку загрузки для выбора файла .json/.txt, или нажмите кнопку примера для загрузки встроенных данных
  2. Подождите 400 мс для автоматического преобразования, справа отобразится сгенерированный код класса C# POCO
  3. Если есть ошибки формата JSON, можно нажать кнопку «Исправить JSON» для автоматического исправления распространенных синтаксических проблем перед повторным преобразованием
  4. Нажмите кнопку «Копировать» для копирования отдельного класса в буфер обмена и вставки в Visual Studio/Rider/VS Code, или нажмите «Загрузить» для сохранения в виде файла .cs

Функции

  • Чистая локальная генерация в браузере: парсинг JSON и генерация кода C# полностью выполняются в браузере через JavaScript + quicktype-core, входные данные не загружаются на какие-либо серверы
  • Две формы POCO + record: по умолчанию генерируются сериализуемые классы POCO, переключение на тип record C# 9+ в один клик, соответствие современному стилю кодирования .NET
  • Аннотации Newtonsoft [JsonProperty]: автоматическое добавление [JsonProperty("исходный ключ")] для каждого поля, совместимость с поведением по умолчанию Newtonsoft.Json, имена полей PascalCase не влияют на десериализацию
  • Автоматическое разделение вложенных объектов: вложенные объекты JSON рекурсивно генерируют независимые классы C#, именование по правилу заглавной первой буквы имени поля (например address → Address), избежание конфликтов типов
  • Автоматическое развертывание обобщений List: массивы JSON автоматически преобразуются в List<T>, T автоматически выводится из первого элемента массива (["a","b"] → List<string>, [{...}] → List<Item>)
  • Автоматический вывод Nullable<T>: поля со значением null в JSON автоматически помечаются как Nullable<T> (например long? / string? / bool?), предотвращение исключений нулевой ссылки во время компиляции
  • Именование полей PascalCase: вход snake_case автоматически преобразуется в PascalCase (например user_name → UserName), при этом аннотация [JsonProperty] сохраняет исходный ключ для обеспечения совместимости десериализации
  • Богатое соответствие типов значений: string→string, integer→long, float→double, bool→bool, array→List<T>, null→Nullable<T>
  • Полный шаблон .cs: автоматическая генерация стандартного файла C#, содержащего using System.Collections.Generic; + namespace + public class + поля + свойства, с возможностью прямой компиляции
  • Копирование и загрузка: копирование отдельного класса в буфер обмена или загрузка в виде файла .cs одним кликом, напрямую перетаскивание в Visual Studio / Rider / VS Code для использования
  • Исправление ошибок JSON одним кликом: автоматическое исправление распространенных ошибок форматирования, таких как конечные запятые, одинарные кавычки, отсутствующие кавычки, после успешного исправления продолжение генерации кода C#
  • Локальная история: автоматическое сохранение последних вводов на основе localStorage, быстрое восстановление после обновления или случайного закрытия страницы для продолжения редактирования

Примеры кода

C#: Десериализация POCO, сгенерированного инструментом, с помощью Newtonsoft.Json

csharp

Наиболее распространенное использование в проектах ASP.NET Core: сочетание POCO, сгенерированного инструментом, с Newtonsoft.Json для десериализации ответа API.

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

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

    // POCO, сгенерированный инструментом:
    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) Вызов API для получения строки JSON
        var json = await _http.GetStringAsync($"https://api.example.com/users/{userId}");

        // 2) Десериализация в POCO, сгенерированный инструментом
        //    Внутреннее автоматическое сопоставление JSON snake_case по аннотациям, таким как [JsonProperty("id")]
        var user = JsonConvert.DeserializeObject<User>(json);

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

C#: Использование POCO, сгенерированного инструментом, в ASP.NET Core Controller для получения запросов

csharp

Поместите POCO User, сгенерированный инструментом, в ASP.NET Core Controller, в сочетании с [FromBody] автоматически получать JSON-запросы от frontend.

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

// POCO, сгенерированный инструментом (по умолчанию использует 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");
        }

        // Бизнес-логика: сохранение заказа
        // var order = OrderService.Create(request);

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

/*
 * Соответствующие зависимости .csproj:
 * <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="7.0.0" />
 * <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
 */

C#: HttpClient.GetFromJsonAsync + System.Text.Json десериализация

csharp

Рекомендуемое использование для .NET 5+/.NET 7+: использование встроенного метода расширения System.Text.Json + типа record, в сочетании с аннотацией [JsonPropertyName].

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

// Инструмент по умолчанию генерирует POCO class; можно вручную изменить на тип record (неизменяемый объект передачи данных) следующим образом:
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 завершает HTTP + десериализацию в одну строку
        var user = await _http.GetFromJsonAsync<User>(
            $"https://api.example.com/users/{userId}");

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

/*
 * Соответствующие зависимости .csproj (System.Text.Json встроен, дополнительная установка не требуется):
 * <TargetFramework>net7.0</TargetFramework>
 *
 * Если проект .NET 7+ и нужно совместимость с синтаксисом Newtonsoft [JsonProperty],
 * можно добавить в Program.cs:
 *   builder.Services.AddControllers()
 *       .AddNewtonsoftJson(options =>
 *       {
 *           options.SerializerSettings.ContractResolver =
 *               new Newtonsoft.Json.Serialization.DefaultContractResolver();
 *       });
 */

Best Practices

Добавьте <Nullable>enable</Nullable> в .csproj, допускающие null типы, такие как string? / List<User>?, сгенерированные этим инструментом, автоматически получат проверку null во время компиляции, предотвращая сбои времени выполнения NullReferenceException.

Этот инструмент автоматически преобразует поля JSON в PascalCase (например user_name → UserName), при этом аннотация [JsonProperty] сохраняет исходный ключ, гарантируя, что код соответствует официальным правилам именования .NET, десериализация по-прежнему работает с исходным ключом JSON.

Когда уровень вложенности превышает 4 уровня, рекомендуется разделить корневой объект на несколько независимых POCO, каждый отвечает за разные бизнес-области (например UserDto / OrderDto / PaymentDto), избегание одного огромного класса, содержащего все поля, повышение поддерживаемости.

Не используйте POCO, сгенерированные этим инструментом, одновременно как EF Core Entity и как API DTO. Рекомендация: ①Слой API использует DTO (сгенерированные из JSON); ②Слой EF Core использует Entity (вручную добавляются аннотации данных, такие как [Key]/[Required]); ③Используйте AutoMapper/Mapster для сопоставления DTO ↔ Entity, избегание прямого раскрытия структуры базы данных frontend.

Если проект использует System.Text.Json, рекомендуется использовать глобальную замену в IDE для изменения сгенерированного [JsonProperty("xxx")] на [JsonPropertyName("xxx")]. Или сохранить исходный [JsonProperty] + установить пакет Microsoft.AspNetCore.Mvc.NewtonsoftJson и вызвать AddNewtonsoftJson() для совместимости с синтаксисом Newtonsoft.

Все вычисления этого инструмента выполняются локально в браузере, но внутри предприятия рекомендуется добавить дополнительный уровень защиты: ①Не копируйте JSON, содержащий строки подключения к производственной базе данных/основные ключи API, в какие-либо онлайн-инструменты; ②Для внутренней генерации POCO рекомендуется использовать NSwag или Вставить JSON как классы Visual Studio для генерации полностью в автономном режиме; ③Используйте онлайн-инструменты только с образцами JSON после маскирования.

JSON, превышающие 1 МБ, будут отображаться медленно в браузере, рекомендуется: ①Разделить на несколько независимых классов POCO (например User.cs / Address.cs / Order.cs), классифицированных по бизнес-модулям; ②Для сверхбольших JSON Schema (100+ полей) рекомендуется использовать NSwag или встроенную функцию Visual Studio для прямой генерации; ③Этот инструмент использовать только для обработки малых и средних ответов API (<100 полей).

Для DTO/моделей ответов, не требующих изменения, рекомендуется изменить сгенерированный class на record C# 9+ и изменить { get; set; } на { get; init; }, преимущества включают: ①Гарантия во время компиляции, что данные не будут изменены; ②Автоматическое получение сравнения равенства значений (Equals/GetHashCode); ③Упрощение копирования объектов в сочетании с выражением with.

Часто задаваемые вопросы

Как преобразовать JSON в классы C#?

Вставьте содержимое JSON в левое поле ввода, инструмент автоматически вызовет quicktype-core для генерации классов C# в течение 400 мс, справа отобразится полный код. Вы также можете нажать кнопку «Загрузить» для выбора файла .json/.txt или нажать «Пример» для загрузки встроенных данных. После генерации нажмите кнопку «Копировать» для копирования отдельного класса в буфер обмена или загрузки в виде файла .cs.

Будет ли сгенерированный код C# содержать аннотации [JsonProperty]?

Да. Инструмент по умолчанию использует режим совместимости с Newtonsoft.Json, автоматически добавляя атрибут [JsonProperty("исходный ключ")] для каждого поля, гарантируя, что после преобразования имени поля в PascalCase десериализация все равно сможет правильно сопоставить исходный ключ JSON. Если используется System.Text.Json, после генерации можно изменить [JsonProperty] на [JsonPropertyName] (оба имеют одинаковую семантику) или напрямую использовать политику именования по умолчанию System.Text.Json ([JsonPropertyName] в System.Text.Json также может обрабатываться через настраиваемый JsonNamingPolicy).

Нужно генерировать классы POCO или типы record?

По умолчанию генерируются сериализуемые классы POCO (содержащие свойства { get; set; }). Если проект использует тип record C# 9+ (неизменяемые объекты передачи данных, подходящие для DTO/неизменяемых моделей), после генерации можно вручную изменить class на record и изменить { get; set; } на init-only свойства (public string Name { get; init; }). Тип record широко используется в ASP.NET Core 7+ Minimal API, Entity Framework Core.

Какие структуры данных JSON поддерживаются?

Поддерживаются все допустимые структуры JSON: базовые типы (null, boolean, number, string), массивы (одномерные или многомерные), вложенные объекты (произвольной глубины). Корневой ввод может быть объектом JSON или массивом JSON, объект JSON генерирует public class Root, массив JSON генерирует public class Root : List<Item>. Не поддерживаются собственные значения JavaScript (функции, Symbol, undefined, объекты Date и т.д.).

Как типы полей JSON сопоставляются с типами C#?

Строка→string, целое число→long, число с плавающей точкой→double, булево→bool, массив→List<T>, вложенный объект→независимый class, поле со значением null→Nullable<T> (например long? / bool? / string?). Подробные правила сопоставления см. в «Таблице быстрого сопоставления типов JSON с типами C#» внизу страницы.

Поля null автоматически генерируют Nullable<T>?

Да. Инструмент обнаруживает поля, явно равные null или отсутствующие в JSON, автоматически генерирует формат Nullable<T> (например long? Id { get; set; }), что соответствует функции Nullable Reference Types (NRT), представленной в C# 8+, помогая компилятору обнаруживать риски нулевых ссылок при статическом анализе. Примечание: после включения NRT ссылочные типы по умолчанию не допускают null, необходимо явно отметить string? для указания возможности null.

Массивы преобразуются в List<T>?

Да. Массивы JSON единообразно преобразуются в List<T> в C#, тип элемента автоматически выводится из первого элемента массива: массив строк→List<string>, массив целых чисел→List<long>, массив объектов→List<Item>. Пустой массив [] не может вывести тип элемента, по умолчанию генерируется List<object>, рекомендуется после генерации вручную изменить на конкретный тип (например List<MyClass>). Если предпочитаете синтаксис массива T[], после генерации можно использовать массовую замену в IDE.

Как обрабатываются вложенные объекты?

Инструмент генерирует независимый класс C# для каждого вложенного объекта, правило именования — заглавная первая буква имени поля (например address → Address). Если корневой объект содержит массив items и элементы являются объектами, генерируется класс public class Item, затем ссылка public List<Item> Items { get; set; }. Объекты с одинаковой структурой повторно используют один и тот же тип, избегая повторяющихся определений.

Можно ли настроить имена генерируемых классов и пространства имен?

Да. quicktype-core по умолчанию использует имя источника JSON (например Root) как имя корневого класса, после генерации можно вручную изменить имена классов, namespace и все позиции ссылок. Имя загружаемого файла .cs также можно переименовать по необходимости при сохранении (например изменить на User.cs, Order.cs).

Можно ли поместить сгенерированный код непосредственно в проект .NET для использования?

Можно использовать напрямую. Сгенерированный файл — стандартный синтаксис C#, содержит ссылку using System.Collections.Generic., достаточно поместить файл .cs в корневой каталог или подкаталог проекта .NET, не требуется добавление дополнительных зависимостей в .csproj (System.Text.Json встроен в .NET; для Newtonsoft.Json требуется установка пакета Microsoft.AspNetCore.Mvc.NewtonsoftJson или Newtonsoft.Json через NuGet). Затем можно использовать JsonConvert.DeserializeObject<T>(jsonString) или JsonSerializer.Deserialize<T>(jsonString) для десериализации.

Данные загружаются на сервер?

Полностью локальное выполнение в браузере. Парсинг JSON, генерация кода C# и загрузка файлов полностью выполняются в браузере через JavaScript + WebAssembly, введенные данные JSON и сгенерированный код C# не загружаются на какие-либо серверы, не записываются и не кэшируются в облаке. Чувствительный JSON, содержащий ключи API, токены, неопубликованные бизнес-поля, также можно безопасно использовать, закрытие страницы приводит к удалению.

Нужна регистрация или вход?

Не нужно. Инструмент полностью бесплатный, не требует регистрации, входа, авторизации, открытие страницы позволяет сразу использовать, все функции предоставляются локально в браузере.

Что делать при ошибке формата JSON?

Инструмент автоматически проверяет допустимость JSON, при ошибке справа отображается красное сообщение об ошибке и предоставляется кнопка «Исправить JSON», при нажатии можно автоматически исправить распространенные ошибки: конечные запятые, преобразование одинарных кавычек в двойные, дополнение кавычек для ключей без кавычек, удаление комментариев и т.д. После успешного исправления продолжается генерация кода C#.

Что лучше — Newtonsoft.Json или System.Text.Json?

Обе являются самыми основными библиотеками JSON в экосистеме .NET. Newtonsoft.Json (также известный как Json.NET) имеет самую долгую историю и самую богатую экосистему, совместим практически со всеми проектами .NET; System.Text.Json — высокопроизводительная библиотека, встроенная в .NET Core 3.0+, быстрый запуск, низкое потребление памяти, дружелюбна к AOT. ASP.NET Core 3.0+ по умолчанию использует System.Text.Json; старые проекты .NET Framework и многие сторонние библиотеки по умолчанию зависят от Newtonsoft.Json. Этот инструмент по умолчанию генерирует [JsonProperty] для совместимости с обеими (System.Text.Json в .NET 7+ также поддерживает пакет совместимости Newtonsoft Microsoft.AspNetCore.Mvc.NewtonsoftJson).

В чем разница с JSON в Java, JSON в Rust?

Все три преобразуют JSON в определения типов целевого языка, но форма вывода различается: JSON в C# генерирует классы POCO с аннотациями [JsonProperty], может напрямую использоваться с Newtonsoft.Json или System.Text.Json для десериализации; JSON в Java генерирует POJO с аннотациями Lombok/Gson/Jackson; JSON в Rust генерирует struct с Serde derive. Все три ориентированы на разные экосистемы, выбор зависит от технологического стека.

Что делать, если десериализация класса с полем DateTime завершается неудачей?

System.Text.Json по умолчанию не поддерживает автоматическое преобразование между string и DateTime, выбрасывает JsonException. Два решения: ①добавить настраиваемый конвертер [JsonConverter(typeof(DateTimeConverter))] в поле; ②настроить глобальный JsonSerializerOptions в Program.cs: options.PropertyNameCaseInsensitive = true; и использовать настраиваемый JsonConverter для обработки DateTime. Newtonsoft.Json по умолчанию поддерживает десериализацию DateTime, но для специальных форматов (например метки времени Unix) требуется настраиваемый converter.

Почему в сгенерированных классах нет namespace?

Инструмент по умолчанию не генерирует namespace, чтобы поддерживать максимальную совместимость фрагментов кода, облегчая пользователям копирование и использование в произвольных проектах. Если нужен namespace, можно вручную добавить namespace YourApp.Models; в верхнюю часть сгенерированного кода и поместить классы в соответствующий файл .cs. Рекомендуется в проектах .NET организовывать namespace по функциональным модулям (например Models / Dtos / ViewModels / Entities).

Можно ли в Visual Studio вставить как классы одним кликом?

Visual Studio 2019+ имеет встроенную функцию «Специальная вставка → Вставить JSON как классы» (в меню Правка → Специальная вставка), которая может напрямую преобразовать JSON в классы C#. Код, сгенерированный этим инструментом, совместим с этой функцией: после копирования сгенерированного этим инструментом кода C# в буфер обмена вставьте в любой файл .cs для использования. Если предпочитаете встроенную функцию VS, можно не открывать этот инструмент, а напрямую использовать Правка → Специальная вставка → Вставить JSON как классы.

Устранение неполадок

Отображается «Пожалуйста, введите данные JSON» или правая сторона пуста

Левое поле ввода пусто или содержит только пробельные символы, убедитесь, что вставлено допустимое содержимое JSON, или нажмите кнопку загрузки для выбора файла .json/.txt, также можно нажать кнопку примера для загрузки встроенного примера.

Отображается сбой парсинга JSON

Распространенные причины: конечные запятые (например {"a":1,}), использование одинарных кавычек вместо двойных, ключи не заключены в двойные кавычки, содержат комментарии JavaScript. Нажатие кнопки «Исправить JSON» может автоматически исправить некоторые ошибки; если все равно не удается, сначала проверьте с помощью инструмента форматирования JSON.

Сгенерированные типы полей недостаточно точны

Инструмент выводит типы на основе примера JSON, например все целые числа — long, все строки — string. Если нужны более точные типы (int/decimal/Guid/DateTime), пожалуйста, вручную измените типы полей после генерации. System.Text.Json по умолчанию не поддерживает DateTime, требуется настройка через [JsonConverter].

Поля null генерируют Nullable<T>, но в проекте не включены Nullable Reference Types

Инструмент по умолчанию генерирует в формате Nullable Reference Types C# 8+ (например string? / List<User>?). Если проект более старой версии .NET Framework/не включен NRT, ссылочные типы по умолчанию допускают null, можно напрямую удалить ? у string? (или включить <Nullable>enable</Nullable> в .csproj).

При компиляции сообщается, что зависимость Newtonsoft.Json не найдена

Пожалуйста, добавьте следующий PackageReference в .csproj: <ItemGroup> <PackageReference Include="Newtonsoft.Json" Version="13.0.3" /> </ItemGroup> Затем выполните dotnet restore, NuGet автоматически загрузит. Если используется System.Text.Json, установка не требуется (встроен в .NET).

Поля snake_case JSON не соответствуют именам полей PascalCase

Инструмент автоматически преобразует имена полей JSON в PascalCase (например user_name → UserName), при этом аннотация [JsonProperty] сохраняет исходный ключ, Newtonsoft.Json будет сопоставлять по [JsonProperty] при десериализации, ручная обработка не требуется. Если используется политика именования по умолчанию System.Text.Json, нужно изменить [JsonProperty] на [JsonPropertyName] или настроить политику именования CamelCase в Program.cs.

Загруженный файл .cs сообщает об ошибке компиляции в проекте

Возможные причины: ①В .csproj не добавлены зависимости Newtonsoft.Json/System.Text.Json; ②Класс размещен в неподходящем каталоге (нужно разместить в корневом каталоге или подкаталоге проекта .NET и соответствовать namespace); ③Имя класса конфликтует с другими типами в проекте. Решение: добавить зависимости, настроить каталог и namespace, переименовать конфликтующий класс.

При получении JSON в ASP.NET Core появляется ошибка «Cannot deserialize»

ASP.NET Core 3.0+ по умолчанию использует System.Text.Json, но [JsonProperty], сгенерированный инструментом, — это синтаксис Newtonsoft.Json. Два решения: ①Добавить пакет Microsoft.AspNetCore.Mvc.NewtonsoftJson в .csproj и вызвать AddNewtonsoftJson() в Program.cs; ②Изменить все сгенерированные [JsonProperty("xxx")] на [JsonPropertyName("xxx")] (синтаксис System.Text.Json).

Массив — числовой тип, но генерируется List<object>

Обычно это когда массив пуст [] по умолчанию выводится как List<object>, пожалуйста, добавьте хотя бы один пример элемента (например [1,2,3]) в исходный JSON, инструмент выведет тип на основе первого элемента; или после генерации вручную измените List<object> на List<long>/List<int>.

При преобразовании сверхбольших JSON страница зависает

Рекомендуется разделить JSON на несколько независимых модулей для отдельного преобразования или извлечь только часть, которую нужно смоделировать. Браузер будет потреблять много памяти при отображении большого количества вложенных классов, для JSON, превышающих 5 МБ, рекомендуется использовать NSwag или встроенную функцию Visual Studio «Вставить JSON как классы».

Глоссарий

POCO (Plain Old CLR Object)
Аббревиатура «обычного CLR-объекта» в C#/.NET, ограничения: открытый конструктор по умолчанию + private поля + открытые свойства { get; set; } + отсутствие зависимостей от фреймворка. То, что генерирует этот инструмент, — стандартный POCO.
record
Неизменяемый тип объекта передачи данных, представленный в C# 9+, использует равенство значений, а не равенство ссылок. После генерации в этом инструменте можно вручную изменить на record, подходит для сценариев, таких как DTO, модели ответов API, неизменяемая конфигурация.
[JsonProperty]
Атрибут сопоставления полей Newtonsoft.Json. Этот инструмент по умолчанию добавляет [JsonProperty("исходный ключ")] для каждого поля, гарантируя, что имена полей PascalCase могут правильно десериализовать JSON в snake_case.
Newtonsoft.Json
Также известный как Json.NET, самая популярная библиотека JSON в экосистеме .NET. Имеет самую богатую экосистему и лучшую совместимость, поддерживается практически всеми проектами .NET. Использовался по умолчанию до ASP.NET Core 3.0, после 3.0 был заменен на System.Text.Json, но по-прежнему может быть совместим через пакет NuGet.
System.Text.Json
Высокопроизводительная библиотека JSON, встроенная в .NET Core 3.0+. Быстрый запуск, низкое потребление памяти, дружелюбна к AOT, включает [JsonPropertyName] (соответствует [JsonProperty] Newtonsoft) и настраиваемую политику именования JsonNamingPolicy.
Nullable<T>
Тип в C#, указывающий, что тип значения может быть null (например long? / bool?). Этот инструмент автоматически выводит поля null в JSON как Nullable<T>, чтобы избежать исключений нулевой ссылки во время компиляции.
List<T>
Обобщенный тип списка в фреймворке коллекций .NET. Этот инструмент автоматически преобразует массивы JSON в List<T>, T автоматически выводится из первого элемента массива (например ["a"] → List<string>).
namespace
Ключевое слово пространства имен в C# для организации классов, аналогично package в Java. Код, сгенерированный этим инструментом, по умолчанию не имеет namespace, можно добавить вручную (например namespace MyApp.Models).
ASP.NET Core
Открытый кроссплатформенный веб-фреймворк Microsoft. Классы POCO, сгенерированные этим инструментом, могут напрямую использоваться в сценариях, таких как привязка модели [FromBody] ASP.NET Core Controller, Minimal API, параметры компонентов Blazor.
Unity
Самый популярный в мире игровой движок, язык скриптов — C#. Классы POCO, сгенерированные этим инструментом, могут использоваться для парсинга ответов сетевого API Unity, моделирования данных конфигурации ScriptableObject.
Snake_case → PascalCase
Преобразование правил именования полей. Преобразование именования snake_case (например user_name, created_at) в именование PascalCase (например UserName, CreatedAt), соответствие официальным правилам именования .NET.
quicktype-core
Базовая зависимость этого инструмента — открытая многоязычная библиотека генерации типов JSON (проект quicktype), поддерживающая более десяти языков, включая C#, Java, TypeScript, Rust, Go, Swift и т.д., выполняется в браузере на основе TypeScript + WebAssembly.
.NET MAUI
Кроссплатформенный UI-фреймворк Microsoft (.NET Multi-platform App UI), код C# может совместно использоваться на iOS/Android/Windows/macOS. POCO, сгенерированные этим инструментом, подходят в качестве Model для привязки данных XAML в MAUI.
Blazor
SPA-фреймворк Microsoft на основе WebAssembly, имеет два режима: Server и WebAssembly. Классы C#, сгенерированные этим инструментом, могут использоваться для параметров компонентов Blazor, моделей ответов API строгого типа, повышения эффективности полностековой разработки на одном языке.
HttpClient.GetFromJsonAsync
Метод расширения .NET 5+/System.Net.Http.Json, завершает HTTP GET + десериализацию JSON в одну строку. В сочетании с POCO, сгенерированными этим инструментом, может значительно упростить код клиента HTTP API.
JsonNamingPolicy
Класс в System.Text.Json, управляющий правилами сопоставления между именами полей JSON и именами свойств C# (например CamelCase, SnakeCaseLower). Newtonsoft.Json реализуется через аннотацию [JsonProperty] или ContractResolver.
IOptions<T>
Основной интерфейс шаблона Options в .NET, связывает подструктуру appsettings.json с классом строгого типа. POCO, сгенерированные этим инструментом, в сочетании с IConfiguration.Bind могут напрямую использоваться как реализация IOptions<T>.

Таблица быстрого сопоставления типов JSON с типами C#

Инструмент автоматически выводит соответствующие типы .NET/C# на основе типов значений JSON:

Пример значения JSONСгенерированный тип C#Формат NullableОписание
nullВывод по контекстуT?Поля со значением null автоматически выводятся как Nullable<T> (например long? / bool? / string?)
true / falseboolbool?Булевы значения JSON напрямую сопоставляются с bool C#
42longlong?Целые числа JSON по умолчанию сопоставляются с long (64-битные целые, совместимы с большими числами)
3.14doubledouble?Числа с плавающей точкой JSON по умолчанию сопоставляются с double (числа с плавающей точкой двойной точности)
"hello"stringstring?Строки JSON сопоставляются с string C#
["a","b"]List<string>List<string>?Массивы строк сопоставляются с List<string>
[1,2,3]List<long>List<long>?Массивы целых чисел сопоставляются с List<long>
[{...},{...}]List<Item>List<Item>?Массивы объектов сначала генерируют соответствующий class для первого элемента, затем оборачивают в List
[]List<object>List<object>?Пустые массивы не могут вывести тип элемента, по умолчанию понижение до object, рекомендуется после генерации вручную изменить на конкретный тип
{...} вложенный объектнезависимый classClassName?Вложенные объекты генерируют независимый class, именование по правилу заглавной первой буквы имени поля (address → Address)

Таблица сравнения аннотаций Newtonsoft.Json и System.Text.Json

Сравнение атрибутов сопоставления полей двух основных библиотек JSON в экосистеме .NET. Этот инструмент по умолчанию генерирует [JsonProperty], совместимый с Newtonsoft:

Сравниваемый элементNewtonsoft.JsonSystem.Text.Json
Атрибут сопоставления полей[JsonProperty("user_name")][JsonPropertyName("user_name")]
Политика именования по умолчаниюСохранение имен полей PascalCase (snake_case требует [JsonProperty])Сохранение исходных имен полей (сопоставление по ключу JSON, по умолчанию CamelCase)
Настраиваемое именованиеПопольное указание через [JsonProperty][JsonPropertyName] + глобальная настройка JsonNamingPolicy
Обработка значений nullNullValueHandling.Ignore / IncludeJsonIgnoreCondition.WhenWritingNull
Встроенная версия .NET.NET Framework / .NET Core / .NET 5+.NET Core 3.0+ / .NET 5+
Способ установкиNuGet: Newtonsoft.JsonВстроенная (установка не требуется)
ПроизводительностьСредняяВысокая (быстрый запуск, низкое потребление памяти)
Поддержка AOTТребуется source generatorНативная поддержка
Применимые сценарииСтарые проекты .NET, зависимости от сторонних библиотек, богатая экосистемаASP.NET Core 3.0+, высокопроизводительные сценарии, .NET MAUI / Blazor

Privacy & Security

Все операции этого инструмента JSON в C# полностью выполняются локально в вашем браузере: парсинг JSON, генерация кода C# и загрузка файлов — все выполняется на стороне клиента через JavaScript + WebAssembly (quicktype-core) браузера, содержимое JSON, загруженные файлы или сгенерированный код не отправляются на какие-либо серверы по сети. Загрузка файлов использует собственный API FileReader браузера для прямого чтения в память, не проходит через какие-либо промежуточные сервисы. Не используется отслеживание Cookie, не собираются данные пользовательского ввода или данные поведения при использовании. После закрытия или обновления страницы все содержимое ввода и вывода автоматически удаляется из памяти. Подходит для обработки JSON, содержащего ключи API, токены, чувствительные бизнес-данные.

Authoritative References