Finalize Metodo
Comprimi il sommario
Espandi il sommario
Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo Object.Finalize ()

 

Consente a un oggetto di provare a liberare risorse ed eseguire altre operazioni di pulizia prima che l'oggetto stesso venga reclamato dalla procedura di Garbage Collection.

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

Protected Overridable Sub Finalize

Il Finalize metodo viene utilizzato per eseguire operazioni di pulizia sulle risorse non gestite utilizzate dall'oggetto corrente prima dell'eliminazione dell'oggetto.Il metodo è protetto e pertanto è accessibile solo tramite questa classe o una classe derivata.

Contenuto della sezione:

La Object classe non fornisce alcuna implementazione per il Finalize metodo e il garbage collector non contrassegna i tipi derivati da Object per la finalizzazione a meno che non hanno la precedenza il Finalize metodo.

Se si esegue l'override di un tipo il Finalize metodo, il garbage collector aggiunge una voce per ogni istanza del tipo a una struttura interna denominata coda di finalizzazione.Coda di finalizzazione contiene voci per tutti gli oggetti nell'heap gestito con codice di finalizzazione deve essere eseguito prima che il garbage collector possa recuperare la memoria.Il garbage collector chiama quindi il Finalize metodo automaticamente le seguenti condizioni:

  • Dopo che il garbage collector ha individuato un oggetto non è accessibile, a meno che l'oggetto sia stato esonerato dalla finalizzazione tramite una chiamata al GC.SuppressFinalize metodo.

  • Durante l'arresto di un dominio applicazione, a meno che non è esente dalla finalizzazione dell'oggetto.Durante l'arresto, anche gli oggetti che sono ancora accessibili vengono finalizzati.

Finalize viene chiamato automaticamente una sola volta per una determinata istanza, a meno che l'oggetto viene registrato nuovamente tramite un meccanismo, ad esempio GC.ReRegisterForFinalize e GC.SuppressFinalize metodo non è stato successivamente chiamato.

