Come impostare il timeout per un TcpClient?

Question

Ho un TcpClient che uso per inviare dati a un listener su un computer remoto. Il computer remoto a volte si accende e talvolta si spegne. Per questo motivo, TcpClient non riesce a connettersi spesso. Voglio che il TcpClient scada dopo un secondo, quindi non ci vuole molto tempo quando non riesce a connettersi al computer remoto. Attualmente, utilizzo questo codice per TcpClient:

try 
{ 
    TcpClient client = new TcpClient("remotehost", this.Port); 
    client.SendTimeout = 1000; 

    Byte[] data = System.Text.Encoding.Unicode.GetBytes(this.Message); 
    NetworkStream stream = client.GetStream(); 
    stream.Write(data, 0, data.Length); 
    data = new Byte[512]; 
    Int32 bytes = stream.Read(data, 0, data.Length); 
    this.Response = System.Text.Encoding.Unicode.GetString(data, 0, bytes); 

    stream.Close(); 
    client.Close();  

    FireSentEvent(); //Notifies of success 
} 
catch (Exception ex) 
{ 
    FireFailedEvent(ex); //Notifies of failure 
} 

Questo funziona abbastanza bene per la gestione del compito. Lo invia se possibile e rileva l'eccezione se non riesce a connettersi al computer remoto. Tuttavia, quando non riesce a connettersi, occorrono da dieci a quindici secondi per generare un'eccezione. Ho bisogno che scada tra un secondo circa? Come cambierei il time out?

Answer 1

È necessario utilizzare il metodo asincrono BeginConnect di TcpClient invece di tentare di connettersi in modo sincrono, ovvero ciò che fa il costruttore. Qualcosa di simile a questo:

var client = new TcpClient(); 
var result = client.BeginConnect("remotehost", this.Port, null, null); 

var success = result.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(1)); 

if (!success) 
{ 
    throw new Exception("Failed to connect."); 
} 

// we have connected 
client.EndConnect(result); 

Answer 2

Una cosa da prendere nota di è che è possibile per la chiamata BeginConnect a fallire prima del timeout. Questo può accadere se stai tentando una connessione locale. Ecco una versione modificata del codice di Jon ...

 var client = new TcpClient(); 
     var result = client.BeginConnect("remotehost", Port, null, null); 

     result.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(1)); 
     if (!client.Connected) 
     { 
      throw new Exception("Failed to connect."); 
     } 

     // we have connected 
     client.EndConnect(result); 

Answer 3

Le risposte di cui sopra non riguardano come gestire in modo pulito una connessione scaduta. Chiamando TcpClient.EndConnect, chiudendo una connessione che riesce ma dopo il timeout e eliminando TcpClient.

Potrebbe essere eccessivo ma questo funziona per me.

private class State 
    { 
     public TcpClient Client { get; set; } 
     public bool Success { get; set; } 
    } 

    public TcpClient Connect(string hostName, int port, int timeout) 
    { 
     var client = new TcpClient(); 

     //when the connection completes before the timeout it will cause a race 
     //we want EndConnect to always treat the connection as successful if it wins 
     var state = new State { Client = client, Success = true }; 

     IAsyncResult ar = client.BeginConnect(hostName, port, EndConnect, state); 
     state.Success = ar.AsyncWaitHandle.WaitOne(timeout, false); 

     if (!state.Success || !client.Connected) 
      throw new Exception("Failed to connect."); 

     return client; 
    } 

    void EndConnect(IAsyncResult ar) 
    { 
     var state = (State)ar.AsyncState; 
     TcpClient client = state.Client; 

     try 
     { 
      client.EndConnect(ar); 
     } 
     catch { } 

     if (client.Connected && state.Success) 
      return; 

     client.Close(); 
    } 

Answer 4

partire con .NET 4.5, TcpClient ha un metodo fresco ConnectAsync che possiamo usare in questo modo, quindi è ora abbastanza facile:

var client = new TcpClient(); 
if (!client.ConnectAsync("remotehost", remotePort).Wait(1000)) 
{ 
    // connection failure 
} 

Answer 5

Un'altra alternativa utilizzando https://stackoverflow.com/a/25684549/3975786:

var timeOut = TimeSpan.FromSeconds(5);  
var cancellationCompletionSource = new TaskCompletionSource<bool>(); 
try 
{ 
    using (var cts = new CancellationTokenSource(timeOut)) 
    { 
     using (var client = new TcpClient()) 
     { 
      var task = client.ConnectAsync(hostUri, portNumber); 

      using (cts.Token.Register(() => cancellationCompletionSource.TrySetResult(true))) 
      { 
       if (task != await Task.WhenAny(task, cancellationCompletionSource.Task)) 
       { 
        throw new OperationCanceledException(cts.Token); 
       } 
      } 

      ... 

     } 
    } 
} 
catch(OperationCanceledException) 
{ 
    ... 
} 

Answer 6

Imposta la proprietà ReadTimeout o WriteTimeout su NetworkStream per letture/scritture sincrone. Codice Aggiornamento del PO:

try 
{ 
    TcpClient client = new TcpClient("remotehost", this.Port); 
    Byte[] data = System.Text.Encoding.Unicode.GetBytes(this.Message); 
    NetworkStream stream = client.GetStream(); 
    stream.WriteTimeout = 1000; // <------- 1 second timeout 
    stream.ReadTimeout = 1000; // <------- 1 second timeout 
    stream.Write(data, 0, data.Length); 
    data = new Byte[512]; 
    Int32 bytes = stream.Read(data, 0, data.Length); 
    this.Response = System.Text.Encoding.Unicode.GetString(data, 0, bytes); 

    stream.Close(); 
    client.Close();  

    FireSentEvent(); //Notifies of success 
} 
catch (Exception ex) 
{ 
    // Throws IOException on stream read/write timeout 
    FireFailedEvent(ex); //Notifies of failure 
} 

Answer 7

Ecco un miglioramento codice basato su mcandal soluzione. Aggiunto eccezione cattura alcuna eccezione generata dal compito client.ConnectAsync (es: SocketException quando il server non è raggiungibile)

var timeOut = TimeSpan.FromSeconds(5);  
var cancellationCompletionSource = new TaskCompletionSource<bool>(); 

try 
{ 
    using (var cts = new CancellationTokenSource(timeOut)) 
    { 
     using (var client = new TcpClient()) 
     { 
      var task = client.ConnectAsync(hostUri, portNumber); 

      using (cts.Token.Register(() => cancellationCompletionSource.TrySetResult(true))) 
      { 
       if (task != await Task.WhenAny(task, cancellationCompletionSource.Task)) 
       { 
        throw new OperationCanceledException(cts.Token); 
       } 

       // throw exception inside 'task' (if any) 
       if (task.Exception?.InnerException != null) 
       { 
        throw task.Exception.InnerException; 
       } 
      } 

      ... 

     } 
    } 
} 
catch (OperationCanceledException operationCanceledEx) 
{ 
    // connection timeout 
    ... 
} 
catch (SocketException socketEx) 
{ 
    ... 
} 
catch (Exception ex) 
{ 
    ... 
}