快速序列化组件MessagePack介绍

简介

MessagePack for C#(MessagePack-CSharp)是用于C#的极速MessagePack序列化程序,比MsgPack-Cli快10倍,与其他所有C#序列化程序相比,具有最好的性能。 MessagePack for C#具有内置的LZ4压缩功能,可以实现超快速序列化和二进制占用空间小。 性能永远是重要的! 可用于游戏,分布式计算,微服务,数据存储到Redis等。支持.NET, .NET Core, Unity, Xamarin。

从上图我们看出MessagePack for C#在性能测试中是最好的,这里解释一下第三个MsgPack-Cli是MessagePack官方实现的。第一和第二都是MessagePack for C#,第一项相比第二项具有稍快一点的序列化和反序列化速度,但是第二项采用了L4压缩功能,显著的减少了二进制的大小。在实际使用中推荐使用L4压缩功能。

使用

该组件已经发布在Nuget,使用命令加入项目。

Install-Package MessagePack

分析器

Install-Package MessagePackAnalyzer

扩展

Install-Package MessagePack.ImmutableCollection
Install-Package MessagePack.ReactiveProperty
Install-Package MessagePack.UnityShims
Install-Package MessagePack.AspNetCoreMvcFormatter

Unity在此处下载 https://github.com/neuecc/MessagePack-CSharp/releases

快速开始

定义一个类添加[MessagePackObject]特性,公共成员(属性或者字段)添加[Key]特性,调用MessagePackSerializer.Serialize<T>/Deserialize<T>进行序列化和反序列化,ToJson可以帮我们转储二进制为json格式。

// 标记 MessagePackObjectAttribute
[MessagePackObject]
public class MyClass
{
    // Key 是序列化索引,对于版本控制非常重要。
    [Key(0)]
    public int Age { get; set; }

    [Key(1)]
    public string FirstName { get; set; }

    [Key(2)]
    public string LastName { get; set; }

    // 公共成员中不序列化目标,标记IgnoreMemberAttribute
    [IgnoreMember]
    public string FullName { get { return FirstName + LastName; } }
}
class Program
{
    static void Main(string[] args)
    {
        var mc = new MyClass
        {
            Age = 99,
            FirstName = "hoge",
            LastName = "huga",
        };

        // 序列化
        var bytes = MessagePackSerializer.Serialize(mc);
        //反序列化
        var mc2 = MessagePackSerializer.Deserialize<MyClass>(bytes);

        // 你可以将msgpack二进制转储为可读的json。
        // 在默认情况下,MeesagePack for C#减少了属性名称信息。
        // [99,"hoge","huga"]
        var json = MessagePackSerializer.ToJson(bytes);
        Console.WriteLine(json);

        Console.ReadKey();

    }
}

序列化索引将会影响该信息在序列化数据中的位置

默认情况下特性是必须的,但是我们有方法进行改变,让它变为不是必须的,详情请看后面。

分析器

MessagePackAnalyzer 可以帮助我们定义对象. 如果不符合规则,那么特性, 程序集等可以被检测到,如果我们编译就会出现编译错误。

如果要允许特定类型(例如,注册自定义类型时),请将MessagePackAnalyzer.json放在项目根目录下,并将生成操作设置为AdditionalFiles(其他文件)。

这是MessagePackAnalyzer.json内容的一个示例。

[ "MyNamespace.FooClass", "MyNameSpace.BarStruct" ]

内置的支持类型

这些类型可以默认序列化。

基元(int、string等等), Enum, Nullable<>, TimeSpan, DateTime, DateTimeOffset, Nil, Guid, Uri, Version, StringBuilder, BitArray, ArraySegment<>, BigInteger, Complext, Task, Array[], Array[,], Array[,,], Array[,,,], KeyValuePair<,>, Tuple<,...>, ValueTuple<,...>, List<>, LinkedList<>, Queue<>, Stack<>, HashSet<>, ReadOnlyCollection<>, IList<>, ICollection<>, IEnumerable<>, Dictionary<,>, IDictionary<,>, SortedDictionary<,>, SortedList<,>, ILookup<,>, IGrouping<,>, ObservableCollection<>, ReadOnlyOnservableCollection<>, IReadOnlyList<>, IReadOnlyCollection<>, ISet<>, ConcurrentBag<>, ConcurrentQueue<>, ConcurrentStack<>, ReadOnlyDictionary<,>, IReadOnlyDictionary<,>, ConcurrentDictionary<,>, Lazy<>, Task<>, 自定义继承ICollection <>或IDictionary <,>具有无参构造方法, IList,IDictionary和自定义继承ICollection或IDictionary具有无参构造函数(包括ArrayList和Hashtable)。

您可以添加自定义类型的支持和一些官方/第三方扩展包。 对于ImmutableCollections(ImmutableList <>等),对于ReactiveProperty和Unity(Vector3, Quaternion等等),对于F#(Record,FsList,Discriminated Unions等)。

MessagePack.Nil是MessagePack for C#的内置null/void/unit表示类型。

对象序列化

MessagePack for C#可以序列化public Class或Struct,序列化目标必须标记[MessagePackObject]和[Key], Key类型可以选择int或字符串。如果Key类型是int,则使用序列化格式为数组,如果Key类型是字符串,则使用序列化格式为键值对,如果您定义了[MessagePackObject(keyAsPropertyName:true)],则不需要Key特性。

[MessagePackObject]
public class Sample1
{
    [Key(0)]
    public int Foo { get; set; }
    [Key(1)]
    public int Bar { get; set; }
}

[MessagePackObject]
public class Sample2
{
    [Key("foo")]
    public int Foo { get; set; }
    [Key("bar")]
    public int Bar { get; set; }
}

[MessagePackObject(keyAsPropertyName: true)]
public class Sample3
{
    // 不需要key特性
    public int Foo { get; set; }

    // 不需要序列化的成员使用IgnoreMember特性
    [IgnoreMember]
    public int Bar { get; set; }
}

// 结果 [10,20]
Console.WriteLine(MessagePackSerializer.ToJson(new Sample1 { Foo = 10, Bar = 20 }));

// 结果 {"foo":10,"bar":20}
Console.WriteLine(MessagePackSerializer.ToJson(new Sample2 { Foo = 10, Bar = 20 }));

// 结果 {"Foo":10}
Console.WriteLine(MessagePackSerializer.ToJson(new Sample3 { Foo = 10, Bar = 20 }));

所有模式序列化目标都是公共实例成员(字段或属性)。 如果要避免序列化目标,可以将[IgnoreMember]添加到目标成员。

目标类必须是 public, 不允许 private, internal 类.

应该使用哪种Key类型,int或string? 作者建议使用int key,因为比string key更快,更紧凑。 但是string key有关键的名字信息,对调试很有用。

MessagePackSerializer序列化目标时,必须在目标使用特性才能保证稳健性,如果类进行了扩充,你必须意识到版本控制。如果Key不存在,MessagePackSerializer将会使用默认值。如果使用的是int key,那么必须从0开始,如果不必要的属性出现,请填写空缺的数字。重用是不好的。 此外,如果Int Key的跳转数字差距太大,则会影响二进制大小。

[MessagePackObject]
public class IntKeySample
{
    [Key(3)]
    public int A { get; set; }
    [Key(10)]
    public int B { get; set; }
}

// int key不从0开始并且数字进行了跳跃,将会出现下面的结果
//[null,null,null,0,null,null,null,null,null,null,0]
Console.WriteLine(MessagePackSerializer.ToJson(new IntKeySample()));

如果你想像JSON.NET那样使用!不想加特性! 如果你这样想,你可以使用无约定的解析器。

public class ContractlessSample
{
    public int MyProperty1 { get; set; }
    public int MyProperty2 { get; set; }
}

