serialización Json y Xml, ¿qué es un mejor rendimiento?

Question

Tengo que almacenar alguna información de configuración en el archivo. En la configuración del código C#, los datos representan por clase y en archivo, voy a guardar esta clase en formato json o xml. Entonces, ¿cuál es el mejor rendimiento de serialización json o xml?

Answer 1

Bueno en vez de adivinar, no tengo la respuesta. Aquí está el programa de prueba:

class Program 
{ 
    static void Main(string[] args) 
    { 
     string xmlConfig = ""; 
     string jsonConfig = ""; 

     Config myConfig = new Config() 
     { 
      value = "My String Value", 
      DateStamp = DateTime.Today, 
      counter = 42, 
      Id = Guid.NewGuid() 
     }; 

     // Make both strings 
     DataContractSerializer xmlSerializer = new DataContractSerializer(typeof(Config)); 
     using (MemoryStream xmlStream = new MemoryStream()) 
     { 
      xmlSerializer.WriteObject(xmlStream, myConfig); 
      xmlConfig = Encoding.UTF8.GetString(xmlStream.ToArray()); 
     } 

     DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(Config)); 
     using (MemoryStream jsonStream = new MemoryStream()) 
     { 
      jsonSerializer.WriteObject(jsonStream, myConfig); 
      jsonConfig = Encoding.UTF8.GetString(jsonStream.ToArray()); 
     } 

     // Test Single 
     var XmlSingleTimer = Stopwatch.StartNew(); 
     SerializeXML(xmlConfig, 1); 
     XmlSingleTimer.Stop(); 

     var JsonSingleTimer = Stopwatch.StartNew(); 
     SerializeJSON(jsonConfig, 1); 
     JsonSingleTimer.Stop(); 

     // Test 1000 
     var XmlTimer = Stopwatch.StartNew(); 
     SerializeXML(xmlConfig, 1000); 
     XmlTimer.Stop(); 

     var JsonTimer = Stopwatch.StartNew(); 
     SerializeJSON(jsonConfig, 1000); 
     JsonTimer.Stop(); 

     // Test 10000 
     var XmlTimer2 = Stopwatch.StartNew(); 
     SerializeXML(xmlConfig, 10000); 
     XmlTimer2.Stop(); 

     var JsonTimer2 = Stopwatch.StartNew(); 
      SerializeJSON(jsonConfig, 10000); 
     JsonTimer2.Stop(); 

     Console.WriteLine(String.Format("XML Serialization Single: {0}ms", XmlSingleTimer.Elapsed.TotalMilliseconds)); 
     Console.WriteLine(String.Format("JSON Serialization Single: {0}ms", JsonSingleTimer.Elapsed.TotalMilliseconds)); 
     Console.WriteLine(); 
     Console.WriteLine(String.Format("XML Serialization 1000: {0}ms", XmlTimer.Elapsed.TotalMilliseconds)); 
     Console.WriteLine(String.Format("JSON Serialization 1000: {0}ms ", JsonTimer.Elapsed.TotalMilliseconds)); 
     Console.WriteLine(); 
     Console.WriteLine(String.Format("XML Serialization 10000: {0}ms ", XmlTimer2.ElapsedMilliseconds)); 
     Console.WriteLine(String.Format("JSON Serialization 10000: {0}ms ", JsonTimer2.ElapsedMilliseconds)); 
    } 

    public static void SerializeXML(string xml, int iterations) 
    { 
     DataContractSerializer xmlSerializer = new DataContractSerializer(typeof(Config)); 
     for (int i = 0; i < iterations; i++) 
     { 
      using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(xml))) 
      { 
       Config serialized = (Config)xmlSerializer.ReadObject(stream); 
      } 
     } 
    } 

    public static void SerializeJSON(string json, int iterations) 
    { 
     DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(Config)); 
     for (int i = 0; i < iterations; i++) 
     { 
      using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(json))) 
      { 
       Config serialized = (Config)jsonSerializer.ReadObject(stream); 
      } 
     } 
    } 
} 

