Smaltimento impostando su null?

Question

Sono a conoscenza della tecnica per gestire IDisposable in modo tradizionale. Di ', in OnStop() di servizio di Windows chiudo messaggio coda di cliente:

 if (client != null) 
     { 
      client.Dispose(); 
     } 

Per la prima volta oggi ho visto un ragazzo a farlo in questo modo:

 using (client) 
     { 
      client = null; 
     } 

che cosa è esattamente accadendo all'interno del suo "usare" o ha a disposizione correttamente?

Answer 1

Il codice del collega using funzionerà, ma è discutibilmente eccessivo;

using(client) { 
    client = null; 
} 

è essenzialmente:

{ // scope here to denote that 'tmp' is not defined outside this scope 
    var tmp = client; 
    try { 
     client = null; 
    } finally { 
     if(tmp != null) tmp.Dispose(); 
    } 
} 

(non del tutto che in tutti i casi, in quanto vi sono di valore tipi e implementazione dell'interfaccia esplicita a cui pensare).

Personalmente, dovrei semplicemente usare using per l'intera cosa, ove possibile (cioè nel codice che inizialmente alloca il client).

Una volta potrei usare questo è un pigro:

using(client as IDisposable) { client = null; } // dispose if needed 

cioè client è qualcosa al di fuori del mio controllo, e non sono sicuro se implementa IDisposable o no, ma se lo fa, ho bisogno di rilascialo.

Answer 2

Uscendo dal

using (client) 
{ 
} 

client.Dispose() si chiama automaticamente per voi.
client = null dovrebbe essere chiamato da quel codice a mio parere.
Ricordare che per utilizzare using(object) l'oggetto deve implementare l'interfaccia IDisposable.

Answer 3

L'istruzione using(){} prende una copia della variabile di riferimento in modo che questa assegnazione con null non sia efficace.

Answer 4

Per me non sembra affatto efficace. Poiché il client è impostato su null, l'utilizzo non ha più nulla a cui fare riferimento, anche se l'oggetto reale è ancora in memoria, semplicemente non referenziato da alcuna variabile (sarà più tardi raccolto, ma qual è il punto di utilizzo?).

Answer 5

Se l'ambito del "client" si estende al di fuori del blocco "using", come sembrerebbe, il codice come scritto garantirà che il "client" venga eliminato prima che il controllo lasci il blocco "using" e il riferimento a l'oggetto "client" appena defunto sarà distrutto. Annullare il riferimento ad esso può essere importante se si tratta di un campo, e potrebbe essere fondamentale se si tratta di una proprietà che allega eventi.

La mia ipotesi sarebbe che "client" è un campo o una proprietà e che l'autore del codice "using" pensava che fosse più conciso della versione data da Marc Gravell. Concederei all'autore che il codice è conciso, ma suggerirei che sarebbe ancora più conciso e più chiaro definire una routine generica "Zap" che accetta un identificativo mediante il riferimento, utilizza Interlocked.Exchange per leggerlo e annullarlo e lo smaltisce se non fosse nullo.In tal caso, la dichiarazione "utilizzando" sarebbe sostituito con:

 
    Zap(ref client); 

che ha il vantaggio di essere più conciso, mentre quasi certamente di essere più chiaro.