Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Metodo IDisposable.Dispose

Esegue attività definite dall'applicazione, ad esempio libera, rilascia o reimposta risorse non gestite.

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

void 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 viene utilizzato per tutte le attività associate alla liberazione di risorse utilizzate da un oggetto, o preparare un oggetto per il riutilizzo.

Nota di avvisoAttenzione

Se si utilizza una classe che implementa l'interfaccia IDisposable, è necessario chiamare l'implementazione di Dispose termine dell'utilizzo della classe. Per ulteriori informazioni, vedere la sezione "utilizzo di un oggetto che implementa la sezione IDisposable" nell'argomento di IDisposable.

Quando si implementa questo metodo, assicurarsi che tutte le risorse utilizzate vengano liberate propagando la chiamata con la gerarchia di contenimento. Se ad esempio un oggetto A alloca un oggetto B e l'oggetto B alloca un oggetto C, l'implementazione Dispose dell'oggetto A deve chiamare il metodo Dispose su B che deve chiamare a sua volta il metodo Dispose su C.

Nota importanteImportante

Ai programmatori C++ si consiglia di consultare distruttori e finalizzatori in Visual C++. Il compilatore C++ supporta la disposizione deterministica le risorse e non consente l'implementazione diretta del metodo di Dispose.

Un oggetto deve chiamare anche il metodo Dispose della classe di base se la classe di base implementa IDisposable. Per ulteriori informazioni sull'implementazione di IDisposable in una classe base e le relative sottoclassi, vedere la sezione di "IDisposable e la gerarchia dell'ereditarietà" nell'argomento 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. Dall'implementatore di classe con tale convenzione può scegliere di implementare un metodo pubblico con un nome personalizzato, come Close, che chiama il metodo di Dispose.

Poiché il metodo di Dispose deve essere chiamato in modo esplicito, è sempre il pericolo che le risorse non gestite non vengono rilasciate, in quanto il consumer di un oggetto non risulta possibile chiamare il relativo metodo di Dispose. Per evitare tale conseguenza è possibile procedere in due modi:

  • Eseguire il wrapping della risorsa gestita in un oggetto derivato da System.Runtime.InteropServices.SafeHandle. L'implementazione di Dispose chiama quindi il metodo di Dispose di istanze di System.Runtime.InteropServices.SafeHandle. Per ulteriori informazioni, vedere "a SafeHandle la sezione" alternativa nell'argomento di Object.Finalize.

  • Implementa un finalizzatore per liberare risorse quando Dispose non viene chiamato. Per impostazione predefinita, il Garbage Collector chiama automaticamente il finalizzatore di un oggetto prima di recuperare la memoria. Tuttavia, se il metodo di Dispose è stato chiamato, il Garbage Collector è in genere non necessario chiamare il finalizzatore dell'oggetto eliminato. Per impedire la finalizzazione automatica, le implementazioni del metodo Dispose possono chiamare il metodo GC.SuppressFinalize.

Quando si utilizza un oggetto che accede alle risorse non gestite, quale StreamWriter, una procedura consigliata è quella di creare l'istanza con un'istruzione using. L'istruzione using chiude automaticamente il flusso e chiama Dispose sull'oggetto quando il codice in uso è stato completato. Per un esempio, vedere la classe StreamWriter.

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

Supportato in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supportato in: 4, 3.5 SP1

Libreria di classi portabile

Supportato in: Libreria di classi portabile

.NET per applicazioni Windows Store

Supportato in: Windows 8

.NET per applicazioni Windows Phone

Supportato in: 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 (ruoli di base del server non supportati), Windows Server 2008 R2 (ruoli di base del server supportati con SP1 o versione successiva, Itanium non supportato)

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

Aggiunte alla community

AGGIUNGI
Mostra:
© 2015 Microsoft