我正在尝试实现一个解决方案，在该解决方案中，服务会为多个 Worker 安排一些工作。调度本身应该通过自定义的基于 tcp 的协议(protocol)进行，因为 Worker 可以在同一台机器或不同的机器上运行。

经过一些研究，我找到了 this邮政。阅读之后，我发现至少有 3 种不同的可能解决方案，每种都有其优点和缺点。

我决定采用 Begin-End 解决方案，并编写了一个小测试程序来试用它。 我的客户端只是一个简单的程序，它向服务器发送一些数据然后退出。 这是客户端代码:

class Client
{
    static void Main(string[] args)
    {
        var ep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 12345);
        var s = new Socket(ep.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
        s.Connect(ep);
        Console.WriteLine("client Startet, socket connected");
        s.Send(Encoding.ASCII.GetBytes("1234"));
        s.Send(Encoding.ASCII.GetBytes("ABCDEFGH"));
        s.Send(Encoding.ASCII.GetBytes("A1B2C3D4E5F6"));
        Console.ReadKey();
        s.Close();
    }
}

按照提供的示例，我的服务器几乎一样简单:

class Program
{
    static void Main(string[] args)
    {
        var server = new BeginEndTcpServer(8, 1, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 12345));
        // var server = new ThreadedTcpServer(8, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 12345));
        //server.ClientConnected += new EventHandler<ClientConnectedEventArgs>(server_ClientConnected);
        server.DataReceived += new EventHandler<DataReceivedEventArgs>(server_DataReceived);
        server.Start();
        Console.WriteLine("Server Started");
        Console.ReadKey();
    }

    static void server_DataReceived(object sender, DataReceivedEventArgs e)
    {
        Console.WriteLine("Receveived Data: " + Encoding.ASCII.GetString(e.Data));
    }
}


using System;
using System.Collections.Generic;
using System.Net; 
using System.Net.Sockets;

namespace TcpServerTest
{
public sealed class BeginEndTcpServer
{
    private class Connection
    {
        public Guid id;
        public byte[] buffer;
        public Socket socket;
    }

    private readonly Dictionary<Guid, Connection> _sockets;
    private Socket _serverSocket;
    private readonly int _bufferSize;
    private readonly int _backlog;
    private readonly IPEndPoint serverEndPoint;

    public BeginEndTcpServer(int bufferSize, int backlog, IPEndPoint endpoint)
    {
        _sockets = new Dictionary<Guid, Connection>();
        serverEndPoint = endpoint;
        _bufferSize = bufferSize;
        _backlog = backlog;
    }

    public bool Start()
    {
        //System.Net.IPHostEntry localhost = System.Net.Dns.GetHostEntry(System.Net.Dns.GetHostName());
        try
        {
            _serverSocket = new Socket(serverEndPoint.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
        }
        catch (System.Net.Sockets.SocketException e)
        {
            throw new ApplicationException("Could not create socket, check to make sure not duplicating port", e);
        }
        try
        {
            _serverSocket.Bind(serverEndPoint);
            _serverSocket.Listen(_backlog);
        }
        catch (Exception e)
        {
            throw new ApplicationException("Error occured while binding socket, check inner exception", e);
        }
        try
        {
            //warning, only call this once, this is a bug in .net 2.0 that breaks if 
            // you're running multiple asynch accepts, this bug may be fixed, but
            // it was a major pain in the ass previously, so make sure there is only one
            //BeginAccept running
            _serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), _serverSocket);
        }
        catch (Exception e)
        {
            throw new ApplicationException("Error occured starting listeners, check inner exception", e);
        }
        return true;
    }

    public void Stop()
    {
        _serverSocket.Close();
        lock (_sockets)
            foreach (var s in _sockets)
                s.Value.socket.Close();
    }

