Question

我正在尝试在客户端之间发送数据，当通过tcp发送数据时，它是一个流而不是“一个发送就是一个接收”功能。因此，我为networkstream写了一个小包装。它有效，但是我缺少什么吗？这是解决我的问题的正确方法吗？

我的网络知识不是很好。

（我的异步知识也非常有限，这是第一次使用它，因此，如果有任何问题，请告诉我。）

为了完整起见，我还包括了我的测试代码：

主要：

    static void Main(string[] args)
    {
        Console.WriteLine("Hello World!");

        HandlerServer();
        HandleClients();

        while (true)
            Thread.Sleep(100);
    }

处理函数：

    private static async void HandleClients()
    {
        using (TcpClient client = new TcpClient())
        {
            await client.ConnectAsync(IPAddress.Parse("127.0.0.1"), 8888);
            using (TcpMessageStream stream = new TcpMessageStream(client))
            {
                while (true)
                    await stream.SendAsync(Encoding.ASCII.GetBytes(Console.ReadLine()));
            }
        }
    }

    private async static void HandlerServer()
    {
        TcpListener server = new TcpListener(IPAddress.Any, 8888);

        server.Start();

        using (TcpClient cl = await server.AcceptTcpClientAsync())
        using (TcpMessageStream stream = new TcpMessageStream(cl))
        {
            Console.WriteLine("Client connected!!");
            while (true)
                Console.WriteLine("Received: " + Encoding.ASCII.GetString(await stream.ReceiveAsync()));
        }
    }

创建的类：

class TcpMessageStream : IDisposable
{
    NetworkStream _stream;
    public TcpMessageStream(TcpClient tcpClient)
    {
        _stream = tcpClient.GetStream();
    }

    public async Task SendAsync(byte[] data)
    {
        byte[] prefix = BitConverter.GetBytes(data.LongLength);
        await _stream.WriteAsync(prefix);
        await _stream.WriteAsync(data);
    }

    public async Task<byte[]> ReceiveAsync()
    {
        byte[] buffer = new byte[8];
        int bytesRead = 0;
        do
        {
            bytesRead += await _stream.ReadAsync(buffer, bytesRead, 8 - bytesRead);

        } while (bytesRead < 8);

        var dataLength = BitConverter.ToInt64(buffer);

        byte[] messageBuffer = new byte[dataLength];

        bytesRead = 0;
        do
        {
            bytesRead += await _stream.ReadAsync(messageBuffer, bytesRead, messageBuffer.Length - bytesRead);

        } while (bytesRead < messageBuffer.Length);

        return messageBuffer;
    }

    private bool disposed = false;

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                // Dispose managed resources.
                _stream.Dispose();
            }

            // Clean up unmanaged resources here.
            disposed = true;
        }
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    ~TcpMessageStream()
    {
        Dispose(false);
    }
}

Answer 1

通常，这是个好主意。您已经创建了一个简单的协议，该协议在数据之前写入一个长度前缀，以便您知道要读取多少。这是非常常见，简单而有效的。

您可以简化很多代码。 BinaryReader具有读取和写入整数和字节数组的方法。您可以读取确切大小的字节数组。 BinaryReader为您进行循环。

如果您不希望出于教育目的使用BinaryReader，请使自己成为一个读取确切字节数的辅助函数。

我将TcpMessageStream基于Stream，而不是TcpClient。这使它更通用。

异步用法是正确的。

您使用的处置模式在这里没有用。终结器不执行任何操作，并且永远不会有任何继承者。不需要此布尔disposed标志。编写一个正常的void Dispose()方法，该方法可以完成所需的工作。

总而言之，这是一项非常出色的工作。联网代码非常困难。

如果这是真实应用程序的一部分，请考虑完全不编写自己的网络协议。尝试使用HTTP或websockets。在抽象堆栈中尽可能高。

通过TCP网络发送数据包

1 个答案: