TcpListener: как прекратить прослушивание при ожидании AcceptTcpClientAsync()

Question

Я не знаю, как правильно закрыть TcpListener, когда асинхронный метод ожидает входящих соединений. Я нашел этот код на SO, здесь код:

public class Server 
{ 
    private TcpListener _Server; 
    private bool _Active; 

    public Server() 
    { 
     _Server = new TcpListener(IPAddress.Any, 5555); 
    } 

    public async void StartListening() 
    { 
     _Active = true; 
     _Server.Start(); 
     await AcceptConnections(); 
    } 

    public void StopListening() 
    { 
     _Active = false; 
     _Server.Stop(); 
    } 

    private async Task AcceptConnections() 
    { 
     while (_Active) 
     { 
      var client = await _Server.AcceptTcpClientAsync(); 
      DoStuffWithClient(client); 
     } 
    } 

    private void DoStuffWithClient(TcpClient client) 
    { 
     // ... 
    } 

} 

И главная:

static void Main(string[] args) 
    { 
     var server = new Server(); 
     server.StartListening(); 

     Thread.Sleep(5000); 

     server.StopListening(); 
     Console.Read(); 
    } 

Исключение бросили на этой линии

 await AcceptConnections(); 

, когда я называю Server.StopListening(), объект удаляется.

Так что мой вопрос в том, как я могу отменить AcceptTcpClientAsync() для правильного закрытия TcpListener.

Answer 1

Хотя существует довольно complicated solution на основе blog post by Stephen Toub, есть гораздо более простое решение с помощью встроенных .NET API:

var cancellation = new CancellationTokenSource(); 
await Task.Run(() => listener.AcceptTcpClientAsync(), cancellation.Token); 

// somewhere in another thread 
cancellation.Cancel(); 

Это решение не будет убивать ожидающий принять вызов. Но другие решения тоже этого не делают, и это решение хотя бы короче.

Update: Более полный пример, который показывает, что должно произойти после того, как отмена сигнализируется:

var cancellation = new CancellationTokenSource(); 
var listener = new TcpListener(IPAddress.Any, 5555); 
listener.Start(); 
try 
{ 
    while (true) 
    { 
     var client = await Task.Run(
      () => listener.AcceptTcpClientAsync(), 
      cancellation.Token); 
     // use the client, pass CancellationToken to other blocking methods too 
    } 
} 
finally 
{ 
    listener.Stop(); 
} 

// somewhere in another thread 
cancellation.Cancel(); 

Answer 2

Работал для меня: Создать локальный фиктивный клиент для подключения к слушателю, а после подключения принимается, просто не выполняйте другой асинхронный прием (используйте активный флаг).

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

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

Это может быть хак, но мне кажется красивее, чем другие варианты здесь :)

Answer 3

Вызов StopListening (который располагает сокет) правильно. Просто проглотите эту конкретную ошибку. Вы не можете этого избежать, так как вам все равно нужно остановить ожидающий вызов. Если вы не пропустите разъем и ожидающий асинхронный ввод-вывод, и порт остается в использовании.

Answer 4

Определить этот метод расширения:

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()); 

Answer 5

Поскольку нет надлежащего рабочего примера здесь, здесь один:

Предполагая, что у вас есть в области как 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; 
    } 
} 

Answer 6

я использовал следующее решение, когда постоянно прослушивание новых клиентов, соединяющие:

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 программирования, так что простите меня, если есть проблема с этим подходом, - я был бы рад видеть, что указали, чтобы узнать от него!