Json und Xml Serialisierung, was ist eine bessere Leistung?

Question

Ich muss einige Konfigurationsinformationen in Datei speichern. In C# -Code-Konfiguration Daten nach Klasse und in Datei Ich werde diese Klasse im JSON-oder XML-Format speichern. Also, was ist die beste Leistung der Serialisierung JSON oder Xml?

Answer 1

Nun, anstatt zu raten, habe ich die Antwort. Hier haben wir das Testprogramm:

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; 
} 

Und das ist die gemessene Leistung:

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 konsequent kam nur ein kleines bisschen schneller nach dem 1. Iteration. Nach 1000 Iterationen gab es keinen Unterschied. Nach 10000 Iterationen war XML deutlich schneller.

An diesem Punkt kann ich nicht erklären, warum JSON einzeln nacheinander schneller wäre, aber XML wäre schneller, wenn es wiederholt wird. Möglicherweise aufgrund von Caching oder etwas Phantasie in der Bibliothek. Sie können sehen, dass der JsonSerializer linear skaliert wurde, indem die Iterationen in einer Größenordnung von 10 erhöht wurden. Die verstrichene Zeit wurde linear um den Faktor 10 erhöht. Der XmlSerializer verhielt sich jedoch anders, seine Leistung wurde nicht linear skaliert.

Ich wiederholte dies mehrmals und erhielt durchgehend die gleichen Ergebnisse.

Also ist die Lektion, wenn Sie nur ein einzelnes Objekt einmal analysieren, dann wird JSON etwas besser sein. Wenn Sie jedoch Objekte wiederholt analysieren, wird XML möglicherweise besser. Obwohl ich nicht getestet habe, was passieren würde, wenn sich die Objektwerte mit jeder Iteration ändern würden, könnte das einen Unterschied machen.

Beachten Sie auch, ich verwende hier die native Runtime.Serialization-Bibliothek. Andere Bibliotheken werden wahrscheinlich zu anderen Ergebnissen führen.

Edit: Ich habe es gerade versucht, während eine neue Guid und zufällige Int jedes Mal, wenn die Strings aufgerufen werden. Es machte keinen Unterschied zu den einzelnen oder 10000 Iterationstests. Aber für 1000 Iterationen war JSON etwa 1 ms schneller. Es sieht so aus, als ob der XML-Serializer die Werte wirklich zwischenspeichert.

Answer 2

Die Kosten für die Serialisierung wären in etwa gleich. Es ist unwahrscheinlich, dass es ein spürbarer Unterschied ist. Verwenden Sie das Format, das Ihre Benutzer am angenehmsten ändern können (da es sich um eine Konfigurationsdatei handelt).

Der tatsächliche Leistungsunterschied kann auftreten, wenn Sie JSON oder XML über ein Netzwerk senden müssen. Dann hängt die Leistung davon ab, wie viel Zeug Sie senden, und da JSON normalerweise prägnanter als XML ist, wird es im Allgemeinen besser über ein Netzwerk funktionieren.

Answer 3

Json kann von Menschen manchmal weniger lesbar sein als xml, aber die Größe der von json erzeugten Datei ist kleiner. Also, wenn Sie die Datei über das Netzwerk senden müssen, ist Json die bessere Wahl, oder wenn Sie in der Lage sein möchten, es zu lesen, ist XML besser. Eine andere gute Sache ist, dass in .NET 4 Sie das dynamische Schlüsselwort haben, und Sie können Ihre Json direkt in ein C# -Objekt konvertieren.

Answer 4

Wenn ich nach der Konfiguration in einer .NET-Anwendung suche, erwarte ich eine XML-Datei namens MyApp.exe.config.

Bei der principle of least surprise haften würde ich XML-Serialisierung über JSON bevorzugen. Es gibt einen zusätzlichen Vorteil, dass die XML-formatierte Konfiguration angepasst werden kann, um mit der Configuration API zu arbeiten. Beide haben ansonsten die gleiche Unterstützung: plattformunabhängig, anständige Parser, textbasiert usw.

Leistung ist nur ein Problem, wenn es ein Problem wird. Ich bin ein Fan davon, mögliche Probleme zu identifizieren, bevor ich sie code, aber das ist in der Regel auf Leistungsprobleme, die durch Architekturentscheidungen eingeführt werden. So etwas, klein und ziemlich eigenständig, wird nicht schwierig zu ändern sein, wenn es sich beim Profiling als Problem erweist.

Answer 5

meiner Meinung nach alles hängt davon ab, was Sie tun müssen und wie Sie implementieren möchten, hier ist ein guter Artikel zum Vergleich von JSON und XML. Komprimierung und Deserialisierung auf Clientseite Ich wähle JSON.

Viel Glück.

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