序列化和反序列化.NET對象的最快方法

Question

我正在尋找序列化和反序列化.NET對象的最快方法。這是我到目前爲止：

public class TD 
{ 
    public List<CT> CTs { get; set; } 
    public List<TE> TEs { get; set; } 
    public string Code { get; set; } 
    public string Message { get; set; } 
    public DateTime StartDate { get; set; } 
    public DateTime EndDate { get; set; } 

    public static string Serialize(List<TD> tData) 
    { 
     var serializer = new XmlSerializer(typeof(List<TD>)); 

     TextWriter writer = new StringWriter(); 
     serializer.Serialize(writer, tData); 

     return writer.ToString(); 
    } 

    public static List<TD> Deserialize(string tData) 
    { 
     var serializer = new XmlSerializer(typeof(List<TD>)); 

     TextReader reader = new StringReader(tData); 

     return (List<TD>)serializer.Deserialize(reader); 
    }   
} 

Answer 1

下面是使用protobuf-net模型（與發明CT和TE）（但保留了能夠使用XmlSerializer，這可能是有用的 - 特別是移民）;我虛心地提交（有很多證據，如果你需要的話），這個是是.NET中速度最快（或者最快）的通用序列化器。

如果你需要字符串，只需base-64編碼二進制。

[XmlType] 
public class CT { 
    [XmlElement(Order = 1)] 
    public int Foo { get; set; } 
} 
[XmlType] 
public class TE { 
    [XmlElement(Order = 1)] 
    public int Bar { get; set; } 
} 
[XmlType] 
public class TD { 
    [XmlElement(Order=1)] 
    public List<CT> CTs { get; set; } 
    [XmlElement(Order=2)] 
    public List<TE> TEs { get; set; } 
    [XmlElement(Order = 3)] 
    public string Code { get; set; } 
    [XmlElement(Order = 4)] 
    public string Message { get; set; } 
    [XmlElement(Order = 5)] 
    public DateTime StartDate { get; set; } 
    [XmlElement(Order = 6)] 
    public DateTime EndDate { get; set; } 

    public static byte[] Serialize(List<TD> tData) { 
     using (var ms = new MemoryStream()) { 
      ProtoBuf.Serializer.Serialize(ms, tData); 
      return ms.ToArray(); 
     }    
    } 

    public static List<TD> Deserialize(byte[] tData) { 
     using (var ms = new MemoryStream(tData)) { 
      return ProtoBuf.Serializer.Deserialize<List<TD>>(ms); 
     } 
    } 
} 

Answer 2

Protobuf是非常非常快。

查看http://code.google.com/p/protobuf-net/wiki/Performance瞭解有關該系統性能的深入信息和實施。

Answer 3

.NET中包含的二進制序列化程序應該比XmlSerializer更快。或另一個序列化程序爲protobuf，JSON，...

但是對於其中一些你需要添加屬性或其他方式添加元數據。例如ProtoBuf在內部使用數字屬性ID，並且映射需要通過不同的機制以某種方式保存。任何序列化程序的版本控制都不是微不足道的。

Answer 4

我做的diffreent格式之間的這種後 http://maxondev.com/serialization-performance-comparison-c-net-formats-frameworks-xmldatacontractserializer-xmlserializer-binaryformatter-json-newtonsoft-servicestack-text/

只是一個樣本中從後

Answer 5

另一個串行在那裏，聲稱自己是超級快一個comprehansive比較是netserializer。

在其網站上給出的數據顯示，2倍以上的protobuf的表現，我還沒試過此我自己，但如果你正在評估各種選項，試試這個以及

Answer 6

你可以嘗試Salar.Bois串行其擁有不俗的性能。它的重點是有效載荷的大小，但它也提供了良好的性能。

如果您希望自己查看和比較結果，那麼Github頁面中有基準測試。

https://github.com/salarcode/Bois

Answer 7

我把你的類送入CGbR generator的自由。 由於它處於早期階段，它不支持DateTime，所以我簡單地用它替換了它。生成的序列化的代碼如下所示：

public int Size 
{ 
    get 
    { 
     var size = 24; 
     // Add size for collections and strings 
     size += Cts == null ? 0 : Cts.Count * 4; 
     size += Tes == null ? 0 : Tes.Count * 4; 
     size += Code == null ? 0 : Code.Length; 
     size += Message == null ? 0 : Message.Length; 

     return size;    
    } 
} 

