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=0;

　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 = 0;

            byte[] data = null;

            if (param == null)
            {
                len = 0;
            }
            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 > 0)
            {
                datas.AddRange(data);
            }
            return datas.Count == 0 ? null : datas.ToArray();
        }

        反序列化实现如下：

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

            var len = 0;

            byte[] data = null;

            len = BitConverter.ToInt32(datas, offset);
            offset += 4;
            if (len > 0)
            {
                data = new byte[len];
                Buffer.BlockCopy(datas, offset, data, 0, 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, 0));
                }
                else if (type == typeof(short))
                {
                    obj = (BitConverter.ToInt16(data, 0));
                }
                else if (type == typeof(int))
                {
                    obj = (BitConverter.ToInt32(data, 0));
                }
                else if (type == typeof(long))
                {
                    obj = (BitConverter.ToInt64(data, 0));
                }
                else if (type == typeof(float))
                {
                    obj = (BitConverter.ToSingle(data, 0));
                }
                else if (type == typeof(double))
                {
                    obj = (BitConverter.ToDouble(data, 0));
                }
                else if (type == typeof(decimal))
                {
                    obj = (BitConverter.ToDouble(data, 0));
                }
                else if (type == typeof(DateTime))
                {
                    var dstr = Encoding.UTF8.GetString(data);
                    var ticks = long.Parse(dstr.Substring(2));
                    obj = (new DateTime(ticks));
                }
                else if (type.BaseType == typeof(Enum))
                {
                    var numType = Enum.GetUnderlyingType(type);

                    if (numType == typeof(byte))
                    {
                        obj = Enum.ToObject(type, data[0]);
                    }
                    else if (numType == typeof(short))
                    {
                        obj = Enum.ToObject(type, BitConverter.ToInt16(data, 0));
                    }
                    else if (numType == typeof(int))
                    {
                        obj = Enum.ToObject(type, BitConverter.ToInt32(data, 0));
                    }
                    else
                    {
                        obj = Enum.ToObject(type, BitConverter.ToInt64(data, 0));
                    }
                }
                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 = 1,
                IsTemporary = false,
                Name = "yswenli group",
                Created = DateTimeHelper.Now,
                Creator = new UserInfo()
                {

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

                        ID = 1,
                        Birthday = DateTimeHelper.Now.AddYears(-100),
                        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 = 1,
                IsTemporary = false,
                Name = "yswenli group",
                Created = DateTimeHelper.Now,
                Creator = new UserInfo()
                {

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

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

            var count = 100000;
            var len1 = 0;
            var len2 = 0;

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

            List<byte[]> list = new List<byte[]>();
            for (int i = 0; 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 = 0; 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 = 0; 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 = 0; i < count; i++)
            {
                int os = 0;

                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