Quelle est la relation entre le mot-clé à l'aide et l'interface IDisposable?

Question

Si je suis en utilisant le mot-clé using, dois-je encore à mettre en œuvre IDisposable?

Answer 1

Si vous utilisez l'instruction using le type ci-joint doit déjà mettre en œuvre IDisposable autrement la question de la volonté du compilateur une erreur. Donc envisager la mise en œuvre IDisposable être une condition sine qua non d'utiliser.

Si vous voulez utiliser l'instruction using sur votre classe personnalisée, vous devez implémenter IDisposable pour elle. Toutefois, ce genre est de faire en arrière parce qu'il n'y a pas de sens de le faire pour le plaisir. Seulement si vous avez quelque chose à en disposer comme une ressource non gérée devrait vous mettre en œuvre.

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

Cela vous permet de:

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.

En effet qui est la même chose que l'écriture:

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

Vous ne pouvez pas avoir l'un sans l'autre.

Lorsque vous écrivez:

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

compilateur va générer quelque chose comme ceci:

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

Comme vous pouvez le voir tout en ayant using mot-clé, il est supposé / exigé que IDisposable est mis en œuvre.

Answer 3

Vous confondez les choses. Vous ne pouvez utiliser la fonction « en utilisant » mot-clé sur quelque chose qui implémente IDisposable.

Edit: Si vous utilisez le mot-clé en utilisant, vous n'avez pas explicity Invoke Dispose, il sera appelé automatiquement à la fin du bloc à l'aide. D'autres ont déjà affiché des exemples de la façon dont l'instruction à l'aide se traduit par un essai - finally, avec Éliminez invoquée dans le bloc finally

.

Answer 4

Oui, le mot-clé à l'aide est le sucre syntaxique pour ce type de modèle ... (à partir msdn)

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

Edit:. Un exemple utile

Lorsque vous vous trouvez faites les choses dans une section enfin consistantly, par exemple la réinitialisation d'un retour du curseur à sa valeur par défaut après avoir mis à un curseur d'attente, c'est un candidat pour ce modèle ...

  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
  }

... Appelé comme

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

Answer 5

L'utilisation ne fera que jeter jetable objets. Donc wraping un bloc à l'aide autour d'un objet qui ne met pas en œuvre IDisposable est assez inutile est en fait provoquer une erreur du compilateur.

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

  

En règle générale, lorsque vous utilisez un IDisposable   objet, vous devez déclarer et   instancier dans une déclaration à l'aide.   La déclaration appelle à l'aide la méthode Dispose   méthode sur l'objet dans le bon   manière, et il fait également l'objet   lui-même pour sortir du champ dès que   Dispose est appelé. Au sein de l'utilisation de   bloc, l'objet est en lecture seule et   ne peut pas être modifié ou réaffectés.

     

Les assure que l'instruction avec   Dispose est appelée même si une exception   se produit pendant que vous appelez des méthodes   sur l'objet. Vous pouvez obtenir le   même résultat en mettant l'objet   l'intérieur d'un bloc try puis appeler   Éliminer dans un bloc finally; En réalité,   voici comment l'instruction à l'aide est   traduit par le compilateur.

Answer 6

Vous devez mettre en œuvre IDisposable à utiliser à l'aide. Si vous essayez d'utiliser l'aide () sur un type qui ne met pas en œuvre IDisposable vous obtenez l'erreur de compilation suivante:

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

Answer 7

Le mot-clé en utilisant déjà des outils, donc si vous utilisez le mot-clé à l'aide, vous ne devez pas Invoke IDisposable