Protobuf-net：非官方手册

当使用 **ImplicitFields** 时，protobuf-net 会忽略标记为 **[ProtoIgnore]** 的字段/属性。需要明确的是，如果你不使用 **ImplicitFields**，字段和属性默认是被忽略的，必须使用 **[ProtoMember(N)]** 显式进行序列化。

1. 普通序列化。在这种模式下，会写入一个标准的 Protocol Buffer，其中 Protocol Buffer 中的每个字段对应于你用 **ProtoMember** 标记的或被 **ImplicitFields** 自动选中的每个字段或属性。在反序列化期间，默认会调用默认构造函数，但可以禁用此行为。我听说 protobuf-net 允许你反序列化到只读字段（？！），这应该能让你处理许多不可变对象的情况。
2. 集合序列化。如果 protobuf-net 将特定数据类型识别为集合，则使用此模式进行序列化。值得庆幸的是，集合类型不需要任何 **ProtoContract** 或 **ProtoMember** 特性，这意味着你可以轻松序列化 **List<T>** 和 **T[]** 等类型。（我不知道如果你的“集合”类上存在任何此类特性，protobuf-net 会如何反应）。我听说也支持字典。
3. 自动元组序列化。在某些条件下，protobuf-net 可以通过调用其非默认构造函数（参数多于零个的构造函数）来反序列化一个没有 **ProtoContract** 特性的不可变类型。幸运的是，这在链接中有完整文档。此功能自动应用于 **System.Tuple<...>** 和 **KeyValuePair**。
4. 字符串（“可解析”）序列化。Protobuf-net 可以序列化一个具有静态 **Parse()** 方法的类。它调用 **ToString()** 进行序列化，然后调用 **Parse(string)** 来反序列化该字符串。但是，此功能默认是禁用的。通过设置 **RuntimeTypeModel.Default.AllowParseableTypes = true** 来启用它。我不知道 **[ProtoContract]** 是否会禁用此功能。
5. “代理”序列化，这对于你不能修改的“封闭”类型（如 BCL（标准库）类型）非常有用。你可以通过 **RuntimeTypeModel.Default.Add(typeof(ClosedType), false) .SetSurrogate(typeof(SurrogateType))** 指定一个用户定义的类型作为代理，而不是直接序列化一个类型。为了在原始类型和代理类型之间进行转换，protobuf-net 会在代理类型上寻找转换运算符（**public static implicit operator ClosedType**，**public static explicit operator SurrogateType**）；**implicit** 和 **explicit** 都可以。即使要转换的“对象”是 **null**，转换运算符也会被调用。

1. “类似 XML 序列化”。在这种默认模式下，你的类必须有一个默认构造函数。在开始反序列化之前，你的默认（即无参数）构造函数会被调用。然而，与 XML 序列化不同，protobuf-net 可以调用私有构造函数。
2. “类似标准序列化”。选项 **[ProtoContract(SkipConstructor = true)]** 将在不调用构造函数的情况下进行反序列化，就像标准序列化一样。太神奇了！如果你添加 **ImplicitFields = ImplicitFields.AllFields**，protobuf-net 的行为会更接近标准序列化。
3. 显然，你可以反序列化到你自己创建的对象中，至少在根级别是这样。调用（非静态的）**RuntimeTypeModel.Deserialize(Stream, object, Type)** 方法（例如 **RuntimeTypeModel.Default.Deseralize()**）。我不知道为什么它既需要一个对象*又*需要一个 **Type**。也许它对子对象也能做同样的事情，我不确定。无论如何，如果你想连续反序列化、检查并丢弃多个对象，这会很方便；你可以避免为垃圾回收器制造不必要的工作。

[ProtoContract]
struct LatLonPoint
{
    [ProtoMember(1)] double X;
    [ProtoMember(2)] double Y;
    [ProtoAfterDeserialization] 
    void Validate() { 
        if (!(Math.Abs(X) <= 180 && Math.Abs(Y) <= 90)) 
            throw new FormatException("Invalid latitude or longitude enountered");
    }
}

你也可以使用 `System.Runtime.Serialization` 中的标准特性：`OnSerializingAttribute`、`OnSerializedAttribute`、`OnDeserializingAttribute` 和 `OnDeserializedAttribute`。微软规定使用这些特性的方法需要一个 `StreamingContext` 参数，但 protobuf-net 不需要。如果该参数存在，你会得到一个 `Context` 属性为 `null` 且 `State==StreamingContextStates.Persistence` 的 `StreamingContext`。

Protobuf-net 集合处理

[ProtoContract]
public class MyClass
{
    ...
    public IReadOnlyList<int> MyList;
        
    [ProtoMember(1, OverwriteList=true)]
    private IEnumerable<int> PB_MyList { 
        get { return MyList; } 
        set { MyList = ((IList<int>)value).AsReadOnly(); }
    }
    ...
}

[ProtoContract]
class DefaultRepresentations
{
  [ProtoMember(1)] int Int;
  [ProtoMember(2)] uint Uint;
  [ProtoMember(3)] byte Byte;
  [ProtoMember(4)] sbyte Sbyte;
  [ProtoMember(5)] ushort Ushort;
  [ProtoMember(6)] short Short;
  [ProtoMember(7)] long Long;
  [ProtoMember(8)] ulong Ulong;
  [ProtoMember(9)] float Float;
  [ProtoMember(10)] double Double;
  [ProtoMember(11)] decimal Decimal;
  [ProtoMember(12)] bool Bool;
  [ProtoMember(13)] string String;
  [ProtoMember(14)] DayOfWeek Enum;
  [ProtoMember(15)] byte[] Bytes;
  [ProtoMember(16)] string[] Strings;
  [ProtoMember(17)] char Char;
}

message DefaultRepresentations {
  optional int32 Int = 1 [default = 0];
  optional uint32 Uint = 2 [default = 0];
  optional uint32 Byte = 3 [default = 0];
  optional int32 Sbyte = 4 [default = 0];
  optional uint32 Ushort = 5 [default = 0];
  optional int32 Short = 6 [default = 0];
  optional int64 Long = 7 [default = 0];
  optional uint64 Ulong = 8 [default = 0];
  optional float Float = 9 [default = 0];
  optional double Double = 10 [default = 0];
  optional bcl.Decimal Decimal = 11 [default=0];
  optional bool Bool = 12 [default = false];
  optional string String = 13;
  optional DayOfWeek Enum = 14 [default=Sunday];
  optional bytes Bytes = 15;
  repeated string Strings = 16;
  optional uint32 Char = 17 [default = 

[ProtoContract]
class ExplicitRepresentations
{
  [ProtoMember(1, DataFormat = DataFormat.TwosComplement)] int defaultInt;
  [ProtoMember(2, DataFormat = DataFormat.TwosComplement)] int defaultLong;
  [ProtoMember(3, DataFormat = DataFormat.FixedSize)] int fixedSizeInt;
  [ProtoMember(4, DataFormat = DataFormat.FixedSize)] long fixedSizeLong;
  [ProtoMember(5, DataFormat = DataFormat.ZigZag)] int zigZagInt;
  [ProtoMember(6, DataFormat = DataFormat.ZigZag)] long zigZagLong;
  [ProtoMember(7, DataFormat = DataFormat.Default)] SubObject lengthPrefixedObject;
  [ProtoMember(8, DataFormat = DataFormat.Group)] SubObject groupObject;
}
[ProtoContract(ImplicitFields=ImplicitFields.AllFields)]
class SubObject { string x; }

message ExplicitRepresentations {
   optional int32 defaultInt = 1 [default = 0];
   optional int32 defaultLong = 2 [default = 0];
   optional sfixed32 fixedSizeInt = 3 [default = 0];
   optional sfixed64 fixedSizeLong = 4 [default = 0];
   optional sint32 zigZagInt = 5 [default = 0];
   optional sint64 zigZagLong = 6 [default = 0];
   optional SubObject lengthPrefixedObject = 7;
   optional group SubObject groupObject = 8;
}
message SubObject {
   optional string x = 1 [default = 0];
}

[ProtoContract]
class SubMessageRepresentations
{
  [ProtoMember(5, DataFormat = DataFormat.Default)] 
  public SubObject lengthPrefixedObject;
  [ProtoMember(6, DataFormat = DataFormat.Group)]
  public SubObject groupObject;
}
[ProtoContract(ImplicitFields=ImplicitFields.AllFields)]
class SubObject { public int x; }
/*
message SubMessageRepresentations {
   optional SubObject lengthPrefixedObject = 5;
   optional group SubObject groupObject = 6;
}
message SubObject {
   optional int32 x = 1 [default = 0];
}
*/

using (var stream = new MemoryStream()) {
  _pbModel.Serialize(
    stream, new SubMessageRepresentations {
      lengthPrefixedObject = new SubObject { x = 0x22 },
      groupObject = new SubObject { x = 0x44 }
    });
  byte[] buf = stream.GetBuffer();
  for (int i = 0; i < stream.Length; i++)
    Console.Write("{0:X2} ", buf[i]);
}

// Output: 2A 02 08 22 33 08 44 34 
// Interpretation:
// 0x2A: ((field=5) << 3) | (wire_type=2) // length-prefixed
// 0x02: length=2
// 0x08: ((field=1) << 3) | (wire_type=0) // varint
// 0x22: value of x
// 0x33: ((field=6) << 3) | (wire_type=3) // start group
// 0x08: ((field=1) << 3) | (wire_type=0) // varint
// 0x44: value of x
// 0x34: ((field=6) << 3) | (wire_type=4) // end group

message NetObjectProxy {
  // for a tracked object, the key of the **first** 
  // time this object was seen
  optional int32 existingObjectKey = 1; 
  // for a tracked object, a **new** key, the first 
  // time this object is seen
  optional int32 newObjectKey = 2;
  // for dynamic typing, the key of the **first** time 
  // this type was seen
  optional int32 existingTypeKey = 3; 
  // for dynamic typing, a **new** key, the first time 
  // this type is seen
  optional int32 newTypeKey = 4;
  // for dynamic typing, the name of the type (only 
  // present along with newTypeKey) 
  optional string typeName = 8;
  // the new string/value (only present along with 
  // newObjectKey)
  optional bytes payload = 10;
}