public byte[] ToBytes(byte[] bytes, ref int index) 
{ 
    if (index + Size > bytes.Length) 
     throw new ArgumentOutOfRangeException("index", "Object does not fit in array"); 

    // Convert Cts 
    // Two bytes length information for each dimension 
    GeneratorByteConverter.Include((ushort)(Cts == null ? 0 : Cts.Count), bytes, ref index); 
    if (Cts != null) 
    { 
     for(var i = 0; i < Cts.Count; i++) 
     { 
      var value = Cts[i]; 
      value.ToBytes(bytes, ref index); 
     } 
    } 
    // Convert Tes 
    // Two bytes length information for each dimension 
    GeneratorByteConverter.Include((ushort)(Tes == null ? 0 : Tes.Count), bytes, ref index); 
    if (Tes != null) 
    { 
     for(var i = 0; i < Tes.Count; i++) 
     { 
      var value = Tes[i]; 
      value.ToBytes(bytes, ref index); 
     } 
    } 
    // Convert Code 
    GeneratorByteConverter.Include(Code, bytes, ref index); 
    // Convert Message 
    GeneratorByteConverter.Include(Message, bytes, ref index); 
    // Convert StartDate 
    GeneratorByteConverter.Include(StartDate.ToBinary(), bytes, ref index); 
    // Convert EndDate 
    GeneratorByteConverter.Include(EndDate.ToBinary(), bytes, ref index); 
    return bytes; 
} 

public Td FromBytes(byte[] bytes, ref int index) 
{ 
    // Read Cts 
    var ctsLength = GeneratorByteConverter.ToUInt16(bytes, ref index); 
    var tempCts = new List<Ct>(ctsLength); 
    for (var i = 0; i < ctsLength; i++) 
    { 
     var value = new Ct().FromBytes(bytes, ref index); 
     tempCts.Add(value); 
    } 
    Cts = tempCts; 
    // Read Tes 
    var tesLength = GeneratorByteConverter.ToUInt16(bytes, ref index); 
    var tempTes = new List<Te>(tesLength); 
    for (var i = 0; i < tesLength; i++) 
    { 
     var value = new Te().FromBytes(bytes, ref index); 
     tempTes.Add(value); 
    } 
    Tes = tempTes; 
    // Read Code 
    Code = GeneratorByteConverter.GetString(bytes, ref index); 
    // Read Message 
    Message = GeneratorByteConverter.GetString(bytes, ref index); 
    // Read StartDate 
    StartDate = DateTime.FromBinary(GeneratorByteConverter.ToInt64(bytes, ref index)); 
    // Read EndDate 
    EndDate = DateTime.FromBinary(GeneratorByteConverter.ToInt64(bytes, ref index)); 

    return this; 
} 

我創造了這樣的採樣對象的列表：

var objects = new List<Td>(); 
for (int i = 0; i < 1000; i++) 
{ 
    var obj = new Td 
    { 
     Message = "Hello my friend", 
     Code = "Some code that can be put here", 
     StartDate = DateTime.Now.AddDays(-7), 
     EndDate = DateTime.Now.AddDays(2), 
     Cts = new List<Ct>(), 
     Tes = new List<Te>() 
    }; 
    for (int j = 0; j < 10; j++) 
    { 
     obj.Cts.Add(new Ct { Foo = i * j }); 
     obj.Tes.Add(new Te { Bar = i + j }); 
    } 
    objects.Add(obj); 
} 

我的機器上結果Release編譯：

var watch = new Stopwatch(); 
watch.Start(); 
var bytes = BinarySerializer.SerializeMany(objects); 
watch.Stop(); 

尺寸： 149000字節

時間： 2.059ms 3.13ms

編輯：與CGbR開始0.4.3二進制序列化支持的DateTime。不幸的是，DateTime.ToBinary方法非常慢。我會盡快更換它。

EDIT2：當使用UTC DateTime通過在1.669ms調用ToUniversalTime()性能被恢復和時鐘英寸

Answer 8

對此感興趣，我決定測試我所能接近的「蘋果到蘋果」測試的建議方法。我用下面的代碼編寫了一個控制檯應用程序：

