C# 如何比较messagepack cli和json.net反序列化程序的性能？

我试图比较Unity3d中两种不同的反序列化方法的性能，该方法基于MonoDevelop的C#/.NET实现

方法A）使用

方法B）使用

基于此，我觉得Messagepack的读写速度都会更快。然而，我发现虽然写性能明显更好，但读性能却明显较慢

为了测试反序列化性能，我在这段代码中是否做错了什么

public void test_msgpack(int _num, Test_Class _obj)
{
    var serializer = MessagePackSerializer.Get< Test_Class >();
    var stream = new MemoryStream();

    serializer.Pack(stream, _obj);

    Stopwatch stopWatch = new Stopwatch ();
    stopWatch.Start ();
    while (_num > 0) {
        _num -= 1;
        stream.Position = 0;
        Test_Class deserializedObject = serializer.Unpack( stream );
    }

    stopWatch.Stop ();
    TimeSpan ts = stopWatch.Elapsed;
    string elapsedTime = String.Format ("{0:00}:{1:00}:{2:00}.{3:00}",
        ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10);

    print ("msgpack read: " + elapsedTime);
}

public void test_json(int _num, Test_Class _obj)
{
    var serializer = new JsonSerializer();
    var stream = new MemoryStream();

    var sw = new StreamWriter(stream);
    var JsonTextWriter = new JsonTextWriter(sw);
    var sr = new StreamReader(stream);
    var JsonTextReader = new JsonTextReader(sr);

    serializer.Serialize(JsonTextWriter, _obj);

    Stopwatch stopWatch = new Stopwatch ();
    stopWatch.Start ();
    while (_num > 0) {
        _num -= 1;
        stream.Position = 0;
        Test_Class deserializedObject = serializer.Deserialize<Test_Class>(JsonTextReader);
    }
    stopWatch.Stop ();
    TimeSpan ts = stopWatch.Elapsed;
    string elapsedTime = String.Format ("{0:00}:{1:00}:{2:00}.{3:00}",
        ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10);

    print ("json read: " + elapsedTime);
}

public void test\u msgpack（int\u num，test\u Class\u obj）
{
var serializer=MessagePackSerializer.Get（）；
var stream=newmemoryStream（）；
序列化程序包（流，_obj）；
秒表秒表=新秒表（）；
stopWatch.Start（）；
而（_num>0）{
_num-=1；
流位置=0；
Test_Class deserializedObject=serializer.Unpack（流）；
}
stopWatch.Stop（）；
TimeSpan ts=秒表。已用时间；
string elapsedTime=string.Format（“{0:00}:{1:00}:{2:00}.{3:00}”，
时、分、秒、毫秒/10）；
打印（“msgpack读取：”+elapsedTime）；
}
public void test_json（int_num，test_Class_obj）
{
var serializer=new JsonSerializer（）；
var stream=newmemoryStream（）；
var sw=新的StreamWriter（流）；
var JsonTextWriter=新的JsonTextWriter（sw）；
var sr=新的流阅读器（流）；
var JsonTextReader=新的JsonTextReader（sr）；
serializer.Serialize（JsonTextWriter，_obj）；
秒表秒表=新秒表（）；
stopWatch.Start（）；
而（_num>0）{
_num-=1；
流位置=0；
Test_Class deserializedObject=serializer.Deserialize（JsonTextReader）；
}
stopWatch.Stop（）；
TimeSpan ts=秒表。已用时间；
string elapsedTime=string.Format（“{0:00}:{1:00}:{2:00}.{3:00}”，
时、分、秒、毫秒/10）；
打印（“json读取：”+elapsedTime）；
}

我发现JSON解析性能在100000次迭代中大约快100倍。。。哪一个看起来很奇怪？下面是我尝试序列化/反序列化的类的形式：

public class Test_Class
{
    public string i { get; set; }
    public List<float> a { get; set; }
    public List<float> b { get; set; }
    public List<float> c { get; set; }
}

公共类测试\u类
{
公共字符串i{get；set；}
公共列表a{get；set；}
公共列表b{get；set；}
公共列表c{get；set；}
}

经过一些尝试和错误之后，我发现JSON.net代码返回了一个空对象，因此显著提高了性能。我通过修改test_json方法纠正了这一点，如下所示：

public void test_json(int _num, Test_Class _obj)
{
    JsonSerializer serializer = new JsonSerializer();

    MemoryStream stream = new MemoryStream();

    StreamWriter writer = new StreamWriter(stream);
    JsonTextWriter jsonWriter = new JsonTextWriter(writer);
    serializer.Serialize(jsonWriter, _obj);
    jsonWriter.Flush();

    Stopwatch stopWatch = new Stopwatch ();
    stopWatch.Start ();
    while (_num > 0) {
        _num -= 1;
        stream.Position = 0;

        StreamReader reader = new StreamReader(stream);
        JsonTextReader jsonReader = new JsonTextReader(reader);
        Test_Class deserialised_object = serializer.Deserialize<Test_Class>(jsonReader);
    }
    stopWatch.Stop ();
    TimeSpan ts = stopWatch.Elapsed;
    string elapsedTime = String.Format ("{0:00}:{1:00}:{2:00}.{3:00}",
        ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10);

    print ("json read: " + elapsedTime);
}

public void test\u json（int\u num，test\u Class\u obj）
{
JsonSerializer serializer=新的JsonSerializer（）；
MemoryStream stream=新的MemoryStream（）；
StreamWriter writer=新StreamWriter（流）；
JsonTextWriter jsonWriter=新的JsonTextWriter（writer）；
serializer.Serialize（jsonWriter，_obj）；
jsonWriter.Flush（）；
秒表秒表=新秒表（）；
stopWatch.Start（）；
而（_num>0）{
_num-=1；
流位置=0；
StreamReader=新的StreamReader（流）；
JsonTextReader jsonReader=新的JsonTextReader（读取器）；
Test_Class反序列化的_object=serializer.Deserialize（jsonReader）；
}
stopWatch.Stop（）；
TimeSpan ts=秒表。已用时间；
string elapsedTime=string.Format（“{0:00}:{1:00}:{2:00}.{3:00}”，
时、分、秒、毫秒/10）；
打印（“json读取：”+elapsedTime）；
}

jsonWriter.Flush（）方法是必需的，在每次读取时创建一个新的JsonTextReader也是必需的

---

结果仍然显示，JSON.net的反序列化速度更快，但是，这种差异现在更小了。MsgPack CLI性能显然可以通过使用SerializerGenerator类来提高，尽管我还没有实现。

MessagePack由于额外的复杂性，序列化/反序列化速度会变慢，但是，结果是文件变小了。如果比较起来更容易想象：拿一个1gb的文件，把它放在一个.zip文件中，然后通过网络发送。压缩和发送文件总是比直接发送1gb文件更快。与其思考哪一个会更快，不如考虑一下你正在做的网络流量。特别是考虑到网络流量可能会对手机造成的影响，因为网络通常是慢的。