public class Config 
{ 
    public string value; 
    public DateTime DateStamp; 
    public int counter; 
    public Guid Id; 
} 

Y esta es la salida medida:

XML Serialization Single: 2.3764ms 
JSON Serialization Single: 2.1432ms 

XML Serialization 1000: 13.7754ms 
JSON Serialization 1000: 13.747ms 

XML Serialization 10000: 100ms 
JSON Serialization 10000: 134ms 

JSON llegaron consistentemente a cabo sólo un poco más rápido después del 1 de iteración. Después de 1000 iteraciones, realmente no hubo diferencia. Después de 10000 iteraciones, XML fue claramente más rápido.

En este punto, no puede explicar por qué JSON sería más rápido uno a la vez, pero XML sería más rápido cuando se repite. Posiblemente debido al almacenamiento en caché o algo sofisticado en la biblioteca. Puede ver que el JsonSerializer escalado linealmente, aumentando las iteraciones en un orden de 10 aumentó linealmente el tiempo transcurrido en un orden de 10. Sin embargo, el XmlSerializer se comportó de manera diferente, su rendimiento no se escalo de forma lineal.

Lo repetí varias veces y siempre obtuve los mismos resultados.

Por lo tanto, la lección es que si solo está analizando un único objeto una vez, entonces JSON será un poco mejor. Pero si está analizando repetidamente objetos, XML podría funcionar mejor. Aunque no he probado lo que sucedería si los valores de los objetos cambian con cada iteración, eso podría marcar la diferencia.

También tenga en cuenta que estoy utilizando la biblioteca nativa Runtime.Serialization aquí. Es probable que otras bibliotecas produzcan resultados diferentes.

Editar: Lo intenté mientras generaba un nuevo Guid y un Int aleatorio cada vez que se llamaban las cadenas. No hizo ninguna diferencia en las pruebas de iteración individuales o 10000. Pero para 1000 iteraciones, JSON era aproximadamente 1 ms más rápido. Entonces, parece que el serializador XML realmente almacena en caché los valores.

Answer 2

El costo de serializar sería aproximadamente el mismo. Es poco probable que sea una diferencia notable. Utilice el formato que sus usuarios se sientan más cómodos modificando (ya que es un archivo de configuración).

La diferencia de rendimiento real puede producirse cuando necesite enviar JSON o XML a través de una red. Entonces, el rendimiento depende de la cantidad de material que envíe, y como JSON suele ser más conciso que XML, generalmente tendrá un mejor rendimiento en una red.

Answer 3

JSON puede ser somethimes menos legible por humanos que xml, pero el tamaño del archivo generado por JSON es más pequeña. Entonces, si necesita enviar el archivo a través de la red, Json puede ser la mejor opción, o si desea poder leerlo, XML es mejor. Otra cosa buena es que en .NET 4 tienes la palabra clave dinámica, y puedes convertir tu Json directamente en un objeto C#.

Answer 4

Cuando voy a buscar para la configuración de una aplicación .NET, espero encontrar un archivo XML en algún lugar llamado MyApp.exe.config.

Si seguimos con el principle of least surprise yo estaría a favor de serialización XML a través de JSON. Existe un beneficio adicional de que la configuración con formato XML se puede adaptar para trabajar con el Configuration API. Tanto de lo contrario tener el mismo tipo de apoyo: independiente de la plataforma, analizadores decente, basado en texto, etc.

El rendimiento es sólo un problema cuando se convierte en un problema. Soy un fanático de identificar problemas potenciales antes de codificarlos, pero eso generalmente se trata de problemas de rendimiento introducidos por decisiones arquitectónicas. Algo como esto, pequeño y bastante autónomo, no será difícil de cambiar si resulta ser un problema bajo el perfil.

Answer 5

en mi opinión todo es depende de lo que tiene que hacer y cómo desea implementar, aquí es un buen artículo comparando JSON y XML. compresión y deserialización en el lado del cliente elijo JSON.

Buena suerte.

http://dotnet.dzone.com/articles/json-vs-xml-net-developer%E2%80%99s