C#高性能二进制序列化

二进制序列化可以方便快捷的将对象进行持久化或者网络传输，并且体积小、性能高，应用面甚至还要高于json的序列化；开始之前，先来看看dotcore/dotne自带的二进制序列化：C#中对象序列化和反序列化一般是通过BinaryFormatter类来实现的二进制序列化、反序列化的。

BinaryFormatter序列化：

 System.Runtime.Serialization.Formatters.Binary.BinaryFormatter serializer =　new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();

 System.IO.MemoryStream memStream = new System.IO.MemoryStream();

 serializer.Serialize(memStream, request);

BinaryFormatter反序列化：

 　memStream.Position=;

 　System.Runtime.Serialization.Formatters.Binary.BinaryFormatter deserializer =

 　new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();

 　object newobj = deserializer.Deserialize(memStream);

 　memStream.Close();

 　return newobj;

用着多了就发现BinaryFormatter有很多地方不妥，下面就来数数这个序列化的“三宗罪”：

1.类名上面要加上[Serializable]，不加不给序列化；正常的用法应该是序列化一个对象，不需的地方加上NonSerialized才合理吧；

2.序列化byte[]结果非常大，使用System.Text.Encoding.UTF8.GetString(bytes)查看下，发现里面有一大堆的元数据；对比看看google的protobuf，pb为什么在网络上应用的越来越多，这和他本身序列化完后体积小有着绝大部门的原因；

3.序列化对象需要完全一致，连类的命名空间都要相同，这点对于分面式开发的应用来说也是不可接受的；

既然BinaryFormatter不好用，那就只能动手自行实现一个解决上述问题的二进制序列化方案；首先去掉[Serializable]这个标签，接着主要是分析对象，并定义对象序列化后的数据结构；这里的想法是按长度加内容的方式来定义，举个例子：使用int作为长度，来保存一个int值,序列化完应该是：4,0,0,0,1,0,0,0这样的一组bytes，同理可以将int、short、long、float、double、datetime、enum、array、string、class、generic等按照这个格式进行序列化，这里主要使用的是BitConverter、反射等来实现序列化与反序列化；

序列化实现如下：

         public static byte[] Serialize(object param)
         {
             List<byte> datas = new List<byte>();

             var len = ;

             byte[] data = null;

             if (param == null)
             {
                 len = ;
             }
             else
             {
                 if (param is string)
                 {
                     data = Encoding.UTF8.GetBytes((string)param);
                 }
                 else if (param is byte)
                 {
                     data = new byte[] { (byte)param };
                 }
                 else if (param is bool)
                 {
                     data = BitConverter.GetBytes((bool)param);
                 }
                 else if (param is short)
                 {
                     data = BitConverter.GetBytes((short)param);
                 }
                 else if (param is int)
                 {
                     data = BitConverter.GetBytes((int)param);
                 }
                 else if (param is long)
                 {
                     data = BitConverter.GetBytes((long)param);
                 }
                 else if (param is float)
                 {
                     data = BitConverter.GetBytes((float)param);
                 }
                 else if (param is double)
                 {
                     data = BitConverter.GetBytes((double)param);
                 }
                 else if (param is DateTime)
                 {
                     var str = "wl" + ((DateTime)param).Ticks;
                     data = Encoding.UTF8.GetBytes(str);
                 }
                 else if (param is Enum)
                 {
                     var enumValType = Enum.GetUnderlyingType(param.GetType());

                     if (enumValType == typeof(byte))
                     {
                         data = new byte[] { (byte)param };
                     }
                     else if (enumValType == typeof(short))
                     {
                         data = BitConverter.GetBytes((Int16)param);
                     }
                     else if (enumValType == typeof(int))
                     {
                         data = BitConverter.GetBytes((Int32)param);
                     }
                     else
                     {
                         data = BitConverter.GetBytes((Int64)param);
                     }
                 }
                 else if (param is byte[])
                 {
                     data = (byte[])param;
                 }
                 else
                 {
                     var type = param.GetType();

                     if (type.IsGenericType || type.IsArray)
                     {
                         if (TypeHelper.DicTypeStrs.Contains(type.Name))
                             data = SerializeDic((System.Collections.IDictionary)param);
                         else if (TypeHelper.ListTypeStrs.Contains(type.Name) || type.IsArray)
                             data = SerializeList((System.Collections.IEnumerable)param);
                         else
                             data = SerializeClass(param, type);
                     }
                     else if (type.IsClass)
                     {
                         data = SerializeClass(param, type);
                     }

                 }
                 if (data != null)
                     len = data.Length;
             }
             datas.AddRange(BitConverter.GetBytes(len));
             if (len > )
             {
                 datas.AddRange(data);
             }
             return datas.Count ==  ? null : datas.ToArray();
         }

