我正在构建一个服务器/客户端应用程序，我正在寻找用于分离数据包的选项。我读过最合适的方法是创建一个 header ，其中包含有关有效载荷有多大的信息，然后读取直到它结束。

这是如何以编程方式工作的？

还使用“\n”换行符分隔它们。一个适当的例子会很好。

我以这种方式异步接收数据:

private void AsyncReceive(IAsyncResult result)
    {
        int bytesTransfered;

        try
        {
            bytesTransfered = _handle.EndReceive(result);

            if(bytesTransfered <= 0)
            {
                throw new Exception("No bytes transfered");
            }
        }
        catch(NullReferenceException)
        {
            return;
        }
        catch(ObjectDisposedException)
        {
            return;
        }
        catch(Exception)
        {
            return;
        }


        byte[] received = new byte[bytesTransfered];

        try
        {
            Array.Copy(_readBuffer, received, received.Length);
        }
        catch(Exception)
        {
            Disconnect();
            return;
        }


        // How should I process the received data now?


        try
        {
            _handle.BeginReceive(_readBuffer, 0, _readBuffer.Length, SocketFlags.None, AsyncReceive, null);
        }
        catch(ObjectDisposedException)
        {
            return;
        }
        catch(Exception)
        {

        }
    }

最佳答案

首先您需要区分不同类型的消息。您可以为此使用单字节，这将允许多达 255 种不同的消息类型。为此创建一个枚举，并使用一个属性来标记您的消息(见下文):

enum MessageType : byte {
    FirstMessage,
    SecondMessage
}

class MessageAttribute : Attribute {
    public MessageAttribute(MessageType type) {
        Type = type;
    }

    public MessageType Type { get; private set; }
}

其次，您需要为消息提供紧凑的序列化程序。一个不错的选择是 protobuf - 它非常紧凑(不序列化属性名称，仅序列化值等)同时仍然易于使用。

[Message(MessageType.FirstMessage)]
[ProtoContract]
class MyFirstMessage {
    [ProtoMember(1)]
    public string Value { get; set; }
    [ProtoMember(2)]
    public int AnotherValue { get; set; }
}

[Message(MessageType.SecondMessage)]
[ProtoContract]
class MySecondMessage {
    [ProtoMember(1)]
    public decimal Stuff { get; set; }
}

第三，您需要知道消息的长度，正如调用者告诉您的那样。为此使用 2 或 4 个字节(分别为 Int16 和 Int32 类型的大小)。

所以我们的格式是:1 字节 - 消息类型。 2-5 字节 - 消息大小，5-5+size 字节 - protobuf 序列化消息。然后按以下定义的三个步骤阅读您的流:

class MessageReader {
    static readonly Dictionary<byte, Type> _typesMap = new Dictionary<byte, Type>(); 
    static MessageReader() {
        // initialize your map
        // this is executed only once per lifetime of your app
        foreach (var type in Assembly.GetExecutingAssembly().GetTypes().Where(c => c.GetCustomAttribute<MessageAttribute>() != null)) {
            var message = type.GetCustomAttribute<MessageAttribute>();
            _typesMap.Add((byte)message.Type, type);
        }
    }

    public async Task<object> Read(Stream stream) {
        // this is your network or any other stream you have
        // read first byte - that is message type
        var firstBuf = new byte[1];
        if (await stream.ReadAsync(firstBuf, 0, 1) != 1) {
            // failed to read - end of stream
            return null;
        }

        var type = firstBuf[0];
        if (!_typesMap.ContainsKey(type)) {
            // unknown message, handle somehow
            return null;
        }
        // read next 4 bytes - length of a message
        var lengthBuf = new byte[4];
        if (await stream.ReadAsync(lengthBuf, 0, 4) != 4) {
            // read less than expected - EOF
            return null;
        }
        var length = BitConverter.ToInt32(lengthBuf, 0);
        // check if length is not too big here! or use 2 bytes for length if your messages allow that
        if (length > 1*1024*1024) {
            // for example - adjust to your needs
            return null;
        }
        var messageBuf = new byte[length];
        if (await stream.ReadAsync(messageBuf, 0, length) != length) {
            // didn't read full message - EOF
            return null;
        }
        try {
            return ProtoBuf.Serializer.NonGeneric.Deserialize(_typesMap[type], new MemoryStream(messageBuf));
        }
        catch {
            // handle invalid message somehow
            return null;
        }
    }
}

从流中读取一条消息后 - 以相同的方式继续读取下一条消息。读取调用将阻塞，直到新数据到达。如果有任何违反协议(protocol)的行为 - 断开连接。

关于c# - 如何使用套接字流正确分离数据包？ C#，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/37147730/