Questa documentazione è stata archiviata e non viene gestita.

Metodo IDisposable.Dispose

Aggiornamento: novembre 2007

Esegue attività definite dall'applicazione, come rilasciare o reimpostare risorse non gestite.

Spazio dei nomi:  System
Assembly:  mscorlib (in mscorlib.dll)

void Dispose()
void Dispose()
function Dispose()

Utilizzare questo metodo per chiudere o rilasciare risorse non gestite, come ad esempio file, flussi e handle, occupate da un'istanza della classe in cui viene implementata questa interfaccia. Per convenzione, questo metodo è utilizzato per tutte le attività relative al rilascio di risorse occupate da un oggetto o alla preparazione di un oggetto per il riutilizzo.

es4s3w1d.alert_caution(it-it,VS.90).gifNota importante:

Ai programmatori C++ si consiglia di consultare Destructors and Finalizers in Visual C++. In .NET Framework versione 2.0 il compilatore C++ fornisce il supporto per l'implementazione dell'eliminazione deterministica delle risorse e non consente l'implementazione diretta del metodo Dispose.

Quando si implementa questo metodo, assicurarsi che tutte le risorse occupate vengano liberate, propagando la chiamata attraverso la gerarchia di contenimento. Se, ad esempio, un oggetto A alloca un oggetto B e quest'ultimo alloca un oggetto C, l'implementazione di Dispose di A dovrà chiamare Dispose su B, che a sua volta dovrà chiamare Dispose su C. Un oggetto dovrà inoltre chiamare il metodo Dispose della relativa classe base se quest'ultima implementa IDisposable.

Se il metodo Dispose di un oggetto viene chiamato più di una volta, l'oggetto dovrà ignorare tutte le chiamate successive alla prima. L'oggetto non dovrà generare un'eccezione se il relativo metodo Dispose viene chiamato più volte. I metodi di istanza diversi da Dispose possono generare un'eccezione ObjectDisposedException se le risorse sono già state eliminate.

Gli utenti possono prevedere che un tipo di risorsa utilizzi una particolare convenzione per indicare uno stato allocato o uno stato liberato. Un esempio è rappresentato dalle classi di flusso, che vengono tradizionalmente considerate aperte o chiuse. Il responsabile dell'implementazione di una classe con una convenzione di questo tipo può decidere di implementare un metodo pubblico con un nome personalizzato, ad esempio Close, che chiama il metodo Dispose.

Il metodo Dispose deve essere chiamato in modo esplicito, pertanto gli oggetti che implementano IDisposable devono anche implementare un finalizzatore per gestire il rilascio delle risorse quando il metodo Dispose non viene chiamato. Per impostazione predefinita il Garbage Collector chiama automaticamente il finalizzatore di un oggetto prima di recuperarne la memoria. Una volta che il metodo Dispose è stato chiamato, non è normalmente necessario che Garbage Collector chiami il finalizzatore dell'oggetto eliminato. Per impedire la finalizzazione automatica, le implementazioni del metodo Dispose possono chiamare il metodo GC.SuppressFinalize.

Per ulteriori informazioni sull'implementazione di finalizzatori e sul metodo Dispose, vedere la classe GC, il metodo Object.Finalize e Implementazione dei metodi Finalize e Dispose per la pulitura delle risorse non gestite.

Nell'esempio riportato di seguito viene illustrata la modalità di implementazione del metodo 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.
        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.
    }
}


import System.*;
import 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 static class MyResource implements 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 boolean 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(boolean 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 this has been done.
                disposed = true;
            }

        } 

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

        // Use J# 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.
        public void finalize() 
        {
            // Do not re-create Dispose clean-up code here.
            // Calling Dispose(false) is optimal in terms of
            // readability and maintainability.
            Dispose(false);
            try {
                super.finalize();
            }
            catch(System.Exception e ) {
            }
        } 
    } //MyResource   

    public static void main(String[] args)
    {
        // Insert code here to create
        // and use the MyResource object.      
    } 
}  


Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition , Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile per Smartphone, Windows Mobile per Pocket PC, Xbox 360

.NET Framework e .NET Compact Framework non supportano tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

.NET Framework

Supportato in: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Supportato in: 3.5, 2.0, 1.0

XNA Framework

Supportato in: 2.0, 1.0
Mostra: