Cómo Convertir Un Arreglo JSON En Una List T En C#

Aug 6, 2025 by ADMIN 51 views

Convirtiendo arreglos JSON a List<T> en C#

JSON (JavaScript Object Notation) se ha convertido en el formato estándar para el intercambio de datos en aplicaciones web debido a su legibilidad y facilidad de uso. En el desarrollo de C#, a menudo nos encontramos con la necesidad de convertir datos JSON en objetos C# para su manipulación. Uno de los escenarios comunes es la conversión de un arreglo JSON a una List, donde T representa el tipo de objeto C# deseado. Este artículo te guiará a través de los métodos y técnicas para lograr esta conversión de manera eficiente y efectiva, utilizando bibliotecas populares como System.Text.Json y Newtonsoft.Json. ¡Prepárense, chicos, que vamos a sumergirnos en el fascinante mundo de JSON y C#!

¿Por qué convertir JSON a List?

Antes de entrar en detalles técnicos, es crucial entender por qué querríamos convertir un arreglo JSON a una List. JSON, al ser un formato de texto, es ideal para la transmisión de datos a través de la web. Sin embargo, en C#, trabajar directamente con cadenas JSON puede ser engorroso. La conversión a una List nos permite:

Manipular los datos como objetos: En lugar de tratar los datos como texto, podemos acceder a ellos a través de propiedades y métodos de objetos C#.
Aprovechar las ventajas de LINQ: Las listas son compatibles con LINQ (Language Integrated Query), lo que facilita la consulta y manipulación de datos.
Tipado fuerte: Al convertir a una List, tenemos la seguridad de que los datos tienen el tipo esperado, lo que reduce errores en tiempo de ejecución.
Mayor legibilidad y mantenibilidad del código: Trabajar con objetos C# en lugar de cadenas JSON hace que el código sea más fácil de entender y mantener.

Métodos para convertir JSON a List

Existen varias formas de convertir un arreglo JSON a una List en C#. A continuación, exploraremos dos de los métodos más comunes y efectivos:

System.Text.Json: La biblioteca System.Text.Json es la opción recomendada por Microsoft para trabajar con JSON en .NET. Ofrece un rendimiento superior y está integrada en el framework .NET.
Newtonsoft.Json: Newtonsoft.Json es una biblioteca de terceros muy popular y ampliamente utilizada para el manejo de JSON en C#. Es conocida por su flexibilidad y características avanzadas.

Usando System.Text.Json

System.Text.Json es la biblioteca oficial de Microsoft para serialización y deserialización JSON en .NET. Es una opción de alto rendimiento y es ideal para proyectos que buscan eficiencia y optimización. Para usar System.Text.Json, primero debes asegurarte de tener el paquete instalado en tu proyecto. Puedes hacerlo a través del NuGet Package Manager.

Instalación

Para instalar System.Text.Json, puedes usar el NuGet Package Manager Console o la interfaz gráfica de NuGet Package Manager en Visual Studio. Aquí te muestro cómo hacerlo usando la consola:

Install-Package System.Text.Json

Este comando descargará e instalará el paquete System.Text.Json en tu proyecto.

Deserialización con System.Text.Json

Una vez instalado, puedes usar la clase JsonSerializer para deserializar tu JSON a una List. Aquí tienes un ejemplo detallado:

using System.Collections.Generic;
using System.Text.Json;

public class Persona
{
    public string Nombre { get; set; }
    public int Edad { get; set; }
}