反序列化实现如下：

         public static object Deserialize(Type type, byte[] datas, ref int offset)
         {
             dynamic obj = null;

             var len = ;

             byte[] data = null;

             len = BitConverter.ToInt32(datas, offset);
             offset += ;
             if (len > )
             {
                 data = new byte[len];
                 Buffer.BlockCopy(datas, offset, data, , len);
                 offset += len;

                 if (type == typeof(string))
                 {
                     obj = Encoding.UTF8.GetString(data);
                 }
                 else if (type == typeof(byte))
                 {
                     obj = (data);
                 }
                 else if (type == typeof(bool))
                 {
                     obj = (BitConverter.ToBoolean(data, ));
                 }
                 else if (type == typeof(short))
                 {
                     obj = (BitConverter.ToInt16(data, ));
                 }
                 else if (type == typeof(int))
                 {
                     obj = (BitConverter.ToInt32(data, ));
                 }
                 else if (type == typeof(long))
                 {
                     obj = (BitConverter.ToInt64(data, ));
                 }
                 else if (type == typeof(float))
                 {
                     obj = (BitConverter.ToSingle(data, ));
                 }
                 else if (type == typeof(double))
                 {
                     obj = (BitConverter.ToDouble(data, ));
                 }
                 else if (type == typeof(decimal))
                 {
                     obj = (BitConverter.ToDouble(data, ));
                 }
                 else if (type == typeof(DateTime))
                 {
                     var dstr = Encoding.UTF8.GetString(data);
                     var ticks = long.Parse(dstr.Substring());
                     obj = (new DateTime(ticks));
                 }
                 else if (type.BaseType == typeof(Enum))
                 {
                     var numType = Enum.GetUnderlyingType(type);

                     if (numType == typeof(byte))
                     {
                         obj = Enum.ToObject(type, data[]);
                     }
                     else if (numType == typeof(short))
                     {
                         obj = Enum.ToObject(type, BitConverter.ToInt16(data, ));
                     }
                     else if (numType == typeof(int))
                     {
                         obj = Enum.ToObject(type, BitConverter.ToInt32(data, ));
                     }
                     else
                     {
                         obj = Enum.ToObject(type, BitConverter.ToInt64(data, ));
                     }
                 }
                 else if (type == typeof(byte[]))
                 {
                     obj = (byte[])data;
                 }
                 else if (type.IsGenericType)
                 {
                     if (TypeHelper.ListTypeStrs.Contains(type.Name))
                     {
                         obj = DeserializeList(type, data);
                     }
                     else if (TypeHelper.DicTypeStrs.Contains(type.Name))
                     {
                         obj = DeserializeDic(type, data);
                     }
                     else
                     {
                         obj = DeserializeClass(type, data);
                     }
                 }
                 else if (type.IsClass)
                 {
                     obj = DeserializeClass(type, data);
                 }
                 else if (type.IsArray)
                 {
                     obj = DeserializeArray(type, data);
                 }
                 else
                 {
                     throw new RPCPamarsException("ParamsSerializeUtil.Deserialize 未定义的类型：" + type.ToString());
                 }

             }
             return obj;
         }

其他详细的代码可以查看https://github.com/yswenli/SAEA/blob/master/Src/SAEA.RPC/Serialize/ParamsSerializeUtil.cs

功能基本实现了，下面对比一下10000次的实体序列化与反序列化测试结果：

