23

我有 2 个联网应用程序，它们应该相互发送序列化的 protobuf-net 消息。我可以序列化对象并发送它们，但是，我无法弄清楚如何反序列化接收到的字节。

我试图用这个反序列化，但它失败了一个 NullReferenceException。

// Where "ms" is a memorystream containing the serialized
// byte array from the network.
Messages.BaseMessage message =
  ProtoBuf.Serializer.Deserialize<Messages.BaseMessage>(ms);

我在包含消息类型 ID 的序列化字节之前传递了一个标头，我可以在一个巨大的 switch 语句中使用它来返回预期的子类类型。使用下面的块，我收到错误：System.Reflection.TargetInvocationException ---> System.NullReferenceException。

//Where "ms" is a memorystream and "messageType" is a
//Uint16.
Type t = Messages.Helper.GetMessageType(messageType);
System.Reflection.MethodInfo method =
  typeof(ProtoBuf.Serializer).GetMethod("Deserialize").MakeGenericMethod(t);
message = method.Invoke(null, new object[] { ms }) as Messages.BaseMessage;

这是我用来通过网络发送消息的功能：

internal void Send(Messages.BaseMessage message){
  using (System.IO.MemoryStream ms = new System.IO.MemoryStream()){
    ProtoBuf.Serializer.Serialize(ms, message);
    byte[] messageTypeAndLength = new byte[4];
    Buffer.BlockCopy(BitConverter.GetBytes(message.messageType), 0, messageTypeAndLength, 0, 2);
    Buffer.BlockCopy(BitConverter.GetBytes((UInt16)ms.Length), 0, messageTypeAndLength, 2, 2);
    this.networkStream.Write(messageTypeAndLength);
    this.networkStream.Write(ms.ToArray());
  }
}

这个类，带有基类，我正在序列化：

[Serializable,
ProtoContract,
ProtoInclude(50, typeof(BeginRequest))]
abstract internal class BaseMessage
{
  [ProtoMember(1)]
  abstract public UInt16 messageType { get; }
}

[Serializable,
ProtoContract]
internal class BeginRequest : BaseMessage
{
    [ProtoMember(1)]
    public override UInt16 messageType
    {
        get { return 1; }
    }
}

使用 Marc Gravell 的建议进行了修复。我从只读属性中删除了 ProtoMember 属性。也切换到使用 SerializeWithLengthPrefix。这是我现在拥有的：

[Serializable,
ProtoContract,
ProtoInclude(50, typeof(BeginRequest))]
abstract internal class BaseMessage
{
  abstract public UInt16 messageType { get; }
}

[Serializable,
ProtoContract]
internal class BeginRequest : BaseMessage
{
    public override UInt16 messageType
    {
        get { return 1; }
    }
}

接收对象：

//where "this.Ssl" is an SslStream.
BaseMessage message =
  ProtoBuf.Serializer.DeserializeWithLengthPrefix<BaseMessage>(
    this.Ssl, ProtoBuf.PrefixStyle.Base128);

发送对象：

//where "this.Ssl" is an SslStream and "message" can be anything that
// inherits from BaseMessage.
ProtoBuf.Serializer.SerializeWithLengthPrefix<BaseMessage>(
  this.Ssl, message, ProtoBuf.PrefixStyle.Base128);
4

3 回答 3

9 
Serializer.NonGeneric.Deserialize(Type, Stream); //Thanks,  Marc.

或者

RuntimeTypeModel.Default.Deserialize(Stream, null, Type);
于 2012-06-15T11:12:41.770 回答
8

第一的; 对于网络使用，SerializeWithLengthPrefix您DeserializeWithLengthPrefix可以使用哪个句柄长度（可选地带有标签）。MakeGenericMethod乍一看还可以；这实际上与我为实现 RPC 堆栈所做的工作的挂起提交密切相关：挂起的代码has an override of DeserializeWithLengthPrefix（本质上）采用 a Func<int,Type>，将标记解析为类型，以便更容易反序列化意外数据在飞行中。

BaseMessage如果消息类型实际上与and之间的继承有关BeginRequest，那么你不需要这个；它总是转到层次结构中最顶层的合约类型并向下工作（由于一些电汇细节）。

另外-我还没有机会对其进行测试，但是以下内容可能会令人不安：

[ProtoMember(1)]
public override UInt16 messageType
{
    get { return 1; }
}

它被标记为序列化，但没有设置值的机制。也许这就是问题所在？尝试删除[ProtoMember]此处，因为我不认为这很有用 - 它（就序列化而言）主要是[ProtoInclude(...)]标记的副本。

于 2009-03-23T23:37:18.953 回答
4

处理此问题的另一种方法是使用 protobuf-net 进行“繁重的工作”，但使用您自己的消息头。处理网络消息的问题是它们可以跨越边界被打破。这通常需要使用缓冲区来累积读取。如果您使用自己的标头，则可以在将消息传递给 protobuf-net 之前确保消息完整存在。

举个例子：

发送

using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
{
    MyMessage message = new MyMessage();
    ProtoBuf.Serializer.Serialize<BaseMessage>(ms, message);
    byte[] buffer = ms.ToArray();

    int messageType = (int)MessageType.MyMessage;
    _socket.Send(BitConverter.GetBytes(messageType));
    _socket.Send(BitConverter.GetBytes(buffer.Length));
    _socket.Send(buffer);
}

接受

protected bool EvaluateBuffer(byte[] buffer, int length)
{
    if (length < 8)
    {
        return false;
    }

    MessageType messageType = (MessageType)BitConverter.ToInt32(buffer, 0);
    int size = BitConverter.ToInt32(buffer, 4);
    if (length < size + 8)
    {
        return false;
    }

    using (MemoryStream memoryStream = new MemoryStream(buffer))
    {
        memoryStream.Seek(8, SeekOrigin.Begin);
        if (messageType == MessageType.MyMessage)
        {
            MyMessage message = 
                ProtoBuf.Serializer.Deserialize<MyMessage>(memoryStream);
        }
    }
}

后一种方法将在累加器缓冲区上“尝试”，直到有足够的数据。一旦满足大小要求，就可以对消息进行反序列化。

于 2009-05-05T19:04:13.480 回答