JSON (JavaScript Object Notation) es un estándar de formato ligero para el intercambio de información. Basado en un subconjunto de la sintaxis de JavaScript, este formato es independiente del lenguaje, lo que facilita su transporte a través de diversas plataformas y aplicaciones. Su estructura es sencilla, permitiendo que tanto humanos como máquinas puedan leerlo y generarlo sin dificultad.

Comparativa: JSON frente a XML

• Legibilidad: Aunque ambos son legibles, XML suele ser más descriptivo gracias a sus etiquetas explícitas, facilitando la comprensión visual compleja.
• Eficiencia de transferencia: JSON es considerablemente más liviano que XML al prescindir de etiquetas de cierre redundantes. Debido a su origen en JavaScript, posee una integración nativa y superior en entornos web.

Reglas fundamentales de sintaxis

Los datos en JSON se estructuran en pares de nombre/valor. El nombre siempre es una cadena entre comillas dobles, mientars que el valor puede ser un número, una cadena, un booleano, un objeto, un arreglo o un valor nulo. Los objetos se delimitan con llaves {} y los arreglos con corchetes [].

{
  "tecnicos": [
    { "nombre": "Ana", "rol": "Desarrolladora" },
    { "nombre": "Luis", "rol": "Arquitecto" }
  ]
}

Es importante recordar que si el contenido incluye caracteres especiales, estos deben escaparse (por ejemplo, una ruta de archivo requiere "C:\\\\datos\\\\archivo.json").

Estrategias para manipular JSON en .NET

1. Uso de Newtonsoft.Json (Json.NET)

Esta es la biblioteca de terceros más extendida debido a su flexibilidad y alto rendimiento. Permite trabajar mediante JsonReader, JsonWriter o el modelo de objetos JObject.

Lectura con JsonTextReader:

string fuenteJson = @"{""clave"" : ""valor"", ""estado"" : ""activo""}";
using (JsonReader lector = new JsonTextReader(new StringReader(fuenteJson)))
{
    while (lector.Read())
    {
        if (lector.Value != null)
        {
            Console.WriteLine($"Tipo: {lector.TokenType}, Valor: {lector.Value}");
        }
    }
}

Escritura con JsonTextWriter:

StringWriter sw = new StringWriter();
using (JsonWriter escritor = new JsonTextWriter(sw))
{
    escritor.WriteStartObject();
    escritor.WritePropertyName("id");
    escritor.WriteValue(101);
    escritor.WritePropertyName("categoria");
    escritor.WriteValue("software");
    escritor.WriteEndObject();
}
string resultado = sw.ToString();

Uso de JObject para acceso dinámico:

string datosJson = "{\"config\":{\"idioma\":\"es\",\"version\":1.2}}";
JObject obj = JObject.Parse(datosJson);
string idiomaActual = obj["config"]["idioma"].ToString();

Serialización de objetos personalizados:

public class Registro
{
    public string Entrada { get; set; }
    public string Salida { get; set; }
}

// Serializar
Registro reg = new Registro { Entrada = "Inicio", Salida = "Fin" };
string jsonSerializado = JsonConvert.SerializeObject(reg);

// Deserializar
Registro regClon = JsonConvert.DeserializeObject<Registro>(jsonSerializado);

2. Utilizando JavaScriptSerializer

Disponible en el espacio de nombres System.Web.Script.Serialization (requiere referencia a System.Web.Extensions.dll), es una opción directa integrada en el Framework para serialización básica.

var serializador = new JavaScriptSerializer();
Registro miRegistro = new Registro { Entrada = "Sensor_A", Salida = "Procesado" };

// Convertir objeto a cadena
string jsonString = serializador.Serialize(miRegistro);

// Reconstruir objeto desde cadena
Registro registroRecuperado = serializador.Deserialize<Registro>(jsonString);

3. Enfoque mediante Contratos (DataContractJsonSerializer)

Este método requiere definir explícitamente los contratos de datos mediante atributos, lo que proporciona un control estricto sobre la estructura del JSON generado.

[DataContract]
public class Documento
{
    [DataMember]
    public string Titulo { get; set; }
    [DataMember]
    public int Paginas { get; set; }
}

// Proceso de escritura en flujo de memoria
Documento doc = new Documento { Titulo = "Guía C#", Paginas = 45 };
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Documento));
using (MemoryStream ms = new MemoryStream())
{
    ser.WriteObject(ms, doc);
    string jsonFinal = Encoding.UTF8.GetString(ms.ToArray());
}

El uso de serialización y deserialización es una de las formas más comunes de realizar una "copia profunda" (deep copy) de objetos en .NET, garantizando que la nueva instancia sea totalmente independiente de la original.