为什么 Socket.AcceptAsync 没有触发 SocketAsyncEventArgs Completed 事件？

Question

我正在开发一个服务器应用程序，它将接收消息并做出响应。没有什么新东西。所以，实际上我正在关注this answer 和this post，但我无法让AcceptAsync() 方法触发Completed 事件。在互联网上到处搜索，尝试了类似问题的解决方案，但似乎没有什么对我有用。

我也尝试从Task.Run() 拨打server.Start()，但没有成功。我知道服务器正在监听，因为我可以在 netstat -an 上看到它，如果我在 Listen() 之后中断，我也可以使用 telnet 连接。

据我了解，如果 AcceptAsync() 方法返回 true，它将引发 SocketAsyncEventArgs.Completed 事件，该事件又会再次调用 StartAccept() 方法并循环直到我强制退出。

SocketAsyncEventArgs.Completed 也是正确的：http://prntscr.com/8l3x8p，但仍然不起作用。

这是我的一段代码：

public class TTSServer
{
    private Socket m_serverSocket;
    private IPEndPoint m_serverEndPoint;

    [DefaultValue(39454)]
    public int Port { get; set; }
    [DefaultValue(100)]
    public int IncommingQueueSize { get; set; }
    [DefaultValue(512)]
    public int BufferSize { get; set; }

    //Listeners to hold event when something happens.

    public static void Main(string[] args)
    {
        TTSServer server = new TTSServer(39454, 100, 512);
        server.Start();
    }

    public TTSServer(int port, int queueSize, int bufferSize)
    {
        Port = port;
        IncommingQueueSize = queueSize;
        BufferSize = bufferSize;
    }


    public void Start()
    {
        Console.WriteLine("Starting TTS Server (Port: {0}, QueueSize: {1}, BufferSize: {2})", Port, IncommingQueueSize, BufferSize);
        m_serverEndPoint = new IPEndPoint(IPAddress.Any, Port);
        m_serverSocket = new Socket(m_serverEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
        Console.WriteLine("Binding ({0})", m_serverEndPoint.ToString());
        m_serverSocket.Bind(m_serverEndPoint);
        Console.WriteLine("Listening");
        m_serverSocket.Listen(IncommingQueueSize);

        StartAccept(null);
    }

    public void Stop()
    {

    }

    /// <summary>
    /// Receive a incomming connection attemp in an asynchronous way.
    /// </summary>
    /// <param name="socketEvent">If is null, a new object is created, else, it'll be used for cache friendly reason.</param>
    private void StartAccept(SocketAsyncEventArgs socketEvent)
    {
        //If received reference points to null, let's create a new object.
        if (socketEvent == null)
        {
            Console.WriteLine("Accepting new connections...");
            socketEvent = new SocketAsyncEventArgs();
            socketEvent.Completed += AcceptCompleted; //Add a callback on completed accept incomming connections attemp.
        }
        else
        {
            //Clear current incomming connection socket, so object may be reused.
            socketEvent.AcceptSocket = null;
        }

        //If there is an incomming connection pending(pooled), this method will receive the connection in a async way (witch returns true) 
        //and will call SocketAsyncEventArgs.Completed callback when done. 
        //Else, it waits for a new connection, returns false, and don't won't SocketAsyncEventArgs.Completed callback when done, so we have to 
        //call it manually.
        bool async = true;

        //When I debug this code, async receive true from AcceptAsync.
        async = m_serverSocket.AcceptAsync(socketEvent);

        if (!async)
        {
            AcceptCompleted(this, socketEvent);
        }
    }

    /// <summary>
    /// Handles a incomming connection after it's fully received. This function will do the business logic for incomming connections and prepare
    /// to receive data.
    /// </summary>
    /// <param name="sender">Object who posted this function</param>
    /// <param name="socketEvent">Information of the incomming connection</param>
    private void AcceptCompleted(object sender, SocketAsyncEventArgs socketEvent)
    {
        Connection connection = new Connection(this, socketEvent.AcceptSocket, BufferSize);

        SocketAsyncEventArgs connectedSocketEvent = new SocketAsyncEventArgs();
        connectedSocketEvent.UserToken = connection;

        //Add a receive callback, to be called whenever the Receive function is finished.
        connectedSocketEvent.Completed += FlushBuffer;
        ReceiveData(connectedSocketEvent);

        //Accept next incomming connection.
        StartAccept(socketEvent);
    }

不知道为什么，AcceptCompleted 永远不会被触发，即使 AcceptAsync() 方法返回 true。

Answer 1

似乎根本原因是默认缓冲：

可选地，可以提供一个缓冲区，在ConnectAsync 方法成功后，在该缓冲区中接收套接字上的初始数据块。在这种情况下，SocketAsyncEventArgs.Buffer 属性需要设置为包含要接收数据的缓冲区，SocketAsyncEventArgs.Count 属性需要设置为缓冲区中要接收的最大数据字节数。可以使用SocketAsyncEventArgs.SetBuffer 方法设置这些属性。传入的部分缓冲区将在内部使用，以供底层 Winsock AcceptEx 调用使用。这意味着返回的数据量将始终小于提供的System.Net.Sockets.SocketAsyncEventArgs 实例上的SocketAsyncEventArgs.Count 属性的值。内部使用的缓冲区数量根据套接字的地址族而有所不同。所需的最小缓冲区大小为 288 字节。如果指定了更大的缓冲区大小，则Socket 将期待一些额外的数据，而不是 Winsock AcceptEx 调用接收到的地址数据，并将等待直到接收到这些额外的数据。如果发生超时，则重置连接。因此，如果需要特定数量的额外数据，则应将缓冲区大小设置为最小缓冲区大小加上此数量。

——Socket.AcceptAsync Method (SocketAsyncEventArgs), MSDN.

假设不需要缓冲，禁用缓冲seems to be a solution：

SocketAsyncEventArgs args = ...;
args.SetBuffer(null, 0, 0);

Answer 2

编辑：在您的示例中，在 server.Start 之后放置一行代码。

一时兴起，您会考虑更改一行。

改一下

socketEvent.Completed += AcceptCompleted; //Add a callback on completed accept incomming connections attemp. 

到这里

socketEvent.Completed += new EventHandler<SocketAsyncEventArgs>(AcceptCompleted); //Add a callback on completed accept incomming connections attemp.