Partager via

Interface System.IDisposable

Cet article fournit des remarques supplémentaires à la documentation de référence de 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 ramassage de déchets aura lieu. En outre, le ramasse-miettes n'a aucune connaissance des ressources non managées telles que les poignées de fenêtre, les fichiers et les flux ouverts.

Utilisez la méthode Dispose de cette interface pour libérer explicitement des ressources non managées en parallèle avec le ramasse-miettes. Le consommateur d’un objet peut appeler cette méthode lorsque l’objet n’est plus nécessaire.

Avertissement

L'ajout de l'interface IDisposable à une classe existante constitue un changement cassant. É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.

Importante

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 .

Utilisez 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 use ou la fonction using en F#.
  • En encapsulant l’appel à l’implémentation IDisposable.Dispose dans un try/finally bloc.

Remarque

La documentation des types qui implémentent IDisposable remarque ce fait et inclut un rappel pour appeler son implémentation Dispose.

L'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; } }
}

open System.IO
open System.Text.RegularExpressions

type WordCount(filename) =
    let txt = 
        if File.Exists filename |> not then
            raise (FileNotFoundException "The file does not exist.")

        use sr = new StreamReader(filename)
        sr.ReadToEnd()

    let pattern = @"\b\w+\b"
    
    let nWords = Regex.Matches(txt, pattern).Count

    member _.FullName = filename

    member _.Name = Path.GetFileName filename

    member _.Count = nWords

Imports System.IO
Imports System.Text.RegularExpressions

Public Class WordCount
   Private filename As String
   Private nWords As Integer
   Private pattern As String = "\b\w+\b" 

   Public Sub New(filename As String)
      If Not File.Exists(filename) Then
         Throw New FileNotFoundException("The file does not exist.")
      End If   
      
      Me.filename = filename
      Dim txt As String = String.Empty
      Using sr As New StreamReader(filename)
         txt = sr.ReadToEnd()
      End Using
      nWords = Regex.Matches(txt, pattern).Count
   End Sub
   
   Public ReadOnly Property FullName As String
      Get
         Return filename
      End Get   
   End Property
   
   Public ReadOnly Property Name As String
      Get
         Return Path.GetFileName(filename)
      End Get   
   End Property
   
   Public ReadOnly Property Count As Integer
      Get
         Return nWords
      End Get
   End Property
End Class

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'instruction using, consultez les rubriques Using Statement ou using Statement.

Le 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; } }
}

open System.IO
open System.Text.RegularExpressions

type WordCount2(filename) =
    let txt = 
        if File.Exists filename |> not then
            raise (FileNotFoundException "The file does not exist.")

        let sr = new StreamReader(filename)
        try
            sr.ReadToEnd()
        finally
            sr.Dispose()

    let pattern = @"\b\w+\b"
    
    let nWords = Regex.Matches(txt, pattern).Count

    member _.FullName = filename

    member _.Name = Path.GetFileName filename

    member _.Count = nWords

Imports System.IO
Imports System.Text.RegularExpressions

Public Class WordCount2
   Private filename As String
   Private nWords As Integer
   Private pattern As String = "\b\w+\b" 

   Public Sub New(filename As String)
      If Not File.Exists(filename) Then
         Throw New FileNotFoundException("The file does not exist.")
      End If   
      
      Me.filename = filename
      Dim txt As String = String.Empty
      Dim sr As StreamReader = Nothing
      Try
         sr = New StreamReader(filename)
         txt = sr.ReadToEnd()
      Finally
         If sr IsNot Nothing Then sr.Dispose() 
      End Try
      nWords = Regex.Matches(txt, pattern).Count
   End Sub
   
   Public ReadOnly Property FullName As String
      Get
         Return filename
      End Get   
   End Property
   
   Public ReadOnly Property Name As String
      Get
         Return Path.GetFileName(filename)
      End Get   
   End Property
   
   Public ReadOnly Property Count As Integer
      Get
         Return nWords
      End Get
   End Property
End Class

Pour plus d’informations sur le modèle try/finally, consultez Try...Catch...Finally Statement, instruction try-finally, expression try...finally 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 utilisateurs 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 de SafeHandle pour encapsuler les ressources non managées, ou remplacer la méthode Object.Finalize pour un type de référence. Dans les deux cas, vous utilisez la méthode Dispose pour effectuer le nettoyage nécessaire après l'utilisation des ressources non managées, telles que les libérer, les relâcher ou les réinitialiser. Pour plus d'informations sur l'implémentation de IDisposable.Dispose, consultez la surcharge de la méthode Dispose(bool).

Importante

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 méthode Dispose() doit appeler Dispose(true) et supprimer la finalisation pour des raisons de performance.
  • 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;
    }
}

open System
open System.IO

type BaseClass1() =
    // Flag: Has Dispose already been called?
    let mutable disposed = false

    // Instantiate a FileStream instance.
    let fs = new FileStream("test.txt", FileMode.OpenOrCreate)

    interface IDisposable with
        // Public implementation of Dispose pattern callable by consumers.
        member this.Dispose() =
            this.Dispose true
            GC.SuppressFinalize this

    // Implementation of Dispose pattern.
    abstract Dispose: bool -> unit
    override _.Dispose(disposing) =
        if not disposed then
            if disposing then
                fs.Dispose()
                // Free any other managed objects here.
            disposed <- true

Imports System.IO
Imports System.Runtime.InteropServices

Class BaseClass1 : Implements IDisposable
   ' Flag: Has Dispose already been called?
   Dim disposed As Boolean = False
   ' Instantiate a FileStream instance.
   Dim fs As FileStream = New FileStream("test.txt", FileMode.OpenOrCreate)

   ' Public implementation of Dispose pattern callable by consumers.
   Public Sub Dispose() _
              Implements IDisposable.Dispose
      Dispose(disposing:=True)
      GC.SuppressFinalize(Me)
   End Sub

   ' Protected implementation of Dispose pattern.
   Protected Overridable Sub Dispose(disposing As Boolean)
      If disposed Then Return

      If disposing Then
         fs.Dispose()
         ' Free any other managed objects here.
         '
      End If

      disposed = True
   End Sub
End Class

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);
    }
}

open System

type BaseClass2() =
    // Flag: Has Dispose already been called?
    let mutable disposed = false

    interface IDisposable with
        // Public implementation of Dispose pattern callable by consumers.
        member this.Dispose() =
            this.Dispose true
            GC.SuppressFinalize this

    // Implementation of Dispose pattern.
    abstract Dispose: bool -> unit
    override _.Dispose(disposing) =
        if not disposed then
            if disposing then
                // Free any other managed objects here.
                ()

            // Free any unmanaged objects here.
            disposed <- true

    override this.Finalize() =
        this.Dispose false

Class BaseClass : Implements IDisposable
   ' Flag: Has Dispose already been called?
   Dim disposed As Boolean = False

   ' Public implementation of Dispose pattern callable by consumers.
   Public Sub Dispose() _
              Implements IDisposable.Dispose
      Dispose(disposing:=True)
      GC.SuppressFinalize(Me)
   End Sub

   ' Protected implementation of Dispose pattern.
   Protected Overridable Sub Dispose(disposing As Boolean)
      If disposed Then Return

      If disposing Then
         ' Free any other managed objects here.
         '
      End If

      ' Free any unmanaged objects here.
      '
      disposed = True
   End Sub

   Protected Overrides Sub Finalize()
      Dispose(disposing:=False)
   End Sub
End Class

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

  • Ils doivent remplacer Dispose(Boolean) et appeler l’implémentation de classe Dispose(Boolean) de base.
  • Ils 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);
    }
}

open Microsoft.Win32.SafeHandles
open System

type MyDerivedClass() =
    inherit MyBaseClass()
    
    // Flag: Has Dispose already been called?
    let mutable disposed = false
    // Instantiate a FileStream instance.
    let fs = new FileStream("test.txt", FileMode.OpenOrCreate)

    // Implementation of Dispose pattern.
    override _.Dispose(disposing) =
        if not disposed then
            if disposing then
                fs.Dispose()
                // Free any other managed objects here.

            // Free any unmanaged objects here.
            disposed <- true
            // Call base class implementation.
            base.Dispose disposing

Imports System.IO
Imports System.Runtime.InteropServices

Class DerivedClass2 : Inherits BaseClass2
   ' Flag: Has Dispose already been called?
   Dim disposed As Boolean = False
   ' Instantiate a FileStream instance.
   Dim fs As FileStream = New FileStream("test.txt", FileMode.OpenOrCreate)

   ' Protected implementation of Dispose pattern.
   Protected Overrides Sub Dispose(disposing As Boolean)
      If disposed Then Return

      If disposing Then
         fs.Dispose()
         ' Free any other managed objects here.
         '
      End If

      ' Free any unmanaged objects here.
      '
      disposed = True

      ' Call base class implementation.
      MyBase.Dispose(disposing)
   End Sub
End Class