using System; 
using System.Collections.Generic; 
using System.Diagnostics; 
using System.IO; 
using System.Linq; 
using System.Runtime.Serialization.Formatters.Binary; 
using System.Text; 
using System.Threading.Tasks; 

namespace SerializationTests 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      var count = 100000; 
      var rnd = new Random(DateTime.UtcNow.GetHashCode()); 
      Console.WriteLine("Generating {0} arrays of data...", count); 
      var arrays = new List<int[]>(); 
      for (int i = 0; i < count; i++) 
      { 
       var elements = rnd.Next(1, 100); 
       var array = new int[elements]; 
       for (int j = 0; j < elements; j++) 
       { 
        array[j] = rnd.Next(); 
       } 
       arrays.Add(array); 
      } 
      Console.WriteLine("Test data generated."); 
      var stopWatch = new Stopwatch(); 

      Console.WriteLine("Testing BinarySerializer..."); 
      var binarySerializer = new BinarySerializer(); 
      var binarySerialized = new List<byte[]>(); 
      var binaryDeserialized = new List<int[]>(); 

      stopWatch.Reset(); 
      stopWatch.Start(); 
      foreach (var array in arrays) 
      { 
       binarySerialized.Add(binarySerializer.Serialize(array)); 
      } 
      stopWatch.Stop(); 
      Console.WriteLine("BinaryFormatter: Serializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds); 

      stopWatch.Reset(); 
      stopWatch.Start(); 
      foreach (var serialized in binarySerialized) 
      { 
       binaryDeserialized.Add(binarySerializer.Deserialize<int[]>(serialized)); 
      } 
      stopWatch.Stop(); 
      Console.WriteLine("BinaryFormatter: Deserializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds); 


      Console.WriteLine(); 
      Console.WriteLine("Testing ProtoBuf serializer..."); 
      var protobufSerializer = new ProtoBufSerializer(); 
      var protobufSerialized = new List<byte[]>(); 
      var protobufDeserialized = new List<int[]>(); 

      stopWatch.Reset(); 
      stopWatch.Start(); 
      foreach (var array in arrays) 
      { 
       protobufSerialized.Add(protobufSerializer.Serialize(array)); 
      } 
      stopWatch.Stop(); 
      Console.WriteLine("ProtoBuf: Serializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds); 

      stopWatch.Reset(); 
      stopWatch.Start(); 
      foreach (var serialized in protobufSerialized) 
      { 
       protobufDeserialized.Add(protobufSerializer.Deserialize<int[]>(serialized)); 
      } 
      stopWatch.Stop(); 
      Console.WriteLine("ProtoBuf: Deserializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds); 

      Console.WriteLine(); 
      Console.WriteLine("Testing NetSerializer serializer..."); 
      var netSerializerSerializer = new ProtoBufSerializer(); 
      var netSerializerSerialized = new List<byte[]>(); 
      var netSerializerDeserialized = new List<int[]>(); 

      stopWatch.Reset(); 
      stopWatch.Start(); 
      foreach (var array in arrays) 
      { 
       netSerializerSerialized.Add(netSerializerSerializer.Serialize(array)); 
      } 
      stopWatch.Stop(); 
      Console.WriteLine("NetSerializer: Serializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds); 

      stopWatch.Reset(); 
      stopWatch.Start(); 
      foreach (var serialized in netSerializerSerialized) 
      { 
       netSerializerDeserialized.Add(netSerializerSerializer.Deserialize<int[]>(serialized)); 
      } 
      stopWatch.Stop(); 
      Console.WriteLine("NetSerializer: Deserializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds); 

      Console.WriteLine("Press any key to end."); 
      Console.ReadKey(); 
     } 

     public class BinarySerializer 
     { 
      private static readonly BinaryFormatter Formatter = new BinaryFormatter(); 

      public byte[] Serialize(object toSerialize) 
      { 
       using (var stream = new MemoryStream()) 
       { 
        Formatter.Serialize(stream, toSerialize); 
        return stream.ToArray(); 
       } 
      } 

      public T Deserialize<T>(byte[] serialized) 
      { 
       using (var stream = new MemoryStream(serialized)) 
       { 
        var result = (T)Formatter.Deserialize(stream); 
        return result; 
       } 
      } 
     } 

     public class ProtoBufSerializer 
     { 
      public byte[] Serialize(object toSerialize) 
      { 
       using (var stream = new MemoryStream()) 
       { 
        ProtoBuf.Serializer.Serialize(stream, toSerialize); 
        return stream.ToArray(); 
       } 
      } 

      public T Deserialize<T>(byte[] serialized) 
      { 
       using (var stream = new MemoryStream(serialized)) 
       { 
        var result = ProtoBuf.Serializer.Deserialize<T>(stream); 
        return result; 
       } 
      } 
     } 

     public class NetSerializer 
     { 
      private static readonly NetSerializer Serializer = new NetSerializer(); 
      public byte[] Serialize(object toSerialize) 
      { 
       return Serializer.Serialize(toSerialize); 
      } 

      public T Deserialize<T>(byte[] serialized) 
      { 
       return Serializer.Deserialize<T>(serialized); 
      } 
     } 
    } 
} 

結果令我感到驚訝;多次運行時，他們是一致的：

Generating 100000 arrays of data... 
Test data generated. 
Testing BinarySerializer... 
BinaryFormatter: Serializing took 336.8392ms. 
BinaryFormatter: Deserializing took 208.7527ms. 

Testing ProtoBuf serializer... 
ProtoBuf: Serializing took 2284.3827ms. 
ProtoBuf: Deserializing took 2201.8072ms. 

Testing NetSerializer serializer... 
NetSerializer: Serializing took 2139.5424ms. 
NetSerializer: Deserializing took 2113.7296ms. 
Press any key to end. 

收集這些結果，我決定去看看的Protobuf或NetSerializer具有較大的物體表現較好。我將收集數量更改爲10,000個對象，但將數組大小增加到1-10,000而不是1-100。結果似乎更加明確：

Generating 10000 arrays of data... 
Test data generated. 
Testing BinarySerializer... 
BinaryFormatter: Serializing took 285.8356ms. 
BinaryFormatter: Deserializing took 206.0906ms. 

Testing ProtoBuf serializer... 
ProtoBuf: Serializing took 10693.3848ms. 
ProtoBuf: Deserializing took 5988.5993ms. 

Testing NetSerializer serializer... 
NetSerializer: Serializing took 9017.5785ms. 
NetSerializer: Deserializing took 5978.7203ms. 
Press any key to end. 

我的結論，因此，是：可能存在的protobuf和NetSerializer是非常適合的情況下，但至少相對簡單對象的原始性能... BinaryFormatter性能顯着提高至少一個數量級。

情況因人而異。

Answer 9

我刪除了上述代碼中的錯誤，並得到了下面的結果：另外我不確定NetSerializer如何要求您註冊正在序列化的類型，可能會產生哪種兼容性或性能差異。

Generating 100000 arrays of data... 
Test data generated. 
Testing BinarySerializer... 
BinaryFormatter: Serializing took 508.9773ms. 
BinaryFormatter: Deserializing took 371.8499ms. 

Testing ProtoBuf serializer... 
ProtoBuf: Serializing took 3280.9185ms. 
ProtoBuf: Deserializing took 3190.7899ms. 

Testing NetSerializer serializer... 
NetSerializer: Serializing took 427.1241ms. 
NetSerializer: Deserializing took 78.954ms. 
Press any key to end. 

修改代碼

using System; 
using System.Collections.Generic; 
using System.Diagnostics; 
using System.IO; 
using System.Linq; 
using System.Runtime.Serialization.Formatters.Binary; 
using System.Text; 
using System.Threading.Tasks; 

namespace SerializationTests 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      var count = 100000; 
      var rnd = new Random((int)DateTime.UtcNow.Ticks & 0xFF); 
      Console.WriteLine("Generating {0} arrays of data...", count); 
      var arrays = new List<int[]>(); 
      for (int i = 0; i < count; i++) 
      { 
       var elements = rnd.Next(1, 100); 
       var array = new int[elements]; 
       for (int j = 0; j < elements; j++) 
       { 
        array[j] = rnd.Next(); 
       } 
       arrays.Add(array); 
      } 
      Console.WriteLine("Test data generated."); 
      var stopWatch = new Stopwatch(); 

      Console.WriteLine("Testing BinarySerializer..."); 
      var binarySerializer = new BinarySerializer(); 
      var binarySerialized = new List<byte[]>(); 
      var binaryDeserialized = new List<int[]>(); 

      stopWatch.Reset(); 
      stopWatch.Start(); 
      foreach (var array in arrays) 
      { 
       binarySerialized.Add(binarySerializer.Serialize(array)); 
      } 
      stopWatch.Stop(); 
      Console.WriteLine("BinaryFormatter: Serializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds); 

      stopWatch.Reset(); 
      stopWatch.Start(); 
      foreach (var serialized in binarySerialized) 
      { 
       binaryDeserialized.Add(binarySerializer.Deserialize<int[]>(serialized)); 
      } 
      stopWatch.Stop(); 
      Console.WriteLine("BinaryFormatter: Deserializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds); 


      Console.WriteLine(); 
      Console.WriteLine("Testing ProtoBuf serializer..."); 
      var protobufSerializer = new ProtoBufSerializer(); 
      var protobufSerialized = new List<byte[]>(); 
      var protobufDeserialized = new List<int[]>(); 

      stopWatch.Reset(); 
      stopWatch.Start(); 
      foreach (var array in arrays) 
      { 
       protobufSerialized.Add(protobufSerializer.Serialize(array)); 
      } 
      stopWatch.Stop(); 
      Console.WriteLine("ProtoBuf: Serializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds); 

      stopWatch.Reset(); 
      stopWatch.Start(); 
      foreach (var serialized in protobufSerialized) 
      { 
       protobufDeserialized.Add(protobufSerializer.Deserialize<int[]>(serialized)); 
      } 
      stopWatch.Stop(); 
      Console.WriteLine("ProtoBuf: Deserializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds); 

      Console.WriteLine(); 
      Console.WriteLine("Testing NetSerializer serializer..."); 
      var netSerializerSerialized = new List<byte[]>(); 
      var netSerializerDeserialized = new List<int[]>(); 

      stopWatch.Reset(); 
      stopWatch.Start(); 
      var netSerializerSerializer = new NS(); 
      foreach (var array in arrays) 
      { 
       netSerializerSerialized.Add(netSerializerSerializer.Serialize(array)); 
      } 
      stopWatch.Stop(); 
      Console.WriteLine("NetSerializer: Serializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds); 

      stopWatch.Reset(); 
      stopWatch.Start(); 
      foreach (var serialized in netSerializerSerialized) 
      { 
       netSerializerDeserialized.Add(netSerializerSerializer.Deserialize<int[]>(serialized)); 
      } 
      stopWatch.Stop(); 
      Console.WriteLine("NetSerializer: Deserializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds); 

      Console.WriteLine("Press any key to end."); 
      Console.ReadKey(); 
     } 

     public class BinarySerializer 
     { 
      private static readonly BinaryFormatter Formatter = new BinaryFormatter(); 

      public byte[] Serialize(object toSerialize) 
      { 
       using (var stream = new MemoryStream()) 
       { 
        Formatter.Serialize(stream, toSerialize); 
        return stream.ToArray(); 
       } 
      } 

      public T Deserialize<T>(byte[] serialized) 
      { 
       using (var stream = new MemoryStream(serialized)) 
       { 
        var result = (T)Formatter.Deserialize(stream); 
        return result; 
       } 
      } 
     } 

     public class ProtoBufSerializer 
     { 
      public byte[] Serialize(object toSerialize) 
      { 
       using (var stream = new MemoryStream()) 
       { 
        ProtoBuf.Serializer.Serialize(stream, toSerialize); 
        return stream.ToArray(); 
       } 
      } 

      public T Deserialize<T>(byte[] serialized) 
      { 
       using (var stream = new MemoryStream(serialized)) 
       { 
        var result = ProtoBuf.Serializer.Deserialize<T>(stream); 
        return result; 
       } 
      } 
     } 

     public class NS 
     { 
      NetSerializer.Serializer Serializer = new NetSerializer.Serializer(new Type[] { typeof(int), typeof(int[]) }); 

      public byte[] Serialize(object toSerialize) 
      { 
       using (var stream = new MemoryStream()) 
       { 
        Serializer.Serialize(stream, toSerialize); 
        return stream.ToArray(); 
       } 
      } 

      public T Deserialize<T>(byte[] serialized) 
      { 
       using (var stream = new MemoryStream(serialized)) 
       { 
        Serializer.Deserialize(stream, out var result); 
        return (T)result; 
       } 
      } 
     } 
    } 
}