Metodo Object.Finalize (System)

Il metodo Finalize è utilizzato per eseguire operazioni di pulizia su risorse non gestite mantenute dall'oggetto corrente prima che venga eliminato l'oggetto corrente. Il metodo è protetto, pertanto è accessibile soltanto attraverso questa classe o una classe derivata.

Il metodo viene chiamato automaticamente dopo che un oggetto è divenuto inaccessibile, a meno che l'oggetto non sia stato esonerato dalla finalizzazione attraverso una chiamata al metodo GC.SuppressFinalize. Durante l'arresto di un dominio applicazione, l'oggetto Finalize viene chiamato automaticamente su oggetti che non sono esenti da finalizzazione, anche quelli ai quali è ancora possibile accedere. La chiamata automatica a Finalize viene eseguita soltanto una volta per una determinata istanza, a meno che l'oggetto venga registrato nuovamente attraverso un meccanismo quale GC.ReRegisterForFinalize e che GC.SuppressFinalize non sia stato successivamente chiamato.

Ogni implementazione di Finalize in un tipo derivato deve chiamare la propria implementazione di Finalize del tipo di base. Questo è l'unico caso in cui il codice dell'applicazione può chiamare il metodo Finalize.

Nota
Poiché il compilatore C# non consente all'utente di implementare direttamente il metodo Finalize, un distruttore C# chiama automaticamente il distruttore della classe di base.

Le operazioni di Finalize hanno i seguenti limiti:

• Non è definito il momento esatto in cui viene eseguito il finalizzatore durante la procedura di Garbage Collection. Non è certo che le risorse vengano rilasciate in un dato momento, a meno che non si chiami un metodo Close o Dispose.

• Non è certo che i finalizzatori di due oggetti vengano eseguiti in un ordine specifico, anche se un oggetto fa riferimento all'altro. Vale a dire, se l'Oggetto A ha un riferimento all'Oggetto B ed entrambi dispongono di finalizzatori, è probabile che l'Oggetto B sia già stato finalizzato quando viene avviato il finalizzatore dell'Oggetto A.

• Non è specificato il thread su cui viene eseguito il finalizzatore.

Il metodo Finalize potrebbe non essere completato o non essere avviato affatto nei seguenti casi eccezionali:

• Un altro finalizzatore è bloccato in modo indefinito, ossia è entrato in un ciclo infinito, esegue il tentativo di ottenere un blocco che non potrà mai ottenere e così via. Poiché viene eseguito il tentativo di completare i finalizzatori ad parte del runtime, gli altri finalizzatori non potranno essere chiamati se uno di essi è bloccato in modo indefinito.

• Il processo termina senza aver dato alcuna possibilità al runtime di eseguire una pulitura. In questo caso, la prima notifica di completamento del processo effettuata dal runtime è una notifica DLL_PROCESS_DETACH.

Il runtime continua a utilizzare il metodo Finalize sugli oggetti durante la chiusura soltanto quando il numero di oggetti finalizzabili continua a diminuire.

Se il metodo Finalize o un override di Finalize genera un'eccezione e il runtime non è contenuto in un'applicazione che esegue l'override dei criteri predefiniti, il runtime termina il processo e nessun blocco try-finally o finalizzatori vengono eseguiti. Questo comportamento garantisce l'integrità del processo qualora il finalizzatore non possa liberare o distruggere risorse.

Object.Finalize non effettua alcuna operazione predefinita. Deve essere sottoposto a override da una classe derivata soltanto se necessario, perché il recupero durante la procedura di Garbage Collection tende a durare più a lungo se deve essere eseguita un'operazione di Finalize.

Se un oggetto Object contiene riferimenti a risorse, Finalize deve essere sottoposto a override da una classe derivata perché possa liberare queste risorse prima che l'oggetto Object venga eliminato durante la procedura di Garbage Collection.

Il metodo Finalize deve essere implementato da un tipo quando utilizza risorse non gestite, ad esempio handle di file o connessioni di database che devono essere rilasciate quando l'oggetto gestito che le utilizza viene recuperato. Per ulteriori informazioni su strumenti complementari e più semplici da gestire per l'eliminazione delle risorse, vedere l'interfaccia IDisposable.

Finalize è in grado di intraprendere qualsiasi azione, tra cui ripristinare un oggetto, ovvero renderlo di nuovo accessibile, dopo averlo eliminato durante la procedura di Garbage Collection. L'oggetto può, tuttavia, essere ripristinato soltanto una volta; Finalize non può essere chiamato su oggetti ripristinati durante la procedura di Garbage Collection.

I distruttori rappresentano il meccanismo di C# per eseguire le operazioni di pulitura. I distruttori forniscono una protezione appropriata, ad esempio chiamando automaticamente il distruttore del tipo di base. Nel codice C# non è possibile chiamare o eseguire l'override di Object.Finalize.

Nell'esempio seguente si verifica che venga chiamato il metodo Finalize quando viene eliminato un oggetto che esegue l'override di Finalize. Si noti che, in un'applicazione di produzione, l'override del metodo Finalize verrebbe eseguito per rilasciare risorse non gestite mantenute dall'oggetto. Si noti inoltre che nell'esempio C# viene fornito un distruttore e non viene eseguito l'override del metodo Finalize.

Imports System.Diagnostics

Public Class ExampleClass
   Dim sw As StopWatch

   Public Sub New()
      sw = Stopwatch.StartNew()
      Console.WriteLine("Instantiated object")
   End Sub 

   Public Sub ShowDuration()
      Console.WriteLine("This instance of {0} has been in existence for {1}",
                        Me, sw.Elapsed)
   End Sub

   Protected Overrides Sub Finalize()
      Console.WriteLine("Finalizing object")
      sw.Stop()
      Console.WriteLine("This instance of {0} has been in existence for {1}",
                        Me, sw.Elapsed)
   End Sub
End Class

Module Demo
   Public Sub Main()
      Dim ex As New ExampleClass()
      ex.ShowDuration()
   End Sub
End Module
' The example displays output like the following:
'    Instantiated object
'    This instance of ExampleClass has been in existence for 00:00:00.0011060
'    Finalizing object
'    This instance of ExampleClass has been in existence for 00:00:00.0036294

using System;
using System.Diagnostics;

public class ExampleClass
{
   Stopwatch sw;

   public ExampleClass()
   {
      sw = Stopwatch.StartNew();
      Console.WriteLine("Instantiated object");
   } 

   public void ShowDuration()
   {
      Console.WriteLine("This instance of {0} has been in existence for {1}",
                        this, sw.Elapsed);
   }

   ~ExampleClass()
   {
      Console.WriteLine("Finalizing object");
      sw.Stop();
      Console.WriteLine("This instance of {0} has been in existence for {1}",
                        this, sw.Elapsed);
   }
}

public class Demo
{
   public static void Main()
   {
      ExampleClass ex = new ExampleClass();
      ex.ShowDuration();
   }
}
// The example displays output like the following:
//    Instantiated object
//    This instance of ExampleClass has been in existence for 00:00:00.0011060
//    Finalizing object
//    This instance of ExampleClass has been in existence for 00:00:00.0036294

.NET Framework

.NET Framework Client Profile

Windows 7, Windows Vista SP1 o versione successiva, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (componenti di base del server non supportati), Windows Server 2008 R2 (componenti di base del server supportati con SP1 o versione successiva), Windows Server 2003 SP2

Riferimenti