Convert XML to JSON in C# With Json.NET and Couchbase

La conversión de XML a JSON es un requisito común al actualizar aplicaciones .NET: la migración de servicios o almacenes basados en XML heredados a sistemas nativos de JSON como Servidor Couchbase o Couchbase Capella. En C#, dos bibliotecas gestionan esta conversión: Newtonsoft Json.NET (el estándar comunitario de larga data, ahora en v13) y System.Text.Json (integrado en .NET Core 3.1+ como una alternativa ligera). Este artículo cubre las diferencias clave entre XML y JSON, cómo realizar la conversión utilizando ambas bibliotecas, casos de uso a tener en cuenta y cómo almacenar los documentos JSON resultantes en Couchbase utilizando el SDK de .NET.

XML vs. JSON: Diferencias clave

Característica	XML	JSON	Consideraciones sobre la migración
Sintaxis	Baseado en etiquetas: Alice	Valores clave-valor: {“name”: “Alice”}	Las etiquetas XML se convierten en claves JSON
Gran cantidad de palabras	Alto: etiquetas de apertura y cierre	Bajo: mínima sobrecarga de sintaxis	Los documentos JSON pueden ser un 30-60% más pequeños que los equivalentes en XML.
Matrices	Elementos repetidos:	Tipo de matriz nativo: [“a”,”b”]	Elementos XML repetidos
Atributos	Nativo:	No hay equivalente directo	Los atributos XML necesitan una conveniencia en el objeto JSON, por ejemplo, el campo @id o id` en el objeto JSON.
Lectura humana	Modera: extenso pero estructurado	Alto: compacto y familiar para los desarrolladores	El formato JSON es generalmente preferido para las API modernas y los bancos de datos de documentos.
Suporte para navegadores y API	En declinación: las API REST prefieren el formato JSON	Universal: nativo en JavaScript	Las API REST casi siempre utilizan JSON; el XML sigue estando presente en SOAP o en sistemas heredados.

Opcion 1: Newtonsoft Json.NET

Newtonsoft Json.NET es la biblioteca JSON más utilizada en el ecosistema .NET. Proporciona una conversión de XML a JSON en una sola línea mediante XmlNodeConverter:

var xmlDoc = new XmlDocument();
xmlDoc.LoadXml(xml);

string jsonNewtonsoft =
    JsonConvert.SerializeXmlNode(xmlDoc, Newtonsoft.Json.Formatting.Indented);
Output:
{
  “user”: {
    “@id”: “1”,
    “name”: “Alice”,
    “email”: “alice@example.com”,
    “roles”: {
      “role”: [
        “admin”,
        “editor”
      ]
    }
  }
}

var xmlDoc = nuevo XmlDocument();

xmlDoc.LoadXml(xml);

cadena jsonNewtonsoft =

JsonConvert.SerializeXmlNode(xmlDoc, Newtonsoft.Json.Formatación.Con líneas separadas);

Salida:

{

“usuario”: {

“@id”: “1”,

“nombre”: “Alice”,

“correo electrónico”: “alice@example.com”,

“roles”: {

“rol”: [

“admin”,

“editor”

]

}

Opcion 2: System.Text.Json (.NET integrado)

System.Text.Json está integrado en .NET (Core) 3.1 y versiones posteriores. No tiene una conversión nativa de XML a JSON, pero se puede combinar con XDocument para un enfoque en dos pasos:

var xdoc = XDocument.Parse(xml);
var dict = XmlToDictionary(xdoc.Root!);

string jsonSystemText = System.Text.Json.JsonSerializer.Serialize(
    dict,
    new JsonSerializerOptions { WriteIndented = true });

var xdoc = XDocument.Parse(xml);

var dict = XmlToDictionary(xdoc.Roto!);

cadena jsonSystemText = Sistema.Texto.Json.SerializerJson.Serializar(

dict,

nuevo SerializerOptions { WriteIndented = verdadero });

Esta opción requiere una función auxiliar:

static object XmlToDictionary(XElement element)
{
    var hasElements = element.Elements().Any();

    // leaf node
    if (!hasElements)
    {
        return element.Value;
    }

    var dict = new Dictionary<string, object>();

    // group children by name (handles arrays)
    foreach (var group in element.Elements().GroupBy(e => e.Name.LocalName))
    {
        if (group.Count() == 1)
        {
            dict[group.Key] = XmlToDictionary(group.First());
        }
        else
        {
            dict[group.Key] = group
                .Select(XmlToDictionary)
                .ToList();
        }
    }

    // attributes (prefix with @ to match Newtonsoft style)
    foreach (var attr in element.Attributes())
    {
        dict[$”@{attr.Name.LocalName}”] = attr.Value;
    }

    return dict;
}

estático objeto XmlToDictionary(XElement elemento)

{

var tiene elementos = elemento.Elementos().Cualquiera();

// nodo de hoja

si (!tiene elementos)

{

regresar elemento.Valores;

}

var dict = nuevo Diccionario<cadena, objetoEl resultado de tu pregunta se muestra a continuación:();

// Agrupar los niños por nombre (maneja matrices)

para cada (var grupo en elemento.Elementos().GroupBy(e =El resultado de tu pregunta se muestra a continuación: e.Nombre.LocalName))

{

si (grupo.Conde() == 1)

{

dict[grupo.Llave] = XmlToDictionary(grupo.Primero());

}

otro

{

dict[grupo.Llave] = grupo

.Seleccionar(XmlToDictionary)

.ToList();

}

// atributos (prefijo con @ para coincidir con el estilo de Newtonsoft)

para cada (var attr en elemento.Atributos())

{

dict[$“@{attr.Name.LocalName}”] = attr.Valores;

}

regresar dict;

}

Para la mayoría de los escenarios de migración de XML a JSON, Newtonsoft Json.NET es la opción más sencilla y generalmente ofrece más funcionalidades. System.Text.Json sería la opción más adecuada para nuevos proyectos en .NET 6+ que no migren de XML y cuando la eficiencia de la serialización sea crucial.

Característica	Newtonsoft Json.NET	System.Text.Json
Conversión XML	Native: SerializeXmlNode y DeserializeXmlNode	Manual: requiere código auxiliar personalizado
Rendimiento	En general, adecuado	Optimizado para Span /SpanReadOnly
Disponibilidad	Paquete NuGet	Incorporado en .NET Core 3.1+ / .NET 5+
Flexibilidad	Alto: amplio conjunto de características y opciones de personalización	Moderado: opiniones encontradas, menos puntos de extensión
Cuando considerar	Migración de XML; escenarios de serialización complejos	Nuevos proyectos .NET 6+; API’s sensibles al rendimiento

Almacenamiento de JSON convertido en Couchbase (.NET SDK)

Una vez convertidos en JSON, los documentos se pueden almacenar en Couchbase utilizando el SDK de .NET 3.x. El SDK acepta cualquier objeto C# o JObject (de NewtonSoft) como valor de documento:

var cluster = await Cluster.ConnectAsync(
    “couchbases://cb..cloud.couchbase.com”,
    new ClusterOptions
    {
        UserName = “xmlconvert”,
        Password = “password”
    });

var bucket = await cluster.BucketAsync(“loadxml”);
var collection = await bucket.DefaultCollectionAsync();

var jsonObj = JObject.Parse(jsonNewtonsoft);
var documentId = $”user::{jsonObj[“user”]![“@id”]}”;

await collection.UpsertAsync(documentId, jsonObj);

var clúster = esperar Clúster.ConnectAsync(

“couchbases://cb..cloud.couchbase.com”,

nuevo OpcionesDeClúster

{

Nombre de usuario = “xmlconvert”,

Contraseña = “contraseña”

});

var cubeta = esperar clúster.BucketAsync(“loadxml”);

var colección = esperar cubeta.DefaultCollectionAsync();

var jsono = JObject.Parse(jsonNewtonsoft);

var documentId = $“user::{jsonObj[“usuario“]![“@identificación“]}”;

esperar colección.UpsertAsync(documentId, jsono);

Para la migración masiva de muchos documentos XML, utilice Tarea.CuandoTodos Para insertar/agregar documentos de forma paralela:

var xmlSamples = new List { xmlA, xmlB };

var tasks = xmlSamples.Select(async (x, i) =>
{
    var doc = new XmlDocument();
    doc.LoadXml(x);

    var json = JsonConvert.SerializeXmlNode(doc, Newtonsoft.Json.Formatting.None);
    var obj = JObject.Parse(json);

    var id = $”doc::{i}”;
    await collection.UpsertAsync(id, obj);

    await Task.Delay(10); // simulate async work

    Console.WriteLine($”Processed {id}”);
});

await Task.WhenAll(tasks);

var xmlSamples = nuevo Lista { xmlA, xmlB };

var tareas = xmlSamples.Seleccionar(asíncrono (x, i) =El resultado de tu pregunta se muestra a continuación:

{

var doc. = nuevo XmlDocument();

doc..LoadXml(x);

var json = JsonConvert.SerializeXmlNode(doc., Newtonsoft.Json.Formatación.Ninguno);

var obj = JObject.Parse(json);

var identificación = $“doc {i}::”;

esperar colección.UpsertAsync(identificación, obj);

esperar Tarea.Retraso(10); // Simular un trabajo async

Consola.EscribirLínea($“Tratado {id}”);

});

esperar Tarea.Cuando todo(tareas);

Casos comunes

Caso extremo	Problema	Solución
Elementos individuales versus múltiples elementos	Un único El elemento se convierte en una cadena; los múltiples se convierten en una matriz	Generar la salida de la matriz mediante la configuración JsonConvert o procesar el JSON en etapas posteriores
Atributos XML vs. elementos	Los atributos reciben el prefijo @ en la salida de Json.NET	Retirar @ del prefijo en el proceso de post-procesamiento si no es necesario en los documentos de Couchbase
Nombres de espacio XML	Los espacios de nombres aparecen como claves @xmlns	Despeje los nombres de los espacios de nombres antes de la conversión mediante XmlDocument.RemoveAll() en los nodos de espacios de nombres
Elementos nulos / vacíos	Las etiquetas XML vacías se convierten en cadenas null o vacías	Normalizar a null o eliminar del documento en el proceso de postprocesamiento
Archivos XML de gran tamaño	La carga de un XmlDocument grande en la memoria puede causar errores de sobrecarga de memoria.	Utilice XmlReader para la conversión en streaming de archivos grandes

Preguntas frecuentes

¿Cómo puedo convertir XML a JSON en C#?

La forma más sencilla es Newtonsoft Json.NET: carga tu XML en un XmlDocument, luego llama JsonConverter.SerializeXmlNode(doc). Para proyectos .NET 6+ que no necesiten migración de XML, System.Text.Json es la alternativa integrada. Consulta los ejemplos de código anteriores para ambos enfoques.

¿Qué es Newtonsoft Json.NET?

Newtonsoft Json.NET es la biblioteca JSON más utilizada en el ecosistema .NET, mantenida por James Newton-King. Su versión actual es 13.x. Provee serialización, deserialización, consulta (LINQ a JSON) y conversión de XML a JSON. Instalación mediante NuGet: Instalar-Package Newtonsoft.Json.

¿Cuál es la diferencia entre XML y JSON?

El XML utiliza una sintaxis basada en etiquetas con atributos, espacios de nombres y validación de esquemas mediante XSD. El JSON utiliza un formato compacto de clave-valor que el JavaScript soporta de forma nativa. Los documentos JSON suelen ser un 30-60% más pequeños, más rápidos en análisis y universalmente compatibles con las API REST modernas y los bancos de datos de documentos. Consulte la tabla de comparación anterior para obtener una descripción completa.

¿Cómo guardo el JSON convertido en Couchbase desde C#? Utilice el SDK de .NET de Couchbase 3.x (NuGet: CouchbaseNetClient). Conéctese a su clúster de Couchbase o a un punto de acceso de Capella, obtenga una referencia a una colección y llame collection. UpsertAsync(documentId, jsonObject). El SDK acepta JObject (de Newtonsoft) o cualquier POCO .NET. Consulte el ejemplo de código en la sección “Almacenamiento en Couchbase” anterior.

¿Debería usar Newtonsoft Json.NET o System.Text.Json? En los casos de migración de XML, Newtonsoft Json.NET es la mejor opción: tiene una conversión nativa de XML a JSON mediante SerializeXmlNode(). Para nuevos proyectos .NET 6+ que no impliquen XML, System.Text.Json es la opción preferida: está integrada, eficiente en la asignación de recursos y ofrece mejores resultados en escenarios de alta velocidad de procesamiento.

Conclusión

La conversión de XML a JSON en C# es sencilla con Newtonsoft Json.NET. SerializeXmlNode método. Las consideraciones principales son el manejo de atributos (@ prefix convention), la coerción repetida de matrices de elementos y la eliminación de espacios de nombres. Una vez convertido, el SDK de Couchbase .NET simplifica la manera de almacenar los documentos JSON resultantes en Couchbase Capella o Server utilizando UpsertAsync.

Este post del blog se inspiró en una conversación por correo electrónico con un usuario de Couchbase. Si tienes alguna sugerencia sobre herramientas, consejos o trucos para facilitar este proceso, por favor déjame saber. ¡O, contacta conmigo si hay algo que quieras que escriba en mi blog! Puedes envíame un correo electrónico o Contacte conmigo @mgroves en X.

¿Por qué Couchbase?

Por industria

Por caso de uso

Centro de recursos

Construya sobre Couchbase

Quiénes somos

Socios

Conversión de XML a JSON con Json.NET

Couchbase Named a Leader in the 2026 IDC MarketScape for Worldwide Operational Databases

Benchmarking Billion-Scale Vector Indexes

Por qué los agentes de IA fallan en la producción: El problema de la capa de datos

De Prompt a Edge AI: los participantes del hackathon crean aplicaciones móviles en menos de una hora

¿Qué es la IA en el borde? Ejemplos y beneficios de la computación en el borde

Deje el desorden de las bases de datos en el pasado