Finalize operazioni presentano le limitazioni seguenti:

  • L'ora esatta di quando viene eseguito il finalizzatore non è definito.Per garantire il rilascio deterministico delle risorse per le istanze della classe, implementare un Close metodo o fornire un IDisposable.Dispose implementazione.

  • Non sono garantiti che i finalizzatori di due oggetti eseguiti in un ordine specifico, anche se un oggetto fa riferimento a altro.Se un oggetto ha un riferimento all'oggetto B e dispongono di finalizzatori, oggetto B potrebbe essere già stato finalizzato all'avvio il finalizzatore dell'oggetto A.

  • Il thread su cui viene eseguito il finalizzatore non è specificato.

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

  • Se un altro finalizzatore blocchi indefinitamente (l'attivazione di un ciclo infinito, tenta di ottenere un blocco può mai ottenere e così via).Poiché il runtime tenta di eseguire i finalizzatori fino al completamento, altri finalizzatori potrebbero non essere chiamati se un finalizzatore è bloccato a tempo indeterminato.

  • Se il processo viene terminato senza consentirà il runtime di pulizia.In questo caso, notifica prima del runtime di terminazione del processo è una notifica DLL_PROCESS_DETACH.

Il runtime continua a completare gli oggetti durante l'arresto solo quando il numero di oggetti finalizzabili continua a diminuire.

Se Finalize o un override di Finalize genera un'eccezione e il runtime non è ospitato da un'applicazione che esegue l'override dei criteri predefiniti, il runtime termina il processo e nessun blocco try/finally blocchi o i finalizzatori vengono eseguiti.Questo comportamento assicura l'integrità del processo se il finalizzatore non può liberare o distruggere risorse.

Eseguire l'override Finalize per una classe che utilizza le risorse non gestite come handle di file o connessioni di database che devono essere rilasciate quando l'oggetto gestito che utilizza tali venga eliminato durante la procedura di garbage collection.

System_CAPS_importantImportante

Se un SafeHandle l'oggetto è disponibile che esegue il wrapping della risorsa non gestita, l'alternativa consigliata consiste nell'implementare il modello dispose con un handle sicuro e non eseguire l'override Finalize.Per ulteriori informazioni, vedere alternativa SafeHandle il sezione.

Il Object.Finalize metodo non esegue alcuna operazione per impostazione predefinita, ma è necessario eseguire l'override Finalize solo se necessario e solo per rilasciare le risorse non gestite.Recupero della memoria tende a durare più a lungo se viene eseguita un'operazione di finalizzazione, perché richiede almeno due operazioni di garbage collection.Inoltre, è necessario eseguire l'override il Finalize solo tipi di metodo per riferimento.Common language runtime completa solo tipi di riferimento.Ignora i finalizzatori sui tipi di valore.

Ogni implementazione di Finalize in un tipo derivato deve chiamare implementazione del tipo di base di Finalize.Questo è l'unico caso in cui applicazione è possibile chiamare codice Finalize.

System_CAPS_noteNota

Il compilatore c# non consente di eseguire l'override il Finalize metodo.In alternativa, è possibile fornire un finalizzatore implementando un per la classe.Un distruttore c# chiama automaticamente il distruttore della relativa classe base.

Visual C++ fornisce inoltre una sintassi per l'implementazione il Finalize metodo.Per ulteriori informazioni, vedere la sezione "Distruttori e finalizzatori" di How to: Define and Consume Classes and Structs (C++/CLI).

Poiché l'operazione di garbage collection è non deterministico, non si conosce con precisione quando il garbage collector esegue la finalizzazione.Per rilasciare le risorse immediatamente, è possibile inoltre scegliere di implementare il e IDisposable interfaccia.Il IDisposable.Dispose implementazione può essere chiamato dagli utenti della classe per liberare le risorse non gestite ed è possibile utilizzare il Finalize metodo per liberare le risorse non gestite nel caso in cui il Dispose non viene chiamato il metodo.

Finalize può richiedere qualsiasi azione, tra cui ripristinare un oggetto (ovvero renderlo di nuovo accessibile) dopo averlo eliminato durante l'operazione di garbage collection.Tuttavia, l'oggetto può essere ripristinato soltanto una volta; Finalize non può essere chiamato su oggetti ripristinati durante l'operazione di garbage collection.Esiste un'azione che l'implementazione di Finalize non dovrebbe mai aver: non non dovrebbe mai generare un'eccezione.

Creazione di finalizzatori affidabili è spesso difficile, poiché non è possibile apportare presupposti sullo stato dell'applicazione e sistema eccezioni non gestite come OutOfMemoryException e StackOverflowException terminare il finalizzatore.Anziché implementare un finalizzatore per la classe per rilasciare risorse non gestite, è possibile utilizzare un oggetto derivato dalla System.Runtime.InteropServices.SafeHandle classe per eseguire il wrapping delle risorse non gestite e quindi implementare il modello dispose senza un finalizzatore..NET Framework fornisce le seguenti classi il Microsoft.Win32 dello spazio dei nomi sono derivati da System.Runtime.InteropServices.SafeHandle:

Nell'esempio seguente viene utilizzata la con handle sicuri anziché eseguire l'override il Finalize metodo.Definisce un FileAssociation classe che esegue il wrapping delle informazioni del Registro di sistema relative all'applicazione che gestisce i file con estensione di file specifico.Gli handle del Registro di due sistema restituiti come out parametri da Windows RegOpenKeyEx chiamate di funzione vengono passate per il SafeRegistryHandle costruttore.Il tipo del protetto Dispose metodo chiama quindi il SafeRegistryHandle.Dispose metodo per liberare gli handle di due.

Imports Microsoft.Win32.SafeHandles
Imports System
Imports System.ComponentModel
Imports System.IO
Imports System.Runtime.InteropServices
Imports System.Text

Public Class FileAssociationInfo : Implements IDisposable
   ' Private variables.
   Private ext As String
   Private openCmd As String
   Private args As String
   Private hExtHandle, hAppIdHandle As SafeRegistryHandle

   ' Windows API calls.
   Private Declare Unicode Function RegOpenKeyEx Lib"advapi32.dll" _
                   Alias "RegOpenKeyExW" (hKey As IntPtr, lpSubKey As String, _
                   ulOptions As Integer, samDesired As Integer, _
                   ByRef phkResult As IntPtr) As Integer
   Private Declare Unicode Function RegQueryValueEx Lib "advapi32.dll" _
                   Alias "RegQueryValueExW" (hKey As IntPtr, _
                   lpValueName As String, lpReserved As Integer, _
                   ByRef lpType As UInteger, lpData As String, _
                   ByRef lpcbData As UInteger) As Integer   
   Private Declare Function RegSetValueEx Lib "advapi32.dll" _
                  (hKey As IntPtr, _
                  <MarshalAs(UnmanagedType.LPStr)> lpValueName As String, _
                  reserved As Integer, dwType As UInteger, _
                  <MarshalAs(UnmanagedType.LPStr)> lpData As String, _
                  cpData As Integer) As Integer 
   Private Declare Function RegCloseKey Lib "advapi32.dll" _
                  (hKey As IntPtr) As Integer

   ' Windows API constants.
   Private Const HKEY_CLASSES_ROOT As Integer = &h80000000
   Private Const ERROR_SUCCESS As Integer = 0

   Private Const KEY_QUERY_VALUE As Integer = 1
   Private Const KEY_SET_VALUE As Integer = &h2

   Private REG_SZ As UInteger = 1

   Private Const MAX_PATH As Integer  = 260

   Public Sub New(fileExtension As String)
      Dim retVal As Integer = 0
      Dim lpType As UInteger = 0

      If Not fileExtension.StartsWith(".") Then 
         fileExtension = "." + fileExtension
      End If   
      ext = fileExtension

      Dim hExtension As IntPtr = IntPtr.Zero
      ' Get the file extension value.
      retVal = RegOpenKeyEx(New IntPtr(HKEY_CLASSES_ROOT), fileExtension, 0, 
                            KEY_QUERY_VALUE, hExtension)
      if retVal <> ERROR_SUCCESS Then 
         Throw New Win32Exception(retVal)
      End If  
      ' Instantiate the first SafeRegistryHandle.
      hExtHandle = New SafeRegistryHandle(hExtension, True)

      Dim appId As New String(" "c, MAX_PATH)
      Dim appIdLength As UInteger = CUInt(appId.Length)
      retVal = RegQueryValueEx(hExtHandle.DangerousGetHandle(), String.Empty, _
                               0, lpType, appId, appIdLength)
      if retVal <> ERROR_SUCCESS Then
         Throw New Win32Exception(retVal)
      End If   
      ' We no longer need the hExtension handle.
      hExtHandle.Dispose()

      ' Determine the number of characters without the terminating null.
      appId = appId.Substring(0, CInt(appIdLength) \ 2 - 1) + "\shell\open\Command"

      ' Open the application identifier key.
      Dim exeName As New string(" "c, MAX_PATH)
      Dim exeNameLength As UInteger = CUInt(exeName.Length)
      Dim hAppId As IntPtr
      retVal = RegOpenKeyEx(New IntPtr(HKEY_CLASSES_ROOT), appId, 0, 
                            KEY_QUERY_VALUE Or KEY_SET_VALUE, hAppId)
      If retVal <> ERROR_SUCCESS Then 
         Throw New Win32Exception(retVal)
      End If   

      ' Instantiate the second SafeRegistryHandle.
      hAppIdHandle = New SafeRegistryHandle(hAppId, True)

      ' Get the executable name for this file type.
      Dim exePath As New string(" "c, MAX_PATH)
      Dim exePathLength As UInteger = CUInt(exePath.Length)
      retVal = RegQueryValueEx(hAppIdHandle.DangerousGetHandle(), _
                               String.Empty, 0, lpType, exePath, exePathLength)
      If retVal <> ERROR_SUCCESS Then
         Throw New Win32Exception(retVal)
      End If     
      ' Determine the number of characters without the terminating null.
      exePath = exePath.Substring(0, CInt(exePathLength) \ 2 - 1)

      exePath = Environment.ExpandEnvironmentVariables(exePath)
      Dim position As Integer = exePath.IndexOf("%"c)
      If position >= 0 Then
         args = exePath.Substring(position)
         ' Remove command line parameters ('%0', etc.).
         exePath = exePath.Substring(0, position).Trim()
      End If   
      openCmd = exePath
   End Sub

   Public ReadOnly Property Extension As String
      Get
         Return ext
      End Get
   End Property

   Public Property Open As String
      Get
         Return openCmd
      End Get    
      Set 
        If hAppIdHandle.IsInvalid Or hAppIdHandle.IsClosed Then
           Throw New InvalidOperationException("Cannot write to registry key.")
        End If    
        If Not File.Exists(value) Then
           Dim message As String = String.Format("'{0}' does not exist", value)
           Throw New FileNotFoundException(message) 
        End If
        Dim cmd As String = value + " %1"
        Dim retVal As Integer = RegSetValueEx(hAppIdHandle.DangerousGetHandle(), String.Empty, 0, 
                                              REG_SZ, value, value.Length + 1)
        If retVal <> ERROR_SUCCESS Then 
           Throw New Win32Exception(retVal)
        End If                             
      End Set
   End Property   

   Public Sub Dispose() _
      Implements IDisposable.Dispose 
      Dispose(true)
      GC.SuppressFinalize(Me)
   End Sub   

   Protected Sub Dispose(disposing As Boolean)
      ' Ordinarily, we release unmanaged resources here 
      ' but all are wrapped by safe handles.

      ' Release disposable objects.
      If disposing Then
         If hExtHandle IsNot Nothing Then hExtHandle.Dispose()
         If hAppIdHandle IsNot Nothing Then hAppIdHandle.Dispose()
      End If
   End Sub
End Class

Nell'esempio seguente verifica che il Finalize metodo viene chiamato quando un oggetto che esegue l'override Finalize viene eliminato.Si noti che, in un'applicazione di produzione, il Finalize potrebbe eseguire l'override del metodo per rilasciare le risorse non gestite utilizzate dall'oggetto.Si noti inoltre che l'esempio di codice c# fornisce un distruttore anziché eseguire l'override il Finalize metodo.

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

For an additional example that overrides the Finalize method, see the GC.SuppressFinalize method.

Universal Windows Platform
Disponibile da 4.5
.NET Framework
Disponibile da 1.1
Portable Class Library
Supportato in: portable .NET platforms
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra:
© 2016 Microsoft