实体代码：

             var groupInfo = new GroupInfo()
             {
                 GroupID = ,
                 IsTemporary = false,
                 Name = "yswenli group",
                 Created = DateTimeHelper.Now,
                 Creator = new UserInfo()
                 {

                     ID = ,
                     Birthday = DateTimeHelper.Now.AddYears(-),
                     UserName = "yswenli"
                 },
                 Users = new System.Collections.Generic.List<UserInfo>()
                 {
                     new UserInfo()
                     {

                         ID = ,
                         Birthday = DateTimeHelper.Now.AddYears(-),
                         UserName = "yswenli"
                     }
                 }
             };

测试代码：

         public static byte[] SerializeBinary(object request)
         {

             System.Runtime.Serialization.Formatters.Binary.BinaryFormatter serializer =

             new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();

             using (System.IO.MemoryStream memStream = new System.IO.MemoryStream())
             {
                 serializer.Serialize(memStream, request);

                 return memStream.ToArray();
             }
         }

         public static object DeSerializeBinary(byte[] data)
         {
             using (System.IO.MemoryStream memStream = new System.IO.MemoryStream(data))
             {
                 System.Runtime.Serialization.Formatters.Binary.BinaryFormatter deserializer =

                 new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();

                 return deserializer.Deserialize(memStream);
             }
         }

         static void SerializeTest()
         {
             var groupInfo = new GroupInfo()
             {
                 GroupID = ,
                 IsTemporary = false,
                 Name = "yswenli group",
                 Created = DateTimeHelper.Now,
                 Creator = new UserInfo()
                 {

                     ID = ,
                     Birthday = DateTimeHelper.Now.AddYears(-),
                     UserName = "yswenli"
                 },
                 Users = new System.Collections.Generic.List<UserInfo>()
                 {
                     new UserInfo()
                     {

                         ID = ,
                         Birthday = DateTimeHelper.Now.AddYears(-),
                         UserName = "yswenli"
                     }
                 }
             };

             var count = ;
             var len1 = ;
             var len2 = ;

             Stopwatch sw = new Stopwatch();
             sw.Start();

             List<byte[]> list = new List<byte[]>();
             for (int i = ; i < count; i++)
             {
                 var bytes = SerializeBinary(groupInfo);
                 len1 = bytes.Length;
                 list.Add(bytes);
             }
             ConsoleHelper.WriteLine($"BinaryFormatter实体序列化平均：{count * 1000 / sw.ElapsedMilliseconds} 次/秒");

             sw.Restart();
             for (int i = ; i < count; i++)
             {
                 var obj = DeSerializeBinary(list[i]);
             }
             ConsoleHelper.WriteLine($"BinaryFormatter实体反序列化平均：{count * 1000 / sw.ElapsedMilliseconds} 次/秒");
             ConsoleHelper.WriteLine($"BinaryFormatter序列化生成bytes大小：{len1 * count * 1.0 / 1024 / 1024} Mb");
             list.Clear();
             sw.Restart();

             for (int i = ; i < count; i++)
             {
                 var bytes = RPC.Serialize.ParamsSerializeUtil.Serialize(groupInfo);
                 len2 = bytes.Length;
                 list.Add(bytes);
             }
             ConsoleHelper.WriteLine($"ParamsSerializeUtil实体序列化平均：{count * 1000 / sw.ElapsedMilliseconds} 次/秒");
             sw.Restart();
             for (int i = ; i < count; i++)
             {
                 int os = ;

                 var obj = RPC.Serialize.ParamsSerializeUtil.Deserialize(groupInfo.GetType(), list[i], ref os);
             }
             ConsoleHelper.WriteLine($"ParamsSerializeUtil实体反序列化平均：{count * 1000 / sw.ElapsedMilliseconds} 次/秒");
             ConsoleHelper.WriteLine($"ParamsSerializeUtil序列化生成bytes大小：{len2 * count * 1.0 / 1024 / 1024} Mb");
             sw.Stop();
         }

运行结果：

更多内容，请Fork或Star我的github:https://github.com/yswenli/SAEA