问题 TcpListener：如何在等待AcceptTcpClientAsync（）时停止侦听？

定义此扩展方法：

public static class Extensions
{
    public static async Task<TcpClient> AcceptTcpClientAsync(this TcpListener listener, CancellationToken token)
    {
        try
        {
            return await listener.AcceptTcpClientAsync();
        }
        catch (Exception ex) when (token.IsCancellationRequested) 
        { 
            throw new OperationCanceledException("Cancellation was requested while awaiting TCP client connection.", ex);
        }
    }
}

在使用扩展方法接受客户端连接之前，请执行以下操作：

token.Register(() => listener.Stop());

由于这里没有正确的工作示例，这里有一个：

假设你有两个范围 cancellationToken 和 tcpListener，那么你可以做到以下几点：

using (cancellationToken.Register(() => tcpListener.Stop()))
{
    try
    {
        var tcpClient = await tcpListener.AcceptTcpClientAsync();
        // … carry on …
    }
    catch (InvalidOperationException)
    {
        // Either tcpListener.Start wasn't called (a bug!)
        // or the CancellationToken was cancelled before
        // we started accepting (giving an InvalidOperationException),
        // or the CancellationToken was cancelled after
        // we started accepting (giving an ObjectDisposedException).
        //
        // In the latter two cases we should surface the cancellation
        // exception, or otherwise rethrow the original exception.
        cancellationToken.ThrowIfCancellationRequested();
        throw;
    }
}

为我工作： 创建一个本地虚拟客户端以连接到侦听器，并在接受连接后，不要再执行另一个异步接受（使用活动标志）。

// This is so the accept callback knows to not 
_Active = false;

TcpClient dummyClient = new TcpClient();
dummyClient.Connect(m_listener.LocalEndpoint as IPEndPoint);
dummyClient.Close();

这可能是一个黑客，但它似乎比其他选项更漂亮:)

调用 StopListening （配置插座）是正确的。只是吞下那个特别的错误。你无法避免这种情况，因为无论如何你都需要停止待处理的呼叫。如果没有，则泄漏套接字并且挂起的异步IO和端口保持使用状态。

在不断收听新的连接客户端时，我使用了以下解决方案：

public async Task ListenAsync(IPEndPoint endPoint, CancellationToken cancellationToken)
{
    TcpListener listener = new TcpListener(endPoint);
    listener.Start();

    // Stop() typically makes AcceptSocketAsync() throw an ObjectDisposedException.
    cancellationToken.Register(() => listener.Stop());

    // Continually listen for new clients connecting.
    try
    {
        while (true)
        {
            cancellationToken.ThrowIfCancellationRequested();
            Socket clientSocket = await listener.AcceptSocketAsync();
        }
    }
    catch (OperationCanceledException) { throw; }
    catch (Exception) { cancellationToken.ThrowIfCancellationRequested(); }
}

• 我注册了一个回叫来打电话 Stop() 在...上 TcpListener 实例的时候 CancellationToken 被取消了。
• AcceptSocketAsync 通常会立即抛出一个 ObjectDisposedException 然后。
• 我抓住了 Exception 以外 OperationCanceledException 虽然要“理智” OperationCanceledException 到外面的来电者。

我很新 async 编程，对不起，如果这个方法有问题 - 我很高兴看到它指出要从中学习！

取消令牌有一个委托，您可以使用该委托来停止服务器。当服务器停止时，任何侦听连接调用都将引发套接字异常。

请参阅以下代码：

public class TcpListenerWrapper
{
    // helper class would not be necessary if base.Active was public, c'mon Microsoft...
    private class TcpListenerActive : TcpListener, IDisposable
    {
        public TcpListenerActive(IPEndPoint localEP) : base(localEP) {}
        public TcpListenerActive(IPAddress localaddr, int port) : base(localaddr, port) {}
        public void Dispose() { Stop(); }
        public new bool Active => base.Active;
    }

    private TcpListenerActive server

    public async Task StartAsync(int port, CancellationToken token)
    {
        if (server != null)
        {
            server.Stop();
        }

        server = new TcpListenerActive(IPAddress.Any, port);
        server.Start(maxConnectionCount);
        token.Register(() => server.Stop());
        while (server.Active)
        {
            try
            {
                await ProcessConnection();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
        }
    }

    private async Task ProcessConnection()
    {
        using (TcpClient client = await server.AcceptTcpClientAsync())
        {
            // handle connection
        }
    }
}