Comment disposer des ressources gérées dans la méthode Dispose () en C #?

Je sais Dispose() est destiné à des ressources non managées, et les ressources doivent être éliminés lorsqu'il n'est plus nécessaire, sans attendre pour le garbage collector pour finaliser l'objet.

Cependant, lors de l'élimination de l'objet, c'supprimer la finalisation du garbage collector (GC.SuppressFinalize(ce); dans le code ci-dessous). Cela signifie que si l'objet comprend les ressources gérées, nous aurons à prendre soin de ce aussi parce que le garbage collector ne sera pas nettoyer cette.

Dans l'exemple de code ci-dessous (à partir de MSDN), "Composant" est une ressource gérée, et nous appelons dispose() pour cette ressource (composant.Dispose()). Ma question est, comment pouvons-nous mettre en œuvre cette méthode pour la classe de Composant qui est géré de ressources? Devrions-nous utiliser quelque chose comme Collect() pour pousser garbage collector pour nettoyer cette partie?

Toute idée serait la bienvenue. Merci.

Ci-dessous est le code je suis à la recherche de ce qui est à partir de MSDN:

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.
    private 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.
}
}

source d'informationauteur elios786 | 2010-02-17