JSON a clase C#

Genera clases C# a partir de JSON

Acerca de JSON a clase C#

JSON a clase C# escribe las clases de modelo C# de una muestra JSON o de un JSON Schema con quicktype-core, dentro de tu navegador. El código queda en el espacio de nombres que elijas (App por defecto), con las directivas using del serializador: System.Text.Json, con un atributo [JsonPropertyName] en cada propiedad, o Newtonsoft.Json, con [JsonProperty]. Cada objeto anidado se convierte en una clase public partial, o en un record si «Records (C# 9+)» está marcado; la del primer nivel toma el «Nombre de la clase» (Root por defecto). Las propiedades van en PascalCase y conservan cada clave original en su atributo. Los números enteros son long, los decimales double o decimal, y los arrays se convierten en arrays como Item[] o en listas como List<Item>. Las propiedades que faltan en algunos elementos de un array son nullable y no se escriben cuando valen null. Un valor con dos tipos, por ejemplo un número en un elemento y texto en otro, añade una estructura de unión y las clases JsonConverter que necesita. El JSON se puede pegar o abrir desde un archivo .json o .txt.

Ejemplo

Un pedido con sus líneas; note solo aparece en una línea, así que se vuelve nullable.

Entrada JSON

{"orderId": 1001, "total": 49.90, "paid": true,
 "items": [{"sku": "A1", "qty": 2}, {"sku": "B7", "qty": 1, "note": "gift"}]}

Salida C#

namespace App
{
    using System;
    using System.Collections.Generic;

    using System.Text.Json;
    using System.Text.Json.Serialization;
    using System.Globalization;

    public partial class Root
    {
        [JsonPropertyName("orderId")]
        public long OrderId { get; set; }

        [JsonPropertyName("total")]
        public double Total { get; set; }

        [JsonPropertyName("paid")]
        public bool Paid { get; set; }

        [JsonPropertyName("items")]
        public Item[] Items { get; set; }
    }

    public partial class Item
    {
        [JsonPropertyName("sku")]
        public string Sku { get; set; }

        [JsonPropertyName("qty")]
        public long Qty { get; set; }

        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
        [JsonPropertyName("note")]
        public string? Note { get; set; }
    }
}

Cómo generar clases C# a partir de JSON

  1. 1Pega una muestra JSON en «Entrada JSON», o haz clic en «Abrir un archivo» para cargar un archivo .json o .txt. Para un JSON Schema, elige «JSON Schema» en «Origen».
  2. 2Elige el «Serializador» y luego pon en «Nombre de la clase» y «Espacio de nombres» los de tu proyecto.
  3. 3Haz clic en «Convertir» para obtener las clases en «Salida C#».
  4. 4Haz clic en «Copiar», o en «Descargar» para guardar el código como «Model.cs».

Formatos y límites

Entrada
Objeto JSON o array de objetos, o JSON Schema, pegado o abierto desde un archivo .json o .txt
Salida
Clases o records C# en el espacio de nombres que elijas (App por defecto), guardados como Model.cs
Serializador
System.Text.Json: [JsonPropertyName] en cada propiedad, [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)] en las opcionales; o Newtonsoft.Json: [JsonProperty], con NullValueHandling.Ignore en las opcionales
Tipos
long, double o decimal, bool, string, y arrays (T[]) o listas (List<T>); object para una clave que vale null en toda la muestra; una estructura de unión cuando un valor tiene dos tipos; desde un JSON Schema, también enums y DateTimeOffset

Dónde se procesa tu JSON

Las clases se generan con JavaScript que se ejecuta en tu propio dispositivo: el JSON que pegas o abres y el C# que obtienes nunca se suben. La biblioteca quicktype se carga la primera vez que pulsas «Convertir». Cuando la página muestra un error, nuestro registro de errores recibe su texto, sin los fragmentos citados, los números largos ni las direcciones web o de correo, junto con el nombre de la herramienta y el nombre y la versión de tu navegador.

Preguntas frecuentes

¿Funciona con Newtonsoft.Json (Json.NET)?

Sí. Elige Newtonsoft.Json en «Serializador»: cada propiedad recibe entonces un atributo [JsonProperty] con su clave original, y las opcionales añaden NullValueHandling = NullValueHandling.Ignore. Lee el JSON con JsonConvert.DeserializeObject<Root>(json), añadiendo Converter.Settings cuando la salida lo contiene.

¿Puedo partir de un JSON Schema?

Sí. Elige «JSON Schema» en «Origen» y luego pega o abre el esquema. Los tipos, las propiedades obligatorias, los enums y los formatos date-time salen del esquema. Un $ref solo se sigue dentro del documento (#/definitions/… o #/$defs/…): un esquema en otra dirección nunca se descarga, y la página lo indica.

¿Puedo obtener records en lugar de clases?

Sí. Marca «Records (C# 9+)»: cada tipo de modelo se convierte en un record public partial con las mismas propiedades y atributos, lo que requiere C# 9 o posterior (.NET 5 o posterior). Las estructuras de unión y las clases de conversión quedan como están.

¿Las clases deserializan mi JSON tal como están?

Sí, cuando cada clave mantiene un solo tipo: JsonSerializer.Deserialize asocia cada propiedad a su clave original mediante [JsonPropertyName]. Cuando un valor mezcla tipos, pasa como segundo argumento Converter.Settings, que entonces contiene la salida. Los tipos salen solo de tu muestra, así que compruébalos con más datos.

¿Una propiedad se tipa como object cuando su valor siempre es null?

Sí. Cuando una clave vale null en todos los elementos de tu muestra, no se puede deducir ningún tipo, así que se vuelve object. Pega un ejemplo en el que la clave tenga un valor real, o indica tú mismo el tipo, por ejemplo string? para un texto opcional.

¿Puedo usar int en lugar de long?

Sí. Los números enteros siempre se tipan como long para que quepan los valores grandes; si tus valores son pequeños, cambia long por int a mano: el atributo y la correspondencia con la clave siguen funcionando.

Consejos y trucos

  • ✓Pega un array con varios elementos para que las propiedades que a veces faltan se vuelvan nullable.
  • ✓Elige decimal en «Números decimales» para precios e importes: double no puede representar con exactitud valores como 0,1.