Qual è la relazione tra la parola chiave using e l’interfaccia IDisposable?

Se sto usando la parola chiave using , devo ancora implementare IDisposable ?

Se si utilizza l’ istruzione using il tipo chiuso deve già implementare IDisposable altrimenti il ​​compilatore emetterà un errore. Pertanto, considerare l’implementazione idisposta come prerequisito dell’utilizzo.

Se si desidera utilizzare l’istruzione using nella class personalizzata, è necessario implementare IDisposable per esso. Tuttavia questo è un po ‘arretrato, perché non ha senso farlo per il gusto di farlo. Solo se hai qualcosa da smaltire come una risorsa non gestita dovresti implementarla.

 // To implement it in C#: class MyClass : IDisposable { // other members in you class public void Dispose() { // in its simplest form, but see MSDN documentation linked above } } 

Questo ti consente di:

 using (MyClass mc = new MyClass()) { // do some stuff with the instance... mc.DoThis(); //all fake method calls for example mc.DoThat(); } // Here the .Dispose method will be automatically called. 

In effetti è lo stesso della scrittura:

 MyClass mc = new MyClass(); try { // do some stuff with the instance... mc.DoThis(); //all fake method calls for example mc.DoThat(); } finally { // always runs mc.Dispose(); // Manual call. } 

Non puoi averne uno senza l’altro.

Quando scrivi:

 using(MyClass myObj = new MyClass()) { myObj.SomeMthod(...); } 

Il compilatore genererà qualcosa come questo:

 MyClass myObj = null; try { myObj = new MyClass(); myObj.SomeMthod(...); } finally { if(myObj != null) { ((IDisposable)myObj).Dispose(); } } 

Quindi, come puoi vedere mentre using parola chiave, si presume / richieda l’implementazione di IDisposable.

Stai confondendo le cose. È ansible utilizzare solo la parola chiave “using” su qualcosa che implementa IDisposable.

Modifica: se si utilizza la parola chiave using, non è necessario chiamare esplicitamente Dispose, verrà chiamato automaticamente alla fine del blocco using. Altri hanno già pubblicato esempi di come l’istruzione using viene tradotta in una dichiarazione try – finally, con Dispose invocato nel blocco finally.

Sì, la parola chiave using è zucchero sintattico per questo tipo di pattern … (da msdn)

  Font font1 = new Font("Arial", 10.0f); try { byte charset = font1.GdiCharSet; } finally { if (font1 != null) ((IDisposable)font1).Dispose(); } 

Modifica: un esempio utile.

Quando trovi che stai facendo cose coerenti in una sezione finale, ad esempio riportando un cursore al suo valore predefinito dopo averlo impostato su un cursore di attesa, questo è un candidato per questo modello …

  public class Busy : IDisposable { private Cursor _oldCursor; private Busy() { _oldCursor = Cursor.Current; } public static Busy WaitCursor { get { Cursor.Current = Cursors.WaitCursor; return new Busy(); } } #region IDisposable Members public void Dispose() { Cursor.Current = _oldCursor; } #endregion } 

Chiamato come …

 using(Busy.WaitCursor) { // some operation that needs a wait cursor. } 

L’utilizzo eliminerà solo oggetti monouso . In questo modo, racchiudere un blocco usando attorno a un object che non implementa IDisposable è piuttosto inutile , di fatto causerà un errore del compilatore.

http://msdn.microsoft.com/en-us/library/yh598w02.aspx

Di norma, quando si utilizza un object IDisposable, è necessario dichiararlo e creare un’istanza in un’istruzione using. L’istruzione using chiama il metodo Dispose sull’object nel modo corretto, e fa sì che l’object stesso vada fuori ambito non appena viene chiamato Dispose. All’interno del blocco using, l’object è di sola lettura e non può essere modificato o riassegnato.

L’istruzione using garantisce che Dispose venga chiamato anche se si verifica un’eccezione mentre si chiamano metodi sull’object. È ansible ottenere lo stesso risultato inserendo l’object in un blocco try e quindi chiamando Dispose in un blocco finally; in effetti, questo è il modo in cui l’istruzione using viene tradotta dal compilatore.

È necessario implementare IDisposable da utilizzare utilizzando. Se si tenta di utilizzare using () su un tipo che non implementa IDisposable si ottiene il seguente errore di compilazione:

 error CS1674: 'SomeType': type used in a using statement must be implicitly convertible to 'System.IDisposable' 

La parola chiave using già implementa, quindi se usi la parola chiave using, non devi invocare IDisposable