    private void AcceptCallback(IAsyncResult result)
    {
        Connection conn = new Connection();
        try
        {
            //Finish accepting the connection
            System.Net.Sockets.Socket s = (System.Net.Sockets.Socket)result.AsyncState;
            conn = new Connection();
            conn.id = Guid.NewGuid();
            conn.socket = s.EndAccept(result);
            conn.buffer = new byte[_bufferSize];
            lock (_sockets)
                _sockets.Add(conn.id, conn);
            OnClientConnected(conn.id);
            //Queue recieving of data from the connection
            conn.socket.BeginReceive(conn.buffer, 0, conn.buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), conn);
            //Queue the accept of the next incomming connection
            _serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), _serverSocket);
        }
        catch (SocketException)
        {
            if (conn.socket != null)
            {
                conn.socket.Close();
                lock (_sockets)
                    _sockets.Remove(conn.id);
            }
            //Queue the next accept, think this should be here, stop attacks based on killing the waiting listeners
            _serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), _serverSocket);
        }
        catch (Exception)
        {
            if (conn.socket != null)
            {
                conn.socket.Close();
                lock (_sockets)
                    _sockets.Remove(conn.id);
            }
            //Queue the next accept, think this should be here, stop attacks based on killing the waiting listeners
            _serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), _serverSocket);
        }
    }

    private void ReceiveCallback(IAsyncResult result)
    {
        //get our connection from the callback
        Connection conn = (Connection)result.AsyncState;
        //catch any errors, we'd better not have any
        try
        {
            //Grab our buffer and count the number of bytes receives
            int bytesRead = conn.socket.EndReceive(result);
            //make sure we've read something, if we haven't it supposadly means that the client disconnected
            if (bytesRead > 0)
            {
                //put whatever you want to do when you receive data here
                conn.socket.Receive(conn.buffer);
                OnDataReceived(conn.id, (byte[])conn.buffer.Clone());
                //Queue the next receive
                conn.socket.BeginReceive(conn.buffer, 0, conn.buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), conn);
            }
            else
            {
                //Callback run but no data, close the connection
                //supposadly means a disconnect
                //and we still have to close the socket, even though we throw the event later
                conn.socket.Close();
                lock (_sockets)
                    _sockets.Remove(conn.id);
            }
        }
        catch (SocketException)
        {
            //Something went terribly wrong
            //which shouldn't have happened
            if (conn.socket != null)
            {
                conn.socket.Close();
                lock (_sockets)
                    _sockets.Remove(conn.id);
            }
        }
    }

    public bool Send(byte[] message, Guid connectionId)
    {
        Connection conn = null;
        lock (_sockets)
            if (_sockets.ContainsKey(connectionId))
                conn = _sockets[connectionId];
        if (conn != null && conn.socket.Connected)
        {
            lock (conn.socket)
            {
                //we use a blocking mode send, no async on the outgoing
                //since this is primarily a multithreaded application, shouldn't cause problems to send in blocking mode
                conn.socket.Send(message, message.Length, SocketFlags.None);
            }
        }
        else
            return false;
        return true;
    }

    public event EventHandler<ClientConnectedEventArgs> ClientConnected;
    private void OnClientConnected(Guid id)
    {
        if (ClientConnected != null)
            ClientConnected(this, new ClientConnectedEventArgs(id));
    }

    public event EventHandler<DataReceivedEventArgs> DataReceived;
    private void OnDataReceived(Guid id, byte[] data)
    {
        if (DataReceived != null)
            DataReceived(this, new DataReceivedEventArgs(id, data));
    }

    public event EventHandler<ConnectionErrorEventArgs> ConnectionError;

}

public class ClientConnectedEventArgs : EventArgs
{
    private readonly Guid _ConnectionId;
    public Guid ConnectionId { get { return _ConnectionId; } }

    public ClientConnectedEventArgs(Guid id)
    {
        _ConnectionId = id;
    }
}

public class DataReceivedEventArgs : EventArgs
{
    private readonly Guid _ConnectionId;
    public Guid ConnectionId { get { return _ConnectionId; } }

    private readonly byte[] _Data;
    public byte[] Data { get { return _Data; } }

    public DataReceivedEventArgs(Guid id, byte[] data)
    {
        _ConnectionId = id;
        _Data = data;
    }
}

public class ConnectionErrorEventArgs : EventArgs
{
    private readonly Guid _ConnectionId;
    public Guid ConnectionId { get { return _ConnectionId; } }

    private readonly Exception _Error;
    public Exception Error { get { return _Error; } }

    public ConnectionErrorEventArgs(Guid id, Exception ex)
    {
        _ConnectionId = id;
        _Error = ex;
    }
}

我的问题是:服务器只收到一部分数据(在示例中它只收到“EFGHA1B2”)。另外，如果我只发送 4 字节的数据，服务器在连接关闭之前不会收到它。 我错过了什么或做错了什么？

另一件事是，目前我真的对不同的可能性感到困惑，我这样做是不是一个好的解决方案？或者我应该尝试其他方法吗？

如有任何帮助，我们将不胜感激!

最佳答案

我怀疑套接字仅在收到的字节数等于您在调用 BeginReceive 时指定的长度或套接字关闭时才调用您的回调方法。

我认为您需要问自己的问题是您将通过此连接发送的数据的性质是什么。数据是否真的是不间断的字节流，例如文件的内容？如果是这样，那么也许您可以合理地期望客户端发送所有字节，然后立即关闭连接。如您所说，如果客户端关闭连接，则将调用您的回调方法以获取剩余字节。