var data = new ContractlessSample { MyProperty1 = 99, MyProperty2 = 9999 };
var bin = MessagePackSerializer.Serialize(data, MessagePack.Resolvers.ContractlessStandardResolver.Instance);

// {"MyProperty1":99,"MyProperty2":9999}
Console.WriteLine(MessagePackSerializer.ToJson(bin));

// 全局设置无约束解析器为默认解析器
MessagePackSerializer.SetDefaultResolver(MessagePack.Resolvers.ContractlessStandardResolver.Instance);

// 序列化
var bin2 = MessagePackSerializer.Serialize(data);

我想序列化私人成员! 默认情况下,不能序列化/反序列化私有成员。 但是你可以使用allow-private解析器来序列化私人成员。

[MessagePackObject]
public class PrivateSample
{
    [Key(0)]
    int x;

    public void SetX(int v)
    {
        x = v;
    }

    public int GetX()
    {
        return x;
    }
}

var data = new PrivateSample();
data.SetX(9999);

// 你可以选择 StandardResolverAllowPrivate 或者  ContractlessStandardResolverAllowPrivate 解析器
var bin = MessagePackSerializer.Serialize(data, MessagePack.Resolvers.DynamicObjectResolverAllowPrivate.Instance);

我不需要类型,我想像BinaryFormatter那样使用! 你可以使用无类型的解析器和帮助器。 请参阅Typeless部分。

解析器是MessagePack For C#的关键定制点。 详情请见扩展部分。

DataContract兼容性

您可以使用[DataContract]而不是[MessagePackObject]。 如果type标记为DataContract,则可以使用[DataMember]代替[Key],[IgnoreDataMember]代替[IgnoreMember]。

[DataMember(Order = int)] 和 [Key(int)]相同, [DataMember(Name = string)]和 [Key(string)]相同. 如果使用 [DataMember], 则类似于 [Key(nameof(propertyname)].

使用DataContract使其成为一个共享的类库,您不必引用MessagePack for C#。 但是,它不包含在分析器或由mpc.exe生成的代码中。此外,像UnionAttribute,MessagePackFormatterAttribute,SerializationConstructorAttribute等功能不能使用。 出于这个原因,我建议您基本上使用MessagePack for C#特性。

序列化不可变对象(序列化构造器)

MessagePack for C#支持反序列化不可变对象。 例如,这个struct可以自然地序列化/反序列化。

[MessagePackObject]
public struct Point
{
    [Key(0)]
    public readonly int X;
    [Key(1)]
    public readonly int Y;

    public Point(int x, int y)
    {
        this.X = x;
        this.Y = y;
    }
}

var data = new Point(99, 9999);
var bin = MessagePackSerializer.Serialize(data);

// Okay to deserialize immutable obejct
var point = MessagePackSerializer.Deserialize<Point>(bin);

MessagePackSerializer choose constructor with the least matched argument, match index if key in integer or match name(ignore case) if key is string. If encounts MessagePackDynamicObjectResolverException: can't find matched constructor parameter you should check about this.

MessagePackSerializer选择具有最少参数的构造方法,如果key是整型将匹配索引或者如果key是字符串将匹配名称(忽略大小写)。 如果遇到 MessagePackDynamicObjectResolverException: can't find matched constructor parameter 你应该检查一会下。

如果不能自动匹配,可以通过[SerializationConstructorAttribute]手动指定使用构造函数。

[MessagePackObject]
public struct Point
{
    [Key(0)]
    public readonly int X;
    [Key(1)]
    public readonly int Y;

    // 如果没有标记特性,将会使用这方法(最少参数)
    public Point(int x)
    {
        X = x;
    }

    [SerializationConstructor]
    public Point(int x, int y)
    {
        this.X = x;
        this.Y = y;
    }
}

序列化回调

如果对象实现了IMessagePackSerializationCallbackReceiver,则接受OnBeforeSerializeOnAfterDeserialize序列化处理。

[MessagePackObject]
public class SampleCallback : IMessagePackSerializationCallbackReceiver
{
    [Key(0)]
    public int Key { get; set; }

    public void OnBeforeSerialize()
    {
        Console.WriteLine("OnBefore");
    }

    public void OnAfterDeserialize()
    {
        Console.WriteLine("OnAfter");
    }
}

Union

MessagePack for C#支持序列化接口。这就像XmlInclude或ProtoInclude。在MessagePack for C#里叫Union。UnionAttribute只能附加到接口或抽象类。 它需要区分的整型key和子类型

// mark inheritance types
[MessagePack.Union(0, typeof(FooClass))]
[MessagePack.Union(1, typeof(BarClass))]
public interface IUnionSample
{
}

[MessagePackObject]
public class FooClass : IUnionSample
{
    [Key(0)]
    public int XYZ { get; set; }
}

[MessagePackObject]
public class BarClass : IUnionSample
{
    [Key(0)]
    public string OPQ { get; set; }
}

// ---

IUnionSample data = new FooClass() { XYZ = 999 };

// serialize interface.
var bin = MessagePackSerializer.Serialize(data);

// deserialize interface.
var reData = MessagePackSerializer.Deserialize<IUnionSample>(bin);

// use type-switch of C# 7.0
switch (reData)
{
    case FooClass x:
        Console.WriteLine(x.XYZ);
        break;
    case BarClass x:
        Console.WriteLine(x.OPQ);
        break;
    default:
        break;
}

C#7.0 type-switch是Union的最佳选择。 Union被序列化为两个长度的数组。

IUnionSample data = new BarClass { OPQ = "FooBar" };

var bin = MessagePackSerializer.Serialize(data);

// Union is serialized to two-length array, [key, object]
// [1,["FooBar"]]
Console.WriteLine(MessagePackSerializer.ToJson(bin));

在抽象类中使用Union,你可以像接口那样使用。

[Union(0, typeof(SubUnionType1))]
[Union(1, typeof(SubUnionType2))]
[MessagePackObject]
public abstract class ParentUnionType
{
    [Key(0)]
    public int MyProperty { get; set; }
}

[MessagePackObject]
public class SubUnionType1 : ParentUnionType
{
    [Key(1)]
    public int MyProperty1 { get; set; }
}

[MessagePackObject]
public class SubUnionType2 : ParentUnionType
{
    [Key(1)]
    public int MyProperty2 { get; set; }
}

继承类型的序列化,在数组(或键值对)中是扁平化的,对于整型键是无关紧要的,它不能复制父类和所有的子类。

Dynamic(Untyped)反序列化

如果使用MessagePackSerializer.Deserialize<object> 或者MessagePackSerializer.Deserialize<dynamic>,messagepack将转换为 primitive values,msgpack-primitive将转换为bool, char, sbyte, byte, short, int, long, ushort, uint, ulong, float, double, DateTime, string, byte[], object[], IDictionary<object, object>.

// sample binary.
var model = new DynamicModel { Name = "foobar", Items = new[] { 1, 10, 100, 1000 } };
var bin = MessagePackSerializer.Serialize(model, ContractlessStandardResolver.Instance);

// dynamic, untyped
var dynamicModel = MessagePackSerializer.Deserialize<dynamic>(bin, ContractlessStandardResolver.Instance);

Console.WriteLine(dynamicModel["Name"]); // foobar
Console.WriteLine(dynamicModel["Items"][2]); // 100

所以你可以使用索引访问键值对或者数组。

Object 类型序列化

StandardResolverContractlessStandardResolver可以通过DynamicObjectTypeFallbackResolver将Object类型序列化为具体类型。

var objects = new object[] { 1, "aaa", new ObjectFieldType { Anything = 9999 } };
var bin = MessagePackSerializer.Serialize(objects);

// [1,"aaa",[9999]]
Console.WriteLine(MessagePackSerializer.ToJson(bin));

// Support Anonymous Type Serialize
var anonType = new { Foo = 100, Bar = "foobar" };
var bin2 = MessagePackSerializer.Serialize(anonType, MessagePack.Resolvers.ContractlessStandardResolver.Instance);

// {"Foo":100,"Bar":"foobar"}
Console.WriteLine(MessagePackSerializer.ToJson(bin2));

Unity支持是有限的。

反序列化时,与Dynamic(Untyped)反序列化相同。

Typeless

Typeless API就像BinaryFormatter, 将类型信息嵌入到二进制中,所以不需要类型去反序列化.

object mc = new Sandbox.MyClass()
{
    Age = 10,
    FirstName = "hoge",
    LastName = "huga"
};

// serialize to typeless
var bin = MessagePackSerializer.Typeless.Serialize(mc);

// binary data is embeded type-assembly information.
// ["Sandbox.MyClass, Sandbox",10,"hoge","huga"]
Console.WriteLine(MessagePackSerializer.ToJson(bin));

// can deserialize to MyClass with typeless
var objModel = MessagePackSerializer.Typeless.Deserialize(bin) as MyClass;

类型信息由mspgack ext格式序列化,typecode为100。

MessagePackSerializer.TypelessSerialize / Deserialize <object>(TypelessContractlessStandardResolver.Instance)的快捷方式。 如果要配置默认的Typeless解析器,可以通过MessagePackSerializer.Typeless.RegisterDefaultResolver进行设置。

性能

与其他序列化器在Windows 10 Pro x64 Intel Core i7-6700K 4.00GHz, 32GB RAM上进行Benchmarks比较,Benchmark代码在这-版本信息,ZeroFormatter和FlatBuffers具有非常快速的反序列化器,因此忽略反序列化的性能。

MessagePack for C#使用许多技术来提高性能。

  • 序列化只使用ref byte []和int offset,不使用(Memory)Stream(调用Stream api会有开销)
  • 高级API使用内部内存池,分配工作内存不要低于64k
  • 不创建中间实用程序实例(XxxWriter / Reader,XxxContext等)
  • 所有代码避免装箱,所有平台(包括Unity / IL2CPP)
  • 对静态泛型字段生成的格式化程序进行缓存,查找时从缓存查找(不使用字典缓存,因为字典查找需要一定开销)
  • 重新调整的动态代码生成
  • 当代码生成知道目标是primitive时直接调用PrimitiveAPI
  • 当代码生成知道目标(整数/字符串)范围时,减少可变长度格式的分支
  • 不在迭代集合上使用IEnumerable<T> 抽象
  • 使用预先生成的查找表来减少检查消息包类型所耗时间
  • 对非泛型方法使用优化类型key字典
  • 避免查找映射(字符串键)键的字符串键解码,并使用自动化名称查找与il内联代码生成
  • 对于字符串键编码,预先生成的成员名字节并在IL中使用固定大小的二进制副本

在创建这个库之前,作则实现了一个具有ZeroFormatter#Performance的快速序列化器。 这是一个进一步演变的实现。 MessagePack for C#始终是快速的,为所有类型(原始,小结构,大对象,任何集合)进行了优化。

反序列化中每个方法的性能

性能取决于选项。 这是一个BenchmarkDotNet的微型benchamark。 目标对象有9个成员(MyProperty1〜MyProperty9),值为零。

Method

Mean

Error

Scaled

Gen 0

Allocated

IntKey

72.67 ns

NA

1.00

0.0132

56 B

StringKey

217.95 ns

NA

3.00

0.0131

56 B

Typeless_IntKey

176.71 ns

NA

2.43

0.0131

56 B

Typeless_StringKey

378.64 ns

NA

5.21

0.0129

56 B

MsgPackCliMap

1,355.26 ns

NA

18.65

0.1431

608 B

MsgPackCliArray

455.28 ns

NA

6.26

0.0415

176 B

ProtobufNet

265.85 ns

NA

3.66

0.0319

136 B

Hyperion

366.47 ns

NA

5.04

0.0949

400 B

JsonNetString

2,783.39 ns

NA

38.30

0.6790

2864 B

JsonNetStreamReader

3,297.90 ns

NA

45.38

1.4267

6000 B

JilString

553.65 ns

NA

7.62

0.0362

152 B

JilStreamReader

1,408.46 ns

NA

19.38

0.8450

3552 B

IntKey,StringKey,Typeless_IntKey,Typeless_StringKey都是MessagePack for C#的方法 ,在反序列化过程中实现零内存分配。JsonNetString /JilString从字符串反序列化。JsonStStreamReader / JilStreamReader是从StreamReader的UTF8 byte []中反序列化的。反序列化通常从Stream读取。 因此,它将从字节数组(或流)而不是字符串中读取。

MessagePack for C#IntKey是最快的。 StringKey比IntKey慢,因为StringKey需要从字符串进行匹配。 如果是IntKey,读取数组长度,根据数组长度进行for循环二进制解码。 如果StringKey,读取map 长度,根据map长度循环,首先需要对密钥解码,然后按照key查找,最后二进制解码,则需要额外两个步骤(解码密钥和按键查找)。

字符串键通常是有用的,无约束的,简单的JSON替换,与其他语言的互操作性,以及更多的某些版本。 MessagePack for C#也为String Key进行了优化。 首先,它不会将UTF8字节数组解码为与成员名称匹配的字符串,它会按原样查找字节数组(避免解码成本和额外分配)。

它会尝试匹配每个长整型(long)(每8个字符,如果长度不够,填充0)使用automata和在生成时内联IL代码。

这也避免了计算字节数组的哈希码,并且可以在长单元上进行多次比较。

这是ILSpy生成的反序列化器代码的示例的反编译。

https://github.com/neuecc/MessagePack-CSharp#performance

如果节点数量很大,则使用嵌入式二进制搜索进行搜索。

另外请注意,这是序列化的基准测试结果。

Method

Mean

Error

Scaled

Gen 0

Allocated

IntKey

84.11 ns

NA

1.00

0.0094

40 B

StringKey

126.75 ns

NA

1.51

0.0341

144 B

Typeless_IntKey

183.31 ns

NA

2.18

0.0265

112 B

Typeless_StringKey

193.95 ns

NA

2.31

0.0513

216 B

MsgPackCliMap

967.68 ns

NA

11.51

0.1297

552 B

MsgPackCliArray

284.20 ns

NA

3.38

0.1006

424 B

ProtobufNet

176.43 ns

NA

2.10

0.0665

280 B

Hyperion

280.14 ns

NA

3.33

0.1674

704 B

ZeroFormatter

149.95 ns

NA

1.78

0.1009

424 B

JsonNetString

1,432.55 ns

NA

17.03

0.4616

1944 B

JsonNetStreamWriter

1,775.72 ns

NA

21.11

1.5526

6522 B

JilString

547.51 ns

NA

6.51

0.3481

1464 B

JilStreamWriter

778.78 ns

NA

9.26

1.4448

6066 B

当然,IntKey是最快的,但StringKey也不错。

LZ4压缩

MessagePack是一个快速和紧凑的格式,但它不是压缩格式。 LZ4是非常快速的压缩算法,使用MessagePack for C#可以实现极快的性能和非常紧凑的二进制大小!

MessagePack for C#具有内置的LZ4支持。 您可以使用LZ4MessagePackSerializer而不是MessagePackSerializer。 内建支持是特殊的,作者已经创建了序列化压缩管道,并专门调整了管道,所以共享工作内存,不分配,不要调整,直到完成。

序列化二进制不是简单地压缩lz4二进制。 序列化二进制是有效的MessagePack二进制使用ext格式和自定义typecode(99)。

var array= Enumerable.Range(1, 100).Select(x => new MyClass { Age = 5, FirstName = "foo", LastName = "bar" }).ToArray();

// call LZ4MessagePackSerializer instead of MessagePackSerializer, api is completely same
var lz4Bytes = LZ4MessagePackSerializer.Serialize(array);
var mc2 = LZ4MessagePackSerializer.Deserialize<MyClass[]>(lz4Bytes);

// you can dump lz4 message pack
// [[5,"hoge","huga"],[5,"hoge","huga"],....]
var json = LZ4MessagePackSerializer.ToJson(lz4Bytes);
Console.WriteLine(json);

// lz4Bytes is valid MessagePack, it is using ext-format( [TypeCode:99, SourceLength|CompressedBinary] )
// [99,"0gAAA+vf3ABkkwWjZm9vo2JhcgoA////yVBvo2Jhcg=="]
var rawJson = MessagePackSerializer.ToJson(lz4Bytes);
Console.WriteLine(rawJson);

与protobuf,JSON,ZeroFormatter比较

protbuf-net是.NET上最常用的二进制格式化库。 我(作者)喜欢protobuf-net,并尊重那伟大的工作。 但是如果使用protobuf-net作为通用序列化格式,则可能会引起烦人的问题。

[ProtoContract]
public class Parent
{
    [ProtoMember(1)]
    public int Primitive { get; set; }
    [ProtoMember(2)]
    public Child Prop { get; set; }
    [ProtoMember(3)]
    public int[] Array { get; set; }
}

[ProtoContract]
public class Child
{
    [ProtoMember(1)]
    public int Number { get; set; }
}

using (var ms = new MemoryStream())
{
    // serialize null.
    ProtoBuf.Serializer.Serialize<Parent>(ms, null);

    ms.Position = 0;
    var result = ProtoBuf.Serializer.Deserialize<Parent>(ms);

    Console.WriteLine(result != null); // True, not null. but all property are zero formatted.
    Console.WriteLine(result.Primitive); // 0
    Console.WriteLine(result.Prop); // null
    Console.WriteLine(result.Array); // null
}

using (var ms = new MemoryStream())
{
    // serialize empty array.
    ProtoBuf.Serializer.Serialize<Parent>(ms, new Parent { Array = new int[0] });

    ms.Position = 0;
    var result = ProtoBuf.Serializer.Deserialize<Parent>(ms);

    Console.WriteLine(result.Array == null); // True, null!
}

protobuf(-net)不能正确处理null和空集合。 因为protobuf没有null表示(这是protobuf-net作者的答案)。

MessagePack规范可以完全序列化C#类型。 这就是推荐MessagePack而不是protobuf的原因。

Protocol Buffers具有良好的IDL和gRPC,这比MessagePack好得多。 如果你想使用IDL,我(作者)推荐Google.Protobuf。

JSON是很好的通用格式。 这是完美的,简单的,足够规范的。 Utf8Json创建了我采用与MessagePack for C#相同的体系结构,并避免编码/修饰成本,所以像二进制一样工作。 如果你想了解二进制与文本,请参阅Utf8Json /应使用哪个序列化器部分。

ZeroFormatter与FlatBuffers类似,但专门用于C#。 这是特别的。 反序列化速度非常快,但是二进制大小却很大。 而ZeroFormatter的缓存算法需要额外的内存。

ZeroFormatter也是特别的。 当与ZeroFormatter对比的情况下,它显示格式化的力量。 但是对于许多常见的用途,MessagePack for C#会更好。

扩展

MessagePack for C#具有扩展点,您可以添加外部类型的序列化支持。 下列是官方扩展支持。

Install-Package MessagePack.ImmutableCollection
Install-Package MessagePack.ReactiveProperty
Install-Package MessagePack.UnityShims
Install-Package MessagePack.AspNetCoreMvcFormatter

MessagePack.ImmutableCollection添加对 System.Collections.Immutable的支持. 添加了对ImmutableArray<>, ImmutableList<>, ImmutableDictionary<,>, ImmutableHashSet<>, ImmutableSortedDictionary<,>, ImmutableSortedSet<>, ImmutableQueue<>, ImmutableStack<>, IImmutableList<>, IImmutableDictionary<,>, IImmutableQueue<>, IImmutableSet<>, IImmutableStack<>的序列化支持.

MessagePack.ReactiveProperty包添加对ReactiveProperty库的支持。它增加了ReactiveProperty <>,IReactiveProperty <>,IReadOnlyReactiveProperty <>,ReactiveCollection <>,unit序列化支持。 这对保存视图模型状态很有用。

MessagePack.AspNetCoreMvcFormatter是ASP.NET Core MVC序列化的附加组件,可提升性能。 这是配置示例。

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc().AddMvcOptions(option =>
    {
        option.OutputFormatters.Clear();
        option.OutputFormatters.Add(new MessagePackOutputFormatter(ContractlessStandardResolver.Instance));
        option.InputFormatters.Clear();
        option.InputFormatters.Add(new MessagePackInputFormatter(ContractlessStandardResolver.Instance));
    });
}

