TcpClient.EndConnect genera NullReferenceException quando il socket è chiuso

Question

Sto provando a connettermi al mio server con una combinazione TcpClient.BeginConnect/TcpClient.EndConnect. Tuttavia, alcune cose non funzionano come dovrebbero.

Lo scenario è il seguente:

• Chiama per il TcpClient.BeginConnect
• Server è volutamente non in linea (a scopo di test) - quindi nessun collegamento può essere fatto.
• Chiudo l'applicazione (client.Close() viene chiamato nel processo che closes the socket which in turn stops the async operation)
• TcpClient connessione metodo di callback accade dando IAsyncResult
• chiamata al metodo TcpClient.EndConnect con il dato IAsyncResult
• NullReferenceException avviene su EndConnect (?)
• Poiché l'ultimo modulo (finestra) è stato chiuso, l'app dovrebbe uscire, tuttavia non t, almeno non fino al completamento dell'operazione BeginConnect (il che è strano, poiché la richiamata è già stata richiamata).

Quello che succede qui è che un NullReferenceException e 'colto. Come puoi vedere dall'immagine sopra, né client né ar sono null. Il problema è che il MSDN documentation for the EndConnect non menziona il caso in cui viene generata questa eccezione.

Quindi, in pratica, non ho idea di cosa stia succedendo. Il problema è che sono costretto ad aspettare che l'app si chiuda (come se l'operazione di connessione fosse ancora in attesa di un timeout). Se un server è online, collega e scollega semplicemente.

CosaNullReferenceExceptionin questo contesto significa? Come evitare l'operazione BeginConnect per bloccare la chiusura dell'applicazione nel caso in cui la connessione non possa essere stabilita?

---

Note aggiuntive (richiesto in commenti):

Ecco il codice per creare il client (client è una variabile membro:

public void Connect() 
{ 
    try 
    { 
     lock (connectionAccess) 
     { 
      if (State.IsConnectable()) 
      { 
       // Create a client 
       client = new TcpClient(); 
       client.LingerState = new LingerOption(false, 0); 
       client.NoDelay = true; 

       State = CommunicationState.Connecting; 

       client.BeginConnect(address, port, onTcpClientConnectionEstablished, null); 
      } 
      else 
      { 
       // Ignore connecting request if a connection is in a state that is not connectable 
      } 
     } 
    } 
    catch 
    { 
     Close(true); 
    } 
} 

anche il metodo close:

public void Close(bool causedByError) 
{ 
    lock (connectionAccess) 
    { 
     // Close the stream 
     if (clientStream != null) 
      clientStream.Close(); 

     // Close the gateway 
     if (client != null) 
      client.Close(); 

     // Empty the mailboxes 
     incomingMailbox.Clear(); 
     outgoingMailbox.Clear(); 

     State = causedByError ? CommunicationState.CommunicationError : CommunicationState.Disconnected; 
    } 
} 

Answer 1

Ho avuto un errore simile e ho finito per usare questo codice. Non sono sicuro se verrà conservato con l'interfaccia IASyncResult, ma potrebbe esserci un modo simile per eseguire questo controllo. Mi accorgo che il tuo ar.AsyncState == null, quindi forse prova ad iniziare da lì, cioè è nullo quando ti connetti correttamente?

private void connConnectCompleted(AsyncCompletedEventArgs e) 
{ 
    if (e.Error != null) 
    { 
     // Something didn't work...abort captain 
     CloseSocket(); 
     Console.WriteLine(this.GetType().ToString() + @":Error connecting socket:" + e.Error.Message); 
     return; 
    } 
    // Do stuff with your connection 
} 

EDIT: Scusate, non mi rendevo conto io non postare quello che ha generato i miei AsyncCompletedEventArgs, che è più legata a quello che stai facendo. Vedrai il motivo per cui mi stavo chiedendo di ar.AsyncState è nullo.

private void OnConnect(IAsyncResult asyncResult) 
{ 
    if (OnConnectCompleted == null) return; // Check whether something is using this wrapper 
    AsyncCompletedEventArgs args; 
    try 
    { 
     Socket outSocket = (Socket) asyncResult.AsyncState; 

     // Complete connection 
     outSocket.EndConnect(asyncResult); 

     args = new AsyncCompletedEventArgs(null); 
     OnConnectCompleted(this, args); 
    } 
    catch (Exception e) 
    { 
     args = new AsyncCompletedEventArgs(e.Message); 
     OnConnectCompleted(this, args); 
    } 
} 

Answer 2

Il NullReferenceException è probabilmente dovuto al TcpClient.Client essere null.

Se si dovesse seguire la MSDN Example per TcpClient.BeginConnect e passare l'oggetto TcpClient come oggetto Stato:

private void onConnEst(IAsyncResult ar) 
{ 
     try 
     { 
      TcpClient client = (TcpClient)ar.AsyncState; 
      if(client!=null && client.Client!=null) 
      { 
       client.EndConnect(ar); 
      } 
     } 
     catch(Exception ex){...} 
} 

Questo dovrebbe gestire il caso in cui Close() viene chiamato prima della richiamata.

Tornando al tuo problema, quanto tempo ci vuole per chiudere l'applicazione?

Answer 3

Questo ovviamente un bug all'interno della classe TcpClient. Anch'io l'ho affrontato. TcpClient.Dispose può impostare il campo Client su null ma EndConnect non lo prevede.

Answer 4

Questo è a know bug.

Si dovrebbe ricevere "ObjectDisposedException" anziché "NullReferenceException".