Cette page vous a-t-elle été utile ?
Votre avis sur ce contenu est important. N'hésitez pas à nous faire part de vos commentaires.
Vous avez d'autres commentaires ?
1500 caractères restants
Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

IDisposable.Dispose, méthode

Exécute les tâches définies par l'application associées à la libération ou à la redéfinition des ressources non managées.

Espace de noms :  System
Assembly :  mscorlib (dans mscorlib.dll)

void Dispose()

Utilisez cette méthode pour fermer ou libérer les ressources non managées, telles que des fichiers, des flux et des handles détenus pas une instance de la classe qui implémente cette interface. Par convention, cette méthode est utilisée pour toutes les tâches associées à la libération des ressources gérées par un objet, ou préparer un objet en vue de leur réutilisation.

Mise en gardeAttention

Si vous utilisez une classe qui implémente l'interface d'IDisposable, vous devez appeler son implémentation d'Dispose lorsque vous avez terminé la classe. Pour plus d'informations, consultez « utilisation d'un objet qui implémente la section IDisposable » dans la rubrique d'IDisposable.

Lors de l'implémentation de cette méthode, veillez à ce que toutes les ressources détenues soient libérées en propageant l'appel dans la hiérarchie des relations contenant-contenu. Par exemple, si un objet A alloue un objet B, et l'objet B alloue un objet C, alors l'implémentation Dispose de A doit appeler Dispose sur B, qui doit appeler ensuite Dispose sur C.

Remarque importanteImportant

Les programmeurs C++ doivent lire Destructeurs et les finaliseurs dans Visual C++. Le compilateur C++ prend en charge la disposition des ressources déterministe et n'autorise pas l'implémentation directe de la méthode d'Dispose.

Un objet doit également appeler la méthode Dispose de sa classe de base si la classe de base implémente IDisposable. Pour plus d'informations sur l'implémentation de IDisposable sur une classe de base et ses sous-classes, consultez la section « IDisposable et la hiérarchie d'héritage » dans la rubrique IDisposable.

Si la méthode Dispose d'un objet est appelée plus d'une fois, l'objet doit ignorer tous les appels autres que le premier. L'objet ne doit pas lever d'exception si sa méthode Dispose est appelée plusieurs fois. Les méthodes d'instance autres que Dispose peuvent lever une ObjectDisposedException lorsque les ressources sont déjà supprimées.

Les utilisateurs peuvent attendre un type de ressource pour utiliser une convention particulière pour dénoter un état alloué par rapport à un état libéré. On peut citer en exemple les classes de flux qui sont traditionnellement représentées comme étant ouvertes ou fermées. Un implémenteur d'une classe qui contient une telle convention peut choisir d'implémenter une méthode publique avec un nom personnalisé, tel qu' Close, qui appelle la méthode de Dispose.

Comme la méthode d'Dispose doit être appelée explicitement, il est toujours le danger que les ressources non managées ne sont pas désallouées, car le consommateur d'un objet n'appelle pas sa méthode d'Dispose. Il existe deux manières d'éviter cette situation :

  • Encapsulez la ressource gérée dans un objet dérivé d'System.Runtime.InteropServices.SafeHandle. L'implémentation de Dispose appelle la méthode d'Dispose d'instances System.Runtime.InteropServices.SafeHandle. Pour plus d'informations, consultez « au SafeHandle l'autre section dans la rubrique d'Object.Finalize.

  • Implémenter un finaliseur pour libérer des ressources en Dispose n'est pas appelé. Par défaut, le garbage collector appelle automatiquement un finaliseur d'un objet avant de libérer sa mémoire. Toutefois, si la méthode d'Dispose a été appelée, il est généralement pas nécessaire que le garbage collector appelle un finaliseur de l'objet supprimé. Afin d'éviter la finalisation automatique, les implémentations de Dispose peuvent appeler la méthode GC.SuppressFinalize.

Lorsque vous utilisez un objet qui accède à ressources non managées, telles qu'un StreamWriter, une méthode conseillée consiste à créer l'instance avec une instruction using. L'instruction using ferme automatiquement le flux de données et appelle Dispose sur l'objet lorsque le code qui l'utilise est terminé. Pour obtenir un exemple, consultez la classe StreamWriter.

L'exemple de code suivant montre comment implémenter la méthode Dispose.


using System;
using System.ComponentModel;

// The following example demonstrates how to create
// a resource class that implements the IDisposable interface
// and the IDisposable.Dispose method.

public class DisposeExample
{
    // A base class that implements IDisposable.
    // By implementing IDisposable, you are announcing that
    // instances of this type allocate scarce resources.
    public class MyResource: IDisposable
    {
        // Pointer to an external unmanaged resource.
        private IntPtr handle;
        // Other managed resource this class uses.
        private Component component = new Component();
        // Track whether Dispose has been called.
        private bool disposed = false;

        // The class constructor.
        public MyResource(IntPtr handle)
        {
            this.handle = handle;
        }

        // Implement IDisposable.
        // Do not make this method virtual.
        // A derived class should not be able to override this method.
        public void Dispose()
        {
            Dispose(true);
            // This object will be cleaned up by the Dispose method.
            // Therefore, you should call GC.SupressFinalize to
            // take this object off the finalization queue
            // and prevent finalization code for this object
            // from executing a second time.
            GC.SuppressFinalize(this);
        }

        // Dispose(bool disposing) executes in two distinct scenarios.
        // If disposing equals true, the method has been called directly
        // or indirectly by a user's code. Managed and unmanaged resources
        // can be disposed.
        // If disposing equals false, the method has been called by the
        // runtime from inside the finalizer and you should not reference
        // other objects. Only unmanaged resources can be disposed.
        protected virtual void Dispose(bool disposing)
        {
            // Check to see if Dispose has already been called.
            if(!this.disposed)
            {
                // If disposing equals true, dispose all managed
                // and unmanaged resources.
                if(disposing)
                {
                    // Dispose managed resources.
                    component.Dispose();
                }

                // Call the appropriate methods to clean up
                // unmanaged resources here.
                // If disposing is false,
                // only the following code is executed.
                CloseHandle(handle);
                handle = IntPtr.Zero;

                // Note disposing has been done.
                disposed = true;

            }
        }

        // Use interop to call the method necessary
        // to clean up the unmanaged resource.
        [System.Runtime.InteropServices.DllImport("Kernel32")]
        private extern static Boolean CloseHandle(IntPtr handle);

        // Use C# destructor syntax for finalization code.
        // This destructor will run only if the Dispose method
        // does not get called.
        // It gives your base class the opportunity to finalize.
        // Do not provide destructors in types derived from this class.
        ~MyResource()
        {
            // Do not re-create Dispose clean-up code here.
            // Calling Dispose(false) is optimal in terms of
            // readability and maintainability.
            Dispose(false);
        }
    }
    public static void Main()
    {
        // Insert code here to create
        // and use the MyResource object.
    }
}


.NET Framework

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Bibliothèque de classes portable

Pris en charge dans : Bibliothèque de classes portable

.NET pour les applications du Windows Store

Pris en charge dans : Windows 8

.NET pour les applications Windows Phone

Pris en charge dans : Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Ajouts de la communauté

AJOUTER
Afficher:
© 2015 Microsoft