作为我的 protobuf 协议的一部分，我需要能够发送动态类型的数据，有点像 VARIANT。我大致要求数据是整数、字符串、布尔值或“其他”，其中“其他”（例如DateTime）被序列化为字符串。我需要能够将它们用作单个字段并在协议中多个不同位置的列表中使用。
如何在保持最小消息大小和最佳性能的同时最好地实现这一点？
我正在使用带有 C# 的 protobuf-net。
编辑：
我在下面发布了一个建议的答案，它使用了我认为所需的最小内存。
EDIT2：
在 http://github.com/pvginkel/ProtoVariant 创建了一个 github.com 项目并完成了实现。
【问题讨论】：
标签： c# .net protocol-buffers protobuf-net
我使用带有抽象基类型和子类的 ProtoInclude 来静态设置类型和单个值。这是 Variant 的开始：
[ProtoContract]
[ProtoInclude(1, typeof(Integer))]
[ProtoInclude(2, typeof(String))]
public abstract class Variant
{
[ProtoContract]
public sealed class Integer
{
[ProtoMember(1)]
public int Value;
}
[ProtoContract]
public sealed class String
{
[ProtoMember(1)]
public string Value;
}
}
用法：
var foo = new Variant.String { Value = "Bar" };
var baz = new Variant.Integer { Value = 10 };
这个答案会占用更多空间，因为它对 ProtoInclude 类实例的长度进行编码（例如，int 为 1 字节，小于 125 字节的字符串）。为了静态控制类型，我愿意忍受这一点。
【讨论】：
提问总是能帮助我思考。我找到了一种将用于传输的字节数降至最低的方法。
我在这里所做的是利用可选属性。假设我想发送一个 int32。当值不为零时，我可以检查消息上的属性是否有值。否则，我将类型设置为 INT32_ZERO。这样我就可以正确存储和重建值。下面的示例具有多种类型的此实现。
.proto 文件：
message Variant {
optional VariantType type = 1 [default = AUTO];
optional int32 value_int32 = 2;
optional int64 value_int64 = 3;
optional float value_float = 4;
optional double value_double = 5;
optional string value_string = 6;
optional bytes value_bytes = 7;
optional string value_decimal = 8;
optional string value_datetime = 9;
}
enum VariantType {
AUTO = 0;
BOOL_FALSE = 1;
BOOL_TRUE = 2;
INT32_ZERO = 3;
INT64_ZERO = 4;
FLOAT_ZERO = 5;
DOUBLE_ZERO = 6;
NULL = 7;
}
以及随附的部分 .cs 文件：
using System;
using System.Collections.Generic;
using System.Text;
using System.Globalization;
namespace ConsoleApplication6
{
partial class Variant
{
public static Variant Create(object value)
{
var result = new Variant();
if (value == null)
result.Type = VariantType.NULL;
else if (value is string)
result.ValueString = (string)value;
else if (value is byte[])
result.ValueBytes = (byte[])value;
else if (value is bool)
result.Type = (bool)value ? VariantType.BOOLTRUE : VariantType.BOOLFALSE;
else if (value is float)
{
if ((float)value == 0f)
result.Type = VariantType.FLOATZERO;
else
result.ValueFloat = (float)value;
}
else if (value is double)
{
if ((double)value == 0d)
result.Type = VariantType.DOUBLEZERO;
else
result.ValueDouble = (double)value;
}
else if (value is decimal)
result.ValueDecimal = ((decimal)value).ToString("r", CultureInfo.InvariantCulture);
else if (value is DateTime)
result.ValueDatetime = ((DateTime)value).ToString("o", CultureInfo.InvariantCulture);
else
throw new ArgumentException(String.Format("Cannot store data type {0} in Variant", value.GetType().FullName), "value");
return result;
}
public object Value
{
get
{
switch (Type)
{
case VariantType.BOOLFALSE:
return false;
case VariantType.BOOLTRUE:
return true;
case VariantType.NULL:
return null;
case VariantType.DOUBLEZERO:
return 0d;
case VariantType.FLOATZERO:
return 0f;
case VariantType.INT32ZERO:
return 0;
case VariantType.INT64ZERO:
return (long)0;
default:
if (ValueInt32 != 0)
return ValueInt32;
if (ValueInt64 != 0)
return ValueInt64;
if (ValueFloat != 0f)
return ValueFloat;
if (ValueDouble != 0d)
return ValueDouble;
if (ValueString != null)
return ValueString;
if (ValueBytes != null)
return ValueBytes;
if (ValueDecimal != null)
return Decimal.Parse(ValueDecimal, CultureInfo.InvariantCulture);
if (ValueDatetime != null)
return DateTime.Parse(ValueDatetime, CultureInfo.InvariantCulture);
return null;
}
}
}
}
}
编辑：
@Marc Gravell 的更多 cmets 显着改进了实现。有关此概念的完整实现，请参阅 Git 存储库。
【讨论】：
double 和 float 作为枚举更短，同意。
int?) 就是这样，但另一个是 bool ShouldSerialize*() 模式（从核心 .NET 借来） - 即，如果您有 int ValueInt {...} 和 bool ShouldSerializeValueInt() { /* true to serialize, false not to */ }，它将按照您的喜好行事。
Jon 的多个选项涵盖了最简单的设置，尤其是在您需要跨平台支持时。在 .NET 方面（以确保您不会序列化不必要的值），只需从任何不匹配的属性返回 null，例如：
public object Value { get;set;}
[ProtoMember(1)]
public int? ValueInt32 {
get { return (Value is int) ? (int)Value : (int?)null; }
set { Value = value; }
}
[ProtoMember(2)]
public string ValueString {
get { return (Value is string) ? (string)Value : null; }
set { Value = value; }
}
// etc
如果您不喜欢空值，您也可以使用 bool ShouldSerialize*() 模式执行相同操作。
将其包装在 class 中，您应该可以在字段级别或列表级别使用它。您提到了最佳性能；我可以建议的唯一额外的事情可能是考虑将其视为“组”而不是“子消息”，因为这更容易编码（只要您期望数据，也同样容易解码）。为此，请使用Grouped 数据格式，通过[ProtoMember]，即
[ProtoMember(12, DataFormat = DataFormat.Group)]
public MyVariant Foo {get;set;}
但是，这里的差异可能很小 - 但它避免了在输出流中进行一些回溯以固定长度。无论哪种方式，就开销而言，“子消息”至少需要 2 个字节；字段标题为“至少一个”（如果12 实际上是1234567，则可能需要更多） - 长度为“至少一个”，对于较长的消息，长度会变得更大。一个组需要 2 x 字段标头，因此如果您使用低字段编号，则无论封装数据的长度如何，这将是 2 个字节（可能是 5MB 的二进制文件）。
一个单独的技巧，对更复杂的场景有用，但不能互操作，是通用继承，即一个抽象基类，将ConcreteType<int>、ConcreteType<string> 等列为子类型 - 但是，这需要额外的 2 个字节（通常），所以不那么节俭。
又进一步远离核心规范，如果您真的无法告诉您需要支持哪些类型，并且不需要互操作性 - 有一些支持在数据中包含（优化）类型信息；请参阅 ProtoMember 上的 DynamicType 选项 - 这比其他两个选项占用更多空间。
【讨论】：
实际上 protobuf 不支持任何类型的 VARIANT 类型。
你可以尝试使用 Unions，查看更多细节here
主要思想是将所有现有消息类型的消息包装器定义为可选字段，并使用union 指定具体消息的类型。
通过上面的链接查看示例。
【讨论】：
您可能会收到这样的消息：
message Variant {
optional string string_value = 1;
optional int32 int32_value = 2;
optional int64 int64_value = 3;
optional string other_value = 4;
// etc
}
然后编写一个辅助类 - 可能还有扩展方法 - 以确保您只在变体中设置 一个 字段。
您可以选择包含一个单独的枚举值来指定设置哪个字段（使其更像一个标记的联合），但检查可选字段的能力只是意味着数据已经存在。这取决于您是想要找到正确字段的速度（在这种情况下添加鉴别器）还是仅包括数据本身的空间效率（在这种情况下不添加鉴别器）。
这是一种通用协议缓冲区方法。当然，可能还有更具体的 protobuf-net。
【讨论】：