Question

因此，通过我的软件，我在网络上发送了一个发现广播，接收该广播的每个“客户端”都将通过TCP连接到我。我拥有的东西似乎工作“好”，但我觉得必须有一个更好的方法。我所看到的是，我的软件中的某些TCP连接被拒绝（我认为）因为我正在接受另一个套接字。因此，对于我当前的版本，我可以在80％的时间内接受套接字。有时更多，但通常在80％左右。其余的都被我的软件拒绝，我不知道为什么。对我来说这是不可接受的，但我很难改善这个数字。

这是我用来接受TCP客户端的类，并通知我的另一个类关于已连接的新套接字：

public class AsynchronousSocketListener
{
    // Thread signal.
    public ManualResetEvent allDone = new ManualResetEvent(false);
    public event EventHandler<ErtdRawDataArgs> ClientConnected;

    private string bindingIp;
    public string AddressBind 
    {
        get { return this.bindingIp; } 
        private set { this.bindingIp = value; } 
    }

    private int port;
    public int Port
    {
        get { return this.port; }
        private set { this.port = value; }
    }

    private Socket listener;

    public AsynchronousSocketListener(string bindingIp, int port) 
    {
        this.bindingIp = bindingIp;
        this.port = port;
    }

    protected void OnClientConnected(string data, IPEndPoint clientEP)
    {
        if (this.ClientConnected == null)
            return;

        Task.Factory.StartNew(() =>
        {
            //build args
            ErtdRawDataArgs args = new ErtdRawDataArgs(Encoding.Default.GetBytes(data));
            args.Source = string.Format("{0}:{1}", clientEP.Address.ToString(), clientEP.Port);
            this.ClientConnected(this, args);
        });
    }

    public void Close()
    {
        if (this.listener == null || !this.listener.Connected)
            return;

        this.listener.Shutdown(SocketShutdown.Both);
        this.listener.Close();
    }

    public void StartListening() 
    {
        Task.Factory.StartNew(() =>
        {
            // Data buffer for incoming data.
            byte[] bytes = new Byte[1024];

            // Establish the local endpoint for the socket.
            IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Parse(this.bindingIp), this.port);

            // Create a TCP/IP socket.
            listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            // Bind the socket to the local endpoint and listen for incoming connections.
            try
            {
                listener.Bind(localEndPoint);
                int maxConnections = (int)SocketOptionName.MaxConnections;
                listener.Listen(maxConnections);

                while (true)
                {
                    // Set the event to nonsignaled state.
                    allDone.Reset();

                    // Start an asynchronous socket to listen for connections.
                    listener.BeginAccept(
                        new AsyncCallback(AcceptCallback),
                        listener);

                    // Wait until a connection is made before continuing.
                    allDone.WaitOne();
                }

            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        });
    }

    public void AcceptCallback(IAsyncResult ar) 
    {
        // Signal the main thread to continue.
        allDone.Set();

        // Get the socket that handles the client request.
        Socket listener = (Socket) ar.AsyncState;
        Socket handler = listener.EndAccept(ar);

        // Create the state object.
        StateObject state = new StateObject();
        state.workSocket = handler;
        handler.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0,
            new AsyncCallback(ReadCallback), state);
    }

    public void ReadCallback(IAsyncResult ar) 
    {
        String content = String.Empty;

        // Retrieve the state object and the handler socket
        // from the asynchronous state object.
        StateObject state = (StateObject) ar.AsyncState;
        Socket handler = state.workSocket;

        // Read data from the client socket. 
        int bytesRead = handler.EndReceive(ar);

        if (bytesRead > 0) {
            // There  might be more data, so store the data received so far.
            state.sb.Append(Encoding.ASCII.GetString(
                state.buffer,0,bytesRead));

            // Check for end-of-file tag. If it is not there, read 
            // more data.
            content = state.sb.ToString();
            OnClientConnected(content, handler.RemoteEndPoint as IPEndPoint);

            //close socket
            handler.Shutdown(SocketShutdown.Both);
            handler.Close();
        }
    }
}

有没有办法改进这个代码，或者是否有一些完全不同的东西可以改善我几乎同时接受TCP连接的结果？

Answer 1

~~嗯，从接受连接到连接“接通”之间有一段时间，然后才能接受另一个连接。使用等待句柄之类的东西可能相当慢。~~

重新阅读您的代码后，从概念上讲，您可以接受另一个连接的时间点是您调用EndAccept时。您可以在致电EndAccept之前设置事件，这意味着可以在BeginAccept之前调用EndAccept，并且可以在之前的EndAccept之前接受另一个连接调用。我不知道这是否是一个问题 - 据我所知，这是合法的。但是，您可以简化代码以避免事件，并在当前接受期间简单地链接下一个BeginAccept，并确保在下一个EndAccept ~~之前调用BeginAccept~~

< S>

~~我所做的是从当前接受中链接下一个接受。~~ 例如：

listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
listener.Bind(new IPEndPoint(IPAddress.Any, 62000));
listener.Listen(1000);
listener.BeginAccept(OnAccept, listener);

private void OnAccept(IAsyncResult ar)
{
    Socket listener = (Socket)ar.AsyncState;
    Socket socket = listener.EndAccept(ar);
    listener.BeginAccept(OnAccept, listener);
    socket.BeginReceive(new byte[10], 0, 10, 0, (arReceive) => socket.EndReceive(arReceive), null);
}

当然，我在这里使用BeginAcceptSocket;但概念与BeginAccept ...

相同

这使您无需启动新的Task，从而创建等待句柄的速度大约是lock的50倍，因为它们是跨进程的 ~~- 从而释放了你从接受~~之间的“巨大”暂停。

允许数百个TCP客户端在一两秒内连接

1 个答案: