protobuf-net无法反序列化我的类

Question

我希望将一个名为“Player”的类序列化并通过网络流发送给客户端。

玩家类

    [ProtoMember(1)]
    public int flag;
    [ProtoMember(2)]
    public Int16 id;
    [ProtoMember(3)]
    public MyVector3 CharPos;
    [ProtoMember(7)]
    public bool spawned;

MyVector3是由于protobuf不支持Vector3的序列化而创建的。

[ProtoContract]
public class MyVector3
{
    [ProtoMember(4)]
    public float X { get; set; }

    [ProtoMember(5)]
    public float Y { get; set; }

    [ProtoMember(6)]
    public float Z { get; set; }

    public MyVector3()
    {
        this.X = 0.0f;
        this.Y = 0.0f;
        this.Z = 0.0f;
    }

    public MyVector3(float x, float y, float z)
    {
        this.X = x;
        this.Y = y;
        this.Z = z;
    }

    public static implicit operator Vector3(MyVector3 v)
    {
        return new Vector3(v.X, v.Y, v.Z);
    }

    public static implicit operator MyVector3(Vector3 v)
    {
        return new MyVector3(v.X, v.Y, v.Z);
    }
}

序列化和反序列化功能

public byte[] serialize(Object obj)
    {
        if (obj == null)
        {
            return null;
        }
        MemoryStream ms = new MemoryStream();
        Serializer.SerializeWithLengthPrefix(ms,obj,PrefixStyle.Base128);
        return ms.ToArray();
    }

    public Player deserialize(NetworkStream inc)
    {
        Player obj = Serializer.DeserializeWithLengthPrefix<Player>(inc,PrefixStyle.Base128);
        return obj;
    }

测试功能（实际上不起作用！）

    static void Main(string[] args)
    {
        TcpListener serverSocket = new TcpListener(8888);
        TcpClient clientSocket = default(TcpClient);

        Serialize ser = new Serialize();

        Player temp = new Player();

        serverSocket.Start();

        while (true)
        {
            clientSocket = serverSocket.AcceptTcpClient();
            using (NetworkStream networkStream = clientSocket.GetStream())
            {
                DeserializeTest(ser,networkStream);
                SerializeTest(ser, networkStream);
            }
        }

    }

    static void SerializeTest(Serialize ser,NetworkStream networkStream)
    {
        Player temp = new Player();
        BinaryWriter writer = new BinaryWriter(networkStream);
        writer.Write(ser.serialize(temp));
        networkStream.Flush();
    }

    static void DeserializeTest(Serialize ser, NetworkStream networkStream)
    {
        Player temp = new Player();
        temp = (Player)ser.deserialize(networkStream);
        Console.WriteLine(temp.flag.ToString() + temp.CharPos.ToString());
        networkStream.Flush();
    }
}

现在会发生什么：

当启动DeserializeTest并尝试从networkStream反序列化数据时，整个函数会“冻结”并开始循环。仅在客户端对数据进行序列化并将其发送到服务器（此代码）进行反序列化时，一切都能正常运行。

- Nop0x

---

哦，顺便说一下 - 我相信v2可以处理Vector3；如果您想要，我可以向您展示如何配置它。 - Marc Gravell

能够处理这个问题会非常好！你能向我展示如何正确使用 SerializeWithLengthPrefix 和 DeserializeWithLengthPrefix 吗？ - Nop0x

重新无效的线路类型 - 如果您例如在没有更改长度的情况下覆盖文件，则通常会发生这种情况。您能否更新以显示您拥有的内容，以便我可以重现？ - Marc Gravell

好的，我刚刚更新了上面的代码 :) - Nop0x

找到了问题，它是serialize(Object obj) - 应该被输入为Player类型 - 它在混合中引入了一个静默的<object>，这是不喜欢的。完整示例请参见编辑；还要注意使用MyVector3。 - Marc Gravell

Answer 1

网络流不会在关闭之前结束，而默认情况下，Protobuf（由Google定义）会消耗完整个流。它正在等待更多的数据或者你的流已经明确结束。如果你想发送多个消息或者只想保持流的开放状态，请用 SerializeWithLengthPrefix 和 DeserializeWithLengthPrefix 替换 Serialize 和 Deserialize。这将添加额外的信息以便可以在不关闭流的情况下获取单个消息。重要的是，管道的两端都知道使用了这种变量。

---

完整示例（这是使用核心 .NET，但现在应该没有问题）：

using System;
using System.IO;
using System.Net.Sockets;
using System.Threading;
using ProtoBuf;
[ProtoContract]
public class Player
{
    [ProtoMember(1)] public int flag;
    [ProtoMember(2)] public Int16 id;
    [ProtoMember(3, DataFormat = DataFormat.Group)] public MyVector3 CharPos;
    [ProtoMember(7)] public bool spawned;
}

public struct MyVector3
{
    public readonly float X, Y, Z;
    public MyVector3(float x, float y, float z)
    {
        X = x;
        Y = y;
        Z = z;
    }
    public override string ToString()
    {
        return string.Format("({0},{1},{2})", X, Y, Z);
    }
}

static class Program
{
    static ManualResetEvent evt = new ManualResetEvent(false);
    static void Main(string[] args)
    {
        var player = new Player() {CharPos = new MyVector3(1, 2, 3), flag=123, id=456, spawned=true};
        ThreadPool.QueueUserWorkItem(x =>
        {
            Console.WriteLine("client: waiting for server");
            evt.WaitOne();
            Console.WriteLine("client: opening connection");
            using (var client = new TcpClient("localhost", 15000))
            using (var ns = client.GetStream())
            {
                serialize(ns, player);
                ns.Flush();
                Console.WriteLine("client: wrote player");

                Console.WriteLine("client: waiting for response");
                while (ns.ReadByte() >= 0)
                {
                    Console.WriteLine("client: receiving...");
                }
                Console.WriteLine("client: connection closed by server");
                ns.Close();
            }
        });
        TcpListener serverSocket = new TcpListener(15000);
        TcpClient clientSocket;

        serverSocket.Start();

        Console.WriteLine("server: accepting connections");
        evt.Set();
        while (true)
        {
            Console.WriteLine("server: waiting for client...");
            clientSocket = serverSocket.AcceptTcpClient();
            Console.WriteLine("server: got client");
            using (NetworkStream networkStream = clientSocket.GetStream())
            {
                var fromNetwork = deserialize(networkStream);
                Console.WriteLine("server: got player");
                Console.WriteLine("> flag: {0}", fromNetwork.flag);
                Console.WriteLine("> id: {0}", fromNetwork.id);
                Console.WriteLine("> spawned: {0}", fromNetwork.spawned);
                Console.WriteLine("> pos: {0}", fromNetwork.CharPos);
            }
        }

    }
    public static void serialize(Stream dest, Player player)
    {
        if (player == null) throw new ArgumentNullException();
        Serializer.SerializeWithLengthPrefix(dest, player, PrefixStyle.Base128);
    }

    public static Player deserialize(Stream inc)
    {
        Player obj = Serializer.DeserializeWithLengthPrefix<Player>(inc, PrefixStyle.Base128);
        return obj;
    }
}

这将会给出：

client: waiting for server
server: accepting connections
server: waiting for client...
client: opening connection
server: got client
client: wrote player
client: waiting for response
server: got player
> flag: 123
> id: 456
> spawned: True
> pos: (1,2,3)
client: connection closed by server
server: waiting for client...

- Marc Gravell

---

首先感谢您的帮助，但是根据我的代码，我不确定要给SerializeWithLengthPrefix或DeserializeWithLengthPrefix哪些参数，因为我无法真正理解文档中的句子。 - Nop0x

其实只要他们同意就没关系了！但我更喜欢的选项是：..., PrefixStyle.Base128, 1 - Marc Gravell