如果连接将保持打开状态并用于发送单独的消息，那么您可能需要为该通信设计一个简单的协议(protocol)。客户端是否会发送多个任意长的字符串，服务器是否需要分别处理每个字符串？如果是这样，那么一种方法可能是为每个字符串添加一个整数值(假设为 4 个字节)作为前缀，该整数值指示您将发送的字符串的长度。然后您的服务器可以首先调用 BeginReceive 指定 4 个字节的长度，使用这 4 个字节来确定传入字符串的长度，然后调用 Receive 指定传入字符串的长度。如果传入字符串的长度超过缓冲区的大小，那么您也需要处理这种情况。

1. 调用 BeginReceive 等待接收 4 个字节。
2. 根据这 4 个字节计算传入字符串的长度。
3. 调用 Receive 以等待接收到传入字符串的字节。
4. 对下一个字符串重复步骤 1-3。

我已经创建了一个实现这种方法的小型示例服务器和客户端应用程序。我将缓冲区硬编码为 2048 字节，但如果您指定一个小至 4 字节的缓冲区，它仍然有效。

在我的方法中，如果传入数据超过我现有缓冲区的大小，那么我会创建一个单独的字节数组来存储传入数据。这可能不是处理这种情况的最佳方式，但我认为您如何处理这种情况取决于您实际对数据执行的操作。

服务器

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;

namespace SocketServer
{
    class Connection
    {
        public Socket Socket { get; private set; }
        public byte[] Buffer { get; private set; }
        public Encoding Encoding { get; private set; }

        public Connection(Socket socket)
        {
            this.Socket = socket;
            this.Buffer = new byte[2048];
            this.Encoding = Encoding.UTF8;
        }

        public void WaitForNextString(AsyncCallback callback)
        {
            this.Socket.BeginReceive(this.Buffer, 0, 4, SocketFlags.None, callback, this);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Connection connection;
            using (Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
            {
                listener.Bind(new IPEndPoint(IPAddress.Loopback, 6767));
                listener.Listen(1);
                Console.WriteLine("Listening for a connection.  Press any key to end the session.");
                connection = new Connection(listener.Accept());
                Console.WriteLine("Connection established.");
            }

            connection.WaitForNextString(ReceivedString);

            Console.ReadKey();
        }

        static void ReceivedString(IAsyncResult asyncResult)
        {
            Connection connection = (Connection)asyncResult.AsyncState;

            int bytesReceived = connection.Socket.EndReceive(asyncResult);

            if (bytesReceived > 0)
            {
                int length = BitConverter.ToInt32(connection.Buffer, 0);

                byte[] buffer;
                if (length > connection.Buffer.Length)
                    buffer = new byte[length];
                else
                    buffer = connection.Buffer;

                int index = 0;
                int remainingLength = length;
                do
                {
                    bytesReceived = connection.Socket.Receive(buffer, index, remainingLength, SocketFlags.None);
                    index += bytesReceived;
                    remainingLength -= bytesReceived;
                }
                while (bytesReceived > 0 && remainingLength > 0);

                if (remainingLength > 0)
                {
                    Console.WriteLine("Connection was closed before entire string could be received");
                }
                else
                {
                    Console.WriteLine(connection.Encoding.GetString(buffer, 0, length));
                }

                connection.WaitForNextString(ReceivedString);
            }
        }
    }
}

客户端

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;

namespace SocketClient
{
    class Program
    {
        static void Main(string[] args)
        {
            var encoding = Encoding.UTF8;
            using (var connector = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
            {
                connector.Connect(new IPEndPoint(IPAddress.Loopback, 6767));

                string value;

                value = "1234";
                Console.WriteLine("Press any key to send \"" + value + "\".");
                Console.ReadKey();
                SendString(connector, encoding, value);

                value = "ABCDEFGH";
                Console.WriteLine("Press any key to send \"" + value + "\".");
                Console.ReadKey();
                SendString(connector, encoding, value);

                value = "A1B2C3D4E5F6";
                Console.WriteLine("Press any key to send \"" + value + "\".");
                Console.ReadKey();
                SendString(connector, encoding, value);

                Console.WriteLine("Press any key to exit.");
                Console.ReadKey();

                connector.Close();
            }
        }

        static void SendString(Socket socket, Encoding encoding, string value)
        {
            socket.Send(BitConverter.GetBytes(encoding.GetByteCount(value)));
            socket.Send(encoding.GetBytes(value));
        }
    }
}

关于c# - 在 C# 中做正确和快速的 TCP 网络，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/8082788/