更多信息请访问github: https://github.com/neuecc/MessagePack-CSharp

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏IMWeb前端团队

网络序?本地序?傻傻分不清楚。。。

网络序?本地序?傻傻分不清楚。。。 这个问题源于最近做的一个项目,需要用Node.js进行socket网络编程,涉及到使用TCP/UDP通过自定义的二进制数据序...

18510
来自专栏ASP.NET MVC5 后台权限管理系统

ASP.NET MVC5+EF6+EasyUI 后台管理系统(33)-MVC 表单验证

注:本节阅读需要有MVC 自定义验证的基础,否则比较吃力 一直以来表单的验证都是不可或缺的,微软的东西还是做得比较人性化的,从webform到MVC,都做到了双...

1805
来自专栏Spring相关

SocketIo+SpringMvc实现文件的上传下载

socketIo不仅可以用来做聊天工具,也可以实现局域网(当然你如果有外网也可用外网)内实现文件的上传和下载,下面是代码的效果演示:

572
来自专栏编程之旅

Swift中的"警卫队"

大半个月没有更新自己的博客了,最近在忙一个新项目时间非常紧张,所以最近的博客更新进度就要稍微放缓一点了。

601
来自专栏我的小碗汤

用go语言爬取珍爱网 | 第二回

昨天我们一起爬取珍爱网首页,拿到了城市列表页面,接下来在返回体城市列表中提取城市和url,即下图中的a标签里的href的值和innerText值。

954
来自专栏函数式编程语言及工具

Scalaz(16)- Monad:依赖注入-Dependency Injection By Reader Monad

  在上一篇讨论里我们简单的介绍了一下Cake Pattern和Reader Monad是如何实现依赖注入的。主要还是从方法上示范了如何用Cake Patter...

1848
来自专栏恰同学骚年

数据结构基础温故-6.查找(下):哈希表

哈希(散列)技术既是一种存储方法,也是一种查找方法。然而它与线性表、树、图等结构不同的是,前面几种结构,数据元素之间都存在某种逻辑关系,可以用连线图示表示出来,...

861
来自专栏软件工程师成长笔记

Java判断计算机网络连接是否正常

1012
来自专栏草根专栏

使用 dynamic 类型让 ASP.NET Core 实现 HATEOAS 结构的 RESTful API

上一篇写的是使用静态基类方法的实现步骤: http://www.cnblogs.com/cgzl/p/8726805.html 使用dynamic (Expa...

4696
来自专栏林德熙的博客

WPF 如何在绑定失败异常

在开发 WPF 程序,虽然 xaml 很好用,但是经常会出现小伙伴把绑定写错了。因为默认的 VisualStudio 是没有自动提示,这时很容易复制粘贴写出一个...

861

扫码关注云+社区