二进制序列化可以方便快捷的将对象进行持久化或者网络传输，并且体积小、性能高，应用面甚至还要高于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