public class EjemploSystemTextJson
{
    public static List<Persona> ConvertirJsonALista(string jsonString)
    {
        try
        {
            // Deserializa la cadena JSON a una List<Persona>
            List<Persona> personas = JsonSerializer.Deserialize<List<Persona>>(jsonString);
            return personas;
        }
        catch (JsonException ex)
        {
            // Maneja las excepciones de deserialización
            Console.WriteLine({{content}}quot;Error al deserializar JSON: {ex.Message}");
            return null;
        }
    }

    public static void Main(string[] args)
    {
        // Ejemplo de cadena JSON
        string jsonString = "[{\"Nombre\":\"Juan\",\"Edad\":30},{\"Nombre\":\"Maria\",\"Edad\":25}]";

        // Convierte la cadena JSON a una List<Persona>
        List<Persona> listaPersonas = ConvertirJsonALista(jsonString);

        // Verifica si la lista es nula
        if (listaPersonas != null)
        {
            // Imprime los elementos de la lista
            foreach (var persona in listaPersonas)
            {
                Console.WriteLine({{content}}quot;Nombre: {persona.Nombre}, Edad: {persona.Edad}");
            }
        }
        else
        {
            Console.WriteLine("No se pudo convertir la cadena JSON a List<Persona>.");
        }
    }
}

En este ejemplo:

Definimos una clase Persona con propiedades Nombre y Edad.
La función ConvertirJsonALista toma una cadena JSON y usa JsonSerializer.Deserialize<List<Persona>> para convertirla en una List<Persona>. Aquí es donde la magia sucede, chicos. System.Text.Json se encarga de analizar la cadena JSON y crear una lista de objetos Persona.
Se incluye un bloque try-catch para manejar posibles excepciones durante la deserialización.
En el método Main, se muestra cómo usar la función y cómo iterar sobre la lista resultante para imprimir los datos. Si algo sale mal durante la conversión, atrapamos la excepción y mostramos un mensaje de error.

Usando Newtonsoft.Json

Newtonsoft.Json, también conocido como Json.NET, es una biblioteca de terceros muy popular para trabajar con JSON en C#. Es conocida por su flexibilidad, amplia gama de características y excelente rendimiento. Aunque System.Text.Json es la opción recomendada por Microsoft, Newtonsoft.Json sigue siendo una excelente opción, especialmente si ya lo estás utilizando en tu proyecto o necesitas características específicas que no están disponibles en System.Text.Json.

Instalación

Al igual que con System.Text.Json, primero debes instalar el paquete Newtonsoft.Json en tu proyecto. Puedes hacerlo a través del NuGet Package Manager.

Usando la consola:

Install-Package Newtonsoft.Json

Deserialización con Newtonsoft.Json

Una vez instalado, puedes usar la clase JsonConvert para deserializar tu JSON a una List. Aquí tienes un ejemplo detallado:

using System;
using System.Collections.Generic;
using Newtonsoft.Json;

public class Persona
{
    public string Nombre { get; set; }
    public int Edad { get; set; }
}

public class EjemploNewtonsoftJson
{
    public static List<Persona> ConvertirJsonALista(string jsonString)
    {
        try
        {
            // Deserializa la cadena JSON a una List<Persona>
            List<Persona> personas = JsonConvert.DeserializeObject<List<Persona>>(jsonString);
            return personas;
        }
        catch (JsonException ex)
        {
            // Maneja las excepciones de deserialización
            Console.WriteLine({{content}}quot;Error al deserializar JSON: {ex.Message}");
            return null;
        }
    }

    public static void Main(string[] args)
    {
        // Ejemplo de cadena JSON
        string jsonString = "[{\"Nombre\":\"Juan\",\"Edad\":30},{\"Nombre\":\"Maria\",\"Edad\":25}]";

        // Convierte la cadena JSON a una List<Persona>
        List<Persona> listaPersonas = ConvertirJsonALista(jsonString);

        // Verifica si la lista es nula
        if (listaPersonas != null)
        {
            // Imprime los elementos de la lista
            foreach (var persona in listaPersonas)
            {
                Console.WriteLine({{content}}quot;Nombre: {persona.Nombre}, Edad: {persona.Edad}");
            }
        }
        else
        {
            Console.WriteLine("No se pudo convertir la cadena JSON a List<Persona>.");
        }
    }
}

Este ejemplo es muy similar al anterior, pero utiliza Newtonsoft.Json en lugar de System.Text.Json. La principal diferencia está en la línea de deserialización:

List<Persona> personas = JsonConvert.DeserializeObject<List<Persona>>(jsonString);

Aquí, JsonConvert.DeserializeObject<List<Persona>> se encarga de la conversión. Newtonsoft.Json es muy intuitivo y fácil de usar, lo que lo convierte en una excelente opción para muchos desarrolladores.

Comparación entre System.Text.Json y Newtonsoft.Json

Ambas bibliotecas son excelentes opciones para trabajar con JSON en C#, pero tienen algunas diferencias clave:

Característica	System.Text.Json	Newtonsoft.Json
Rendimiento	Generalmente más rápido y eficiente en el uso de memoria. Ideal para aplicaciones de alto rendimiento.	Sigue siendo rápido, pero generalmente un poco más lento que System.Text.Json.
Integración	Integrado en el framework .NET. No requiere la instalación de paquetes adicionales.	Requiere la instalación del paquete Newtonsoft.Json.
Flexibilidad	Menos flexible en términos de opciones de configuración y características avanzadas.	Muy flexible con muchas opciones de configuración y características avanzadas, como serialización personalizada, atributos para controlar la serialización, etc.
Soporte	Soporte oficial de Microsoft.	Amplia comunidad y soporte. Muy bien documentado y con muchos ejemplos disponibles.
Características	Centrado en el rendimiento y la seguridad. Soporte para JSON estándar y algunas características comunes.	Amplia gama de características, incluyendo soporte para JSON complejo, serialización y deserialización personalizada, soporte para diferentes formatos de fecha, etc.
Uso recomendado	Recomendado para nuevas aplicaciones y proyectos que buscan rendimiento y eficiencia. Ideal si no necesitas características avanzadas y estás trabajando con .NET Core 3.1 o posterior.	Recomendado para proyectos existentes que ya usan Newtonsoft.Json o que requieren características avanzadas. También es una buena opción si necesitas compatibilidad con versiones anteriores de .NET.

Manejo de Errores y Excepciones

Al convertir JSON a List, es crucial manejar posibles errores y excepciones. Aquí hay algunas situaciones comunes y cómo abordarlas:

JSON inválido: Si la cadena JSON no tiene el formato correcto, ambas bibliotecas lanzarán una excepción. Es importante envolver el código de deserialización en un bloque try-catch para capturar estas excepciones.
Incompatibilidad de tipos: Si la estructura del JSON no coincide con la estructura de la clase C#, la deserialización fallará. Asegúrate de que los nombres de las propiedades y los tipos de datos coincidan.
Valores nulos: Si el JSON contiene valores nulos, debes asegurarte de que las propiedades C# correspondientes puedan aceptar valores nulos (usando ? para tipos de valor nullable).

Aquí tienes un ejemplo de cómo manejar excepciones usando try-catch:

try
{
    List<Persona> personas = JsonSerializer.Deserialize<List<Persona>>(jsonString);
    // Haz algo con la lista de personas
}
catch (JsonException ex)
{
    Console.WriteLine({{content}}quot;Error al deserializar JSON: {ex.Message}");
    // Maneja el error (por ejemplo, registra el error, muestra un mensaje al usuario, etc.)
}

Ejemplos Avanzados

Serialización y Deserialización Personalizada

A veces, necesitas un control más fino sobre cómo se serializa y deserializa el JSON. Ambas bibliotecas ofrecen mecanismos para la serialización y deserialización personalizada.

System.Text.Json

Con System.Text.Json, puedes usar JsonConverter para personalizar el proceso. Aquí tienes un ejemplo:

using System;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;

public class Persona
{
    public string Nombre { get; set; }
    public int Edad { get; set; }
}

public class PersonaConverter : JsonConverter<Persona>
{
    public override Persona Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        if (reader.TokenType != JsonTokenType.StartObject)
        {
            throw new JsonException();
        }

        string nombre = null;
        int edad = 0;

        while (reader.Read())
        {
            if (reader.TokenType == JsonTokenType.EndObject)
            {
                return new Persona { Nombre = nombre, Edad = edad };
            }

            if (reader.TokenType == JsonTokenType.PropertyName)
            {
                string propertyName = reader.GetString();
                reader.Read();
                switch (propertyName)
                {
                    case "nombre":
                        nombre = reader.GetString();
                        break;
                    case "edad":
                        edad = reader.GetInt32();
                        break;
                }
            }
        }

        throw new JsonException();
    }

    public override void Write(Utf8JsonWriter writer, Persona persona, JsonSerializerOptions options)
    {
        writer.WriteStartObject();
        writer.WriteString("nombre", persona.Nombre);
        writer.WriteNumber("edad", persona.Edad);
        writer.WriteEndObject();
    }
}

public class EjemploSystemTextJsonPersonalizado
{
    public static void Main(string[] args)
    {
        string jsonString = "[{\"nombre\":\"Juan\",\"edad\":30},{\"nombre\":\"Maria\",\"edad\":25}]";

        JsonSerializerOptions options = new JsonSerializerOptions();
        options.Converters.Add(new PersonaConverter());

        try
        {
            List<Persona> personas = JsonSerializer.Deserialize<List<Persona>>(jsonString, options);

            foreach (var persona in personas)
            {
                Console.WriteLine({{content}}quot;Nombre: {persona.Nombre}, Edad: {persona.Edad}");
            }
        }
        catch (JsonException ex)
        {
            Console.WriteLine({{content}}quot;Error al deserializar JSON: {ex.Message}");
        }
    }
}

Newtonsoft.Json

Con Newtonsoft.Json, puedes usar JsonConverter de manera similar. Aquí tienes un ejemplo:

using System;
using System.Collections.Generic;
using Newtonsoft.Json;

public class Persona
{
    public string Nombre { get; set; }
    public int Edad { get; set; }
}

public class PersonaConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(Persona);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (reader.TokenType != JsonToken.StartObject)
        {
            throw new JsonException();
        }

        string nombre = null;
        int edad = 0;

        while (reader.Read())
        {
            if (reader.TokenType == JsonToken.EndObject)
            {
                return new Persona { Nombre = nombre, Edad = edad };
            }

            if (reader.TokenType == JsonToken.PropertyName)
            {
                string propertyName = reader.Value.ToString();
                reader.Read();
                switch (propertyName)
                {
                    case "nombre":
                        nombre = reader.Value.ToString();
                        break;
                    case "edad":
                        edad = Convert.ToInt32(reader.Value); // Convertir a Int32
                        break;
                }
            }
        }

        throw new JsonException();
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        var persona = (Persona)value;
        writer.WriteStartObject();
        writer.WritePropertyName("nombre");
        writer.WriteValue(persona.Nombre);
        writer.WritePropertyName("edad");
        writer.WriteValue(persona.Edad);
        writer.WriteEndObject();
    }
}

public class EjemploNewtonsoftJsonPersonalizado
{
    public static void Main(string[] args)
    {
        string jsonString = "[{\"nombre\":\"Juan\",\"edad\":30},{\"nombre\":\"Maria\",\"edad\":25}]";

        try
        {
            List<Persona> personas = JsonConvert.DeserializeObject<List<Persona>>(jsonString, new PersonaConverter());

            foreach (var persona in personas)
            {
                Console.WriteLine({{content}}quot;Nombre: {persona.Nombre}, Edad: {persona.Edad}");
            }
        }
        catch (JsonException ex)
        {
            Console.WriteLine({{content}}quot;Error al deserializar JSON: {ex.Message}");
        }
    }
}

Uso de Atributos para Controlar la Serialización

Ambas bibliotecas también permiten usar atributos para controlar cómo se serializan y deserializan las propiedades. Esto es útil cuando necesitas renombrar propiedades, ignorar propiedades o especificar formatos de fecha.

System.Text.Json

using System.Text.Json.Serialization;

public class Persona
{
    [JsonPropertyName("nombre_completo")]
    public string Nombre { get; set; }

    [JsonIgnore]
    public int Edad { get; set; }
}

Newtonsoft.Json

using Newtonsoft.Json;

public class Persona
{
    [JsonProperty("nombre_completo")]
    public string Nombre { get; set; }

    [JsonIgnore]
    public int Edad { get; set; }
}

Conclusión

La conversión de arreglos JSON a List en C# es una tarea común y esencial en el desarrollo de aplicaciones web y servicios. Ya sea que elijas System.Text.Json para un rendimiento óptimo o Newtonsoft.Json por su flexibilidad y características avanzadas, tienes las herramientas necesarias para manejar esta tarea de manera eficiente. Recuerda manejar las excepciones, considerar la serialización personalizada y usar atributos para un control más fino sobre el proceso. ¡Espero que esta guía te haya sido útil, chicos! ¡Ahora a convertir JSON como campeones!

Preguntas Frecuentes

¿Qué biblioteca debo usar, System.Text.Json o Newtonsoft.Json?

Si estás comenzando un nuevo proyecto y buscas rendimiento y eficiencia, System.Text.Json es la mejor opción.
Si ya estás usando Newtonsoft.Json en tu proyecto o necesitas características avanzadas, Newtonsoft.Json sigue siendo una excelente opción.

¿Cómo manejo los errores de deserialización?

Envuelve el código de deserialización en un bloque try-catch para capturar excepciones como JsonException.
Asegúrate de que la estructura del JSON coincida con la estructura de la clase C#.

¿Puedo personalizar la serialización y deserialización?

Sí, ambas bibliotecas ofrecen mecanismos para la serialización y deserialización personalizada usando JsonConverter.

¿Cómo ignoro propiedades durante la serialización?

Usa el atributo [JsonIgnore] en la propiedad que deseas ignorar.

¿Cómo cambio el nombre de una propiedad en el JSON?

Usa el atributo `[JsonPropertyName(