Qual è il rapporto tra la l'interfaccia IDisposable parola chiave utilizzando e?

Question

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

Answer 1

Se si utilizza il using dichiarazione tipo chiuso deve già implementare IDisposable altrimenti il ??problema compilatore un errore. Quindi prendere in considerazione l'attuazione IDisposable ad essere un prerequisito di utilizzare.

Se si desidera utilizzare l'istruzione using sulla vostra classe personalizzata, allora si deve implementare IDisposable per esso. Tuttavia questo è una specie di rovescio da fare, perché non c'è alcun senso di farlo per il gusto di farlo. Solo se avete qualcosa da smaltire come una risorsa non gestita si dovrebbe attuarlo.

// 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
    }
}

Ciò 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 questo è lo stesso di 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. 
}

Answer 2

Non si può avere l'uno senza l'altro.

Quando si scrive:

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

compilatore genererà qualcosa di simile:

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

Quindi, come si può vedere, pur avendo using parola chiave si presume / necessario che IDisposable è implementato.

Answer 3

Stai confondendo le cose. È possibile utilizzare solo la parola chiave "usando" su qualcosa che implementa IDisposable.

Edit: Se si utilizza la parola chiave utilizzando, non si deve esplicitamente invoke Dispose, sarà chiamato automaticamente alla fine del blocco utilizzando. Altri hanno già postato esempi di come l'istruzione utilizzando è tradotto in una prova - finally, con Smaltire invocato all'interno del blocco finally

.

Answer 4

Sì, la parola chiave using è zucchero sintattico per questo tipo di modello ... (da MSDN)

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

Modifica:. Un utile esempio

Quando si trova si sta facendo le cose in un finalmente sezione consistantly, ad esempio il reset di un cursore per tornare la sua impostazione predefinita dopo aver impostato ad 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.
}

Answer 5

Uso sarà solo smaltire monouso oggetti. Così wraping un blocco tramite attorno ad un oggetto che non implementa IDisposable è piuttosto inutile sarà infatti causa un errore di compilazione.

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

  

Come regola generale, quando si utilizza un IDisposable   oggetto, si deve dichiarare e   un'istanza in un'istruzione using.   L'istruzione using chiama Dispose   metodo sull'oggetto nella corretta   modo, e provoca anche l'oggetto   stesso per andare fuori del campo di applicazione non appena   Dispose viene chiamato. All'interno del usando   blocco, l'oggetto è di sola lettura e   non possono essere modificati o riassegnati.

     

Gli utilizzando assicura dichiarazione che   Dispose viene chiamato anche se un'eccezione   si verifica mentre si sta chiamando i metodi   sull'oggetto. È possibile ottenere lo   stesso risultato mettendo l'oggetto   all'interno di un blocco try e quindi chiamando   Disporre in un blocco finally; infatti,   questo è come l'istruzione using è   tradotto dal compilatore.

Answer 6

Si deve implementare IDisposable da utilizzare utilizzando. Se si tenta di utilizzare utilizzando () 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'

Answer 7

La parola chiave utilizzando strumenti già, quindi se si utilizza la parola chiave utilizzando, non si dispone di invocare IDisposable