Genera modelos C# a partir de ejemplos JSON completos

Genera modelos C# a partir de ejemplos JSON. Revisa campos obligatorios, valores null y tipos numéricos antes de descargar el código.

JSON a C#

C# 12 / .NET 8; sólo System.Text.Json y biblioteca estándar.

JsonRequired exige presencia, no referencias no null. Las propiedades opcionales nullable, incluido JsonElement?, colapsan ausencia y null. Lexemas enteros en int64 sin cero negativo usan long; los demás números usan JsonElement. Los helpers raíz deserializan sin validar el contrato inferido. Los valores con sustitutos aislados conservan un aviso del parser, pero System.Text.Json los rechaza en runtime.

Activa JavaScript para generar código. Puedes leer y editar el JSON.

Todos los elementos y documentos aportan al mismo contrato. Un array raíz sigue siendo un array. La ausencia de un campo es distinta de null.

Hasta 20 documentos, 1.000.000 de unidades UTF-16 de entrada y 2.000.000 de salida; también se aplican otros presupuestos de recursos.

Tu JSON se procesa localmente en un Worker del navegador. No se envía ni se guarda.

Modo de entrada

JSON del ejemplo activoCargar archivo local UTF-8

Nombre del tipo raíz

Usa entre 1 y 64 letras y dígitos ASCII; comienza por una letra. Los nombres reservados se rechazan.

Listo para introducir JSON.

Genera modelos C# a partir de tus ejemplos

Pega un documento JSON completo o abre un archivo UTF-8. Puedes aportar hasta veinte muestras para deducir tipos comunes. Se revisan todos los elementos, incluidos los campos que solo aparecen al final de un array. Una raíz array se representa como una lista.

[{"id":1},{"id":2,"nombre":"Ana"}]

#nullable enable
namespace Generated;

public sealed class RootItem
{
  [global::System.Text.Json.Serialization.JsonRequired]
  [global::System.Text.Json.Serialization.JsonPropertyName("id")]
  public long Id { get; set; }
  [global::System.Text.Json.Serialization.JsonPropertyName("nombre")]
  public string? Nombre { get; set; }
}

public static class Root
{
  public static global::System.Collections.Generic.List<RootItem> Deserialize(string json)
    => global::System.Text.Json.JsonSerializer.Deserialize<global::System.Collections.Generic.List<RootItem>>(json)!;
}

En el ejemplo, Id es un long obligatorio. Como nombre falta en el primer objeto, Nombre se genera como string? y no lleva JsonRequired.

La entrada debe ser JSON estricto. Las claves duplicadas, los comentarios, las comas finales, los documentos concatenados y las muestras vacías detienen la generación.

Nombres de propiedades y clases

Cada propiedad lleva JsonPropertyName con su clave JSON exacta. Los caracteres Unicode y las distintas formas de escribirlos se conservan. Los conflictos con otros identificadores, nombres de clase o miembros como Equals y GetType se resuelven cambiando el identificador C#, no la clave. Una clave con un sustituto Unicode aislado impide generar código.

La salida usa clases public sealed en namespace Generated, propiedades públicas con get/set y tipos estándar con nombres completos. No añade paquetes ni conversores propios.

Obligatorio no significa que null esté prohibido

JsonRequired exige que la propiedad esté presente; omitirla provoca una JsonException. Las propiedades opcionales no llevan ese atributo y usan T? o JsonElement?.

Una propiedad ausente y un null explícito pueden terminar en el mismo valor null. Si una propiedad es obligatoria y las muestras solo contienen null, se representa con JsonElement y ValueKind.Null.

Las referencias obligatorias que no admiten null se inicializan con default! para el análisis estático. Eso no aporta un valor válido a los datos. En .NET 8, las anotaciones de nulabilidad no bastan para rechazar null explícito en esas referencias; revisa el aviso y añade validación si la necesitas. La salida no activa WhenWritingNull ni garantiza conservar la diferencia entre ausencia y null al serializar otra vez.

Cómo se representan los números

Los enteros escritos sin decimales ni exponentes, dentro del rango de Int64 y distintos de -0, usan long. Esto incluye 9007199254740993. Los decimales, exponentes, -0 y enteros fuera de ese rango usan JsonElement; GetRawText() permite recuperar su escritura.

Cuando no hay datos suficientes para deducir un tipo, solo se observa null o se mezclan varios tipos distintos de null, se usa JsonElement con un aviso. Los objetos vacíos usan Dictionary<string, JsonElement>.

Una raíz de objeto no vacío genera una clase directa. Para otras raíces, la salida incluye el método Deserialize(string json), que llama a System.Text.Json; no añade validación del contrato deducido. Un sustituto Unicode aislado en una cadena permite generar el tipo, pero .NET 8 rechaza ese valor al leer los datos. El navegador no compila ni ejecuta el C# generado.

Límites y descarga

Límite	Máximo
Muestras	20
Texto de entrada total	1.000.000 unidades UTF-16 / 4.000.000 bytes UTF-8
Archivo	4.000.000 bytes
Contenedores anidados / valores de entrada	200 niveles / 100.000
Tipos inferidos / campos	10.000 / 20.000
Declaraciones generadas	2.000
Código de salida	2.000.000 unidades UTF-16 / 8.000.000 bytes
Tiempo de generación	15 segundos

Los ejemplos complejos pueden alcanzar otros límites de procesamiento antes. Si se supera un límite, no se entrega código parcial.

Copiar y descargar incluyen todo Types.cs, aunque la vista previa termine en 20.000 unidades UTF-16. El archivo usa UTF-8 sin BOM y un salto LF final. Si falla el portapapeles, puedes copiar el código completo manualmente.