Lire en anglais

Partager via


Interface System.IDisposable

Cet article vous offre des remarques complémentaires à la documentation de référence pour cette API.

L’utilisation principale de l’interface IDisposable consiste à libérer des ressources non managées. Le garbage collector libère automatiquement la mémoire allouée à un objet managé quand cet objet n’est plus utilisé. Toutefois, il n’est pas possible de prédire quand le garbage collection se produit. En outre, le garbage collector n’a aucune connaissance des ressources non managées telles que les handles de fenêtre, ou ouvrir des fichiers et des flux.

Utilisez la Dispose méthode de cette interface pour libérer explicitement des ressources non managées conjointement avec le garbage collector. Le consommateur d’un objet peut appeler cette méthode lorsque l’objet n’est plus nécessaire.

Avertissement

Il s’agit d’un changement cassant pour ajouter l’interface IDisposable à une classe existante. Étant donné que les consommateurs préexistants de votre type ne peuvent pas appeler Dispose, vous ne pouvez pas être certain que les ressources non managées détenues par votre type seront publiées.

Étant donné que l’implémentation IDisposable.Dispose est appelée par le consommateur d’un type lorsque les ressources appartenant à une instance ne sont plus nécessaires, vous devez encapsuler l’objet managé dans une SafeHandle (alternative recommandée) ou remplacer Object.Finalize les ressources non managées en cas d’oubli du consommateur d’appeler Dispose.

Important

Dans .NET Framework, le compilateur C++ prend en charge l’élimination déterministe des ressources et n’autorise pas l’implémentation directe de la Dispose méthode.

Pour obtenir une discussion détaillée sur l’utilisation de cette interface et de la Object.Finalize méthode, consultez les rubriques Garbage Collection et Implémentation d’une méthode Dispose.

Utiliser un objet qui implémente IDisposable

Si votre application utilise simplement un objet qui implémente l’interface IDisposable , vous devez appeler l’implémentation de IDisposable.Dispose l’objet lorsque vous avez terminé de l’utiliser. Selon votre langage de programmation, vous pouvez le faire de deux façons :

  • En utilisant une construction de langage telle que l’instruction using en C# et Visual Basic, et l’instruction ou using la use fonction en F#.
  • En encapsulant l’appel à l’implémentation IDisposable.Dispose dans un try/finally bloc.

Notes

Documentation pour les types qui implémentent IDisposable notez que le fait et incluez un rappel pour appeler son Dispose implémentation.

Instruction C#, F# et Visual Basic Using

Si votre langage prend en charge une construction telle que l’instruction using en C#, l’instruction Using en Visual Basic ou l’instruction use en F#, vous pouvez l’utiliser au lieu de vous appeler IDisposable.Dispose explicitement. L’exemple suivant utilise cette approche pour définir une WordCount classe qui conserve des informations sur un fichier et le nombre de mots qu’il contient.

using System;
using System.IO;
using System.Text.RegularExpressions;

public class WordCount
{
    private String filename = String.Empty;
    private int nWords = 0;
    private String pattern = @"\b\w+\b";

    public WordCount(string filename)
    {
        if (!File.Exists(filename))
            throw new FileNotFoundException("The file does not exist.");

        this.filename = filename;
        string txt = String.Empty;
        using (StreamReader sr = new StreamReader(filename))
        {
            txt = sr.ReadToEnd();
        }
        nWords = Regex.Matches(txt, pattern).Count;
    }

    public string FullName
    { get { return filename; } }

    public string Name
    { get { return Path.GetFileName(filename); } }

    public int Count
    { get { return nWords; } }
}

L’instruction using (use expression en F#) est en fait une commodité syntaxique. Au moment de la compilation, le compilateur de langage implémente le langage intermédiaire (IL) pour un try/finally bloc.

Pour plus d’informations sur l’instructionusing, consultez les rubriques Using Statement ou using.

Bloc Try/Finally

Si votre langage de programmation ne prend pas en charge une construction comme l’instruction using en C# ou Visual Basic, ou l’instruction use en F#, ou si vous préférez ne pas l’utiliser, vous pouvez appeler l’implémentation IDisposable.Dispose à partir du finally bloc d’une try/finally instruction. L’exemple suivant remplace le using bloc dans l’exemple précédent par un try/finally bloc.

using System;
using System.IO;
using System.Text.RegularExpressions;

public class WordCount2
{
    private String filename = String.Empty;
    private int nWords = 0;
    private String pattern = @"\b\w+\b";

    public WordCount2(string filename)
    {
        if (!File.Exists(filename))
            throw new FileNotFoundException("The file does not exist.");

        this.filename = filename;
        string txt = String.Empty;
        StreamReader? sr = null;
        try
        {
            sr = new StreamReader(filename);
            txt = sr.ReadToEnd();
        }
        finally
        {
            if (sr != null) sr.Dispose();
        }
        nWords = Regex.Matches(txt, pattern).Count;
    }

    public string FullName
    { get { return filename; } }

    public string Name
    { get { return Path.GetFileName(filename); } }

    public int Count
    { get { return nWords; } }
}

Pour plus d’informations sur le try/finally modèle, consultez Try... Catch... Enfin, instruction, try-finally, try... enfin, expression ou instruction try-finally.

Implémenter IDisposable

Vous devez implémenter IDisposable si votre type utilise directement des ressources non managées ou si vous souhaitez utiliser vous-même des ressources jetables. Les consommateurs de votre type peuvent appeler votre IDisposable.Dispose implémentation pour libérer des ressources lorsque l’instance n’est plus nécessaire. Pour gérer les cas dans lesquels ils ne parviennent pas à appeler Dispose, vous devez utiliser une classe dérivée pour SafeHandle encapsuler les ressources non managées, ou remplacer la Object.Finalize méthode d’un type référence. Dans les deux cas, vous utilisez la Dispose méthode pour effectuer les propre up nécessaires après avoir utilisé les ressources non managées, telles que la libération, la libération ou la réinitialisation des ressources non managées. Pour plus d’informations sur l’implémentation IDisposable.Dispose, consultez la surcharge de méthode Dispose(bool).

Important

Si vous définissez une classe de base qui utilise des ressources non managées et qui a, ou est susceptible d’avoir, des sous-classes qui doivent être supprimées, vous devez implémenter la IDisposable.Dispose méthode et fournir une deuxième surcharge, Disposecomme indiqué dans la section suivante.

IDisposable et la hiérarchie d’héritage

Une classe de base avec des sous-classes qui doivent être disponibles doit être implémentée IDisposable comme suit. Vous devez utiliser ce modèle chaque fois que vous implémentez IDisposable sur un type qui n’est pas sealed (NotInheritable en Visual Basic).

  • Il doit fournir une méthode publique, non virtuelle Dispose() et une méthode virtuelle Dispose(Boolean disposing) protégée.
  • La Dispose() méthode doit appeler Dispose(true) et supprimer la finalisation des performances.
  • Le type de base ne doit pas inclure de finaliseurs.

Le fragment de code suivant reflète le modèle de suppression pour les classes de base. Il part du principe que votre type ne remplace pas la Object.Finalize méthode.

using System;
using System.IO;
using System.Runtime.InteropServices;

class BaseClass1 : IDisposable
{
    // Flag: Has Dispose already been called?
    bool disposed = false;
    // Instantiate a FileStream instance.
    FileStream fs = new FileStream("test.txt", FileMode.OpenOrCreate);

    // Public implementation of Dispose pattern callable by consumers.
    public void Dispose()
    {
        Dispose(disposing: true);
        GC.SuppressFinalize(this);
    }

    // Protected implementation of Dispose pattern.
    protected virtual void Dispose(bool disposing)
    {
        if (disposed)
            return;

        if (disposing)
        {
            fs.Dispose();
            // Free any other managed objects here.
            //
        }

        disposed = true;
    }
}

Si vous remplacez la Object.Finalize méthode, votre classe doit implémenter le modèle suivant.

using System;

class BaseClass2 : IDisposable
{
    // Flag: Has Dispose already been called?
    bool disposed = false;

    // Public implementation of Dispose pattern callable by consumers.
    public void Dispose()
    {
        Dispose(disposing: true);
        GC.SuppressFinalize(this);
    }

    // Protected implementation of Dispose pattern.
    protected virtual void Dispose(bool disposing)
    {
        if (disposed)
            return;

        if (disposing)
        {
            // Free any other managed objects here.
            //
        }

        // Free any unmanaged objects here.
        //
        disposed = true;
    }

    ~BaseClass2()
    {
        Dispose(disposing: false);
    }
}

Les sous-classes doivent implémenter le modèle supprimable comme suit :

  • Elles doivent substituer Dispose(Boolean) et appeler l'implémentation Dispose(Boolean) de la classe de base.
  • Elles peuvent fournir un finaliseur, si nécessaire. Le finaliseur doit appeler Dispose(false).

Notez que les classes dérivées n’implémentent pas l’interface IDisposable et n’incluent pas de méthode sans Dispose paramètre. Ils remplacent uniquement la méthode de classe Dispose(Boolean) de base.

Le fragment de code suivant reflète le modèle de suppression pour les classes dérivées. Il part du principe que votre type ne remplace pas la Object.Finalize méthode.

using System;
using System.IO;
using System.Runtime.InteropServices;

class MyDerivedClass : MyBaseClass
{
    // Flag: Has Dispose already been called?
    bool disposed = false;
    // Instantiate a FileStream instance.
    FileStream fs = new FileStream("test.txt", FileMode.OpenOrCreate);

    // Protected implementation of Dispose pattern.
    protected override void Dispose(bool disposing)
    {
        if (disposed)
            return;

        if (disposing)
        {
            fs.Dispose();
            // Free any other managed objects here.
            //
        }

        // Free any unmanaged objects here.
        //

        disposed = true;
        // Call base class implementation.
        base.Dispose(disposing);
    }
}