CriticalFinalizerObject Classe

Definizione

Assicura che tutto il codice di finalizzazione nelle classi derivate sia contrassegnato come critico.Ensures that all finalization code in derived classes is marked as critical.

public ref class CriticalFinalizerObject abstract
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class CriticalFinalizerObject
type CriticalFinalizerObject = class
Public MustInherit Class CriticalFinalizerObject
Ereditarietà
CriticalFinalizerObject
Derivato
Attributi

Esempi

Nell'esempio di codice seguente viene illustrato l'utilizzo della classe SafeFileHandle per fornire la finalizzazione critica per i flussi di input e di output standard.The following code example shows the use of the SafeFileHandle class to provide critical finalization for the standard input and output streams. Il SafeFileHandle, derivato dalla classe SafeHandle, viene passato al flusso di file nel costruttore di FileStream.The SafeFileHandle, derived from the SafeHandle class, is passed to the file stream in the FileStream constructor.

using System;
using System.Runtime.InteropServices;
using System.IO;
using Microsoft.Win32.SafeHandles;

namespace CriticalFinalizer
{
    class Program
    {
        const int STD_INPUT_HANDLE   = -10;
        const int STD_OUTPUT_HANDLE = -11;
        const int STD_ERROR_HANDLE  =  -12;
        [DllImport("Kernel32.dll", CharSet = System.Runtime.InteropServices.CharSet.Auto)]
        public static extern IntPtr GetStdHandle(int type);

        static void Main(string[] args)
        {
            FileStream fsIn = null;
            FileStream fsOut = null;
            try
            {
                SafeFileHandle sfhIn = new SafeFileHandle(GetStdHandle(STD_INPUT_HANDLE), false);
                fsIn = new FileStream(sfhIn, FileAccess.Read);
                byte[] input = new byte[] {0};
                fsIn.Read(input,0,1);
                SafeFileHandle sfhOut = new SafeFileHandle(GetStdHandle(STD_OUTPUT_HANDLE), false);
                fsOut = new FileStream(sfhOut, FileAccess.Write);
                fsOut.Write(input,0,1);
                SafeFileHandle sf = fsOut.SafeFileHandle;
            }
            finally
            {
                if (fsIn != null)
                {
                    fsIn.Close();
                    fsIn = null;
                }
                if (fsOut != null)
                {
                    fsOut.Close();
                    fsOut = null;
                }
            }
        }
    }
}
Imports System.Runtime.InteropServices
Imports System.IO
Imports Microsoft.Win32.SafeHandles

Public Module Example
   Const STD_INPUT_HANDLE As Integer  = -10
   Const STD_OUTPUT_HANDLE As Integer = -11
   Const STD_ERROR_HANDLE As Integer  = -12

   Public Declare Auto Function GetStdHandle Lib "Kernel32" (type As Integer) As IntPtr

   Public Sub Main()
      Dim fsIn As FileStream = Nothing
      Dim fsOut As FileStream = Nothing

      Try
         Dim sfhIn As New SafeFileHandle(GetStdHandle(STD_INPUT_HANDLE), False)
         fsIn = new FileStream(sfhIn, FileAccess.Read)
         Dim input() As Byte = { 0 }
         fsIn.Read(input, 0, 1)
         Dim sfhOut As New SafeFileHandle(GetStdHandle(STD_OUTPUT_HANDLE), False)
         fsOut = New FileStream(sfhOut, FileAccess.Write)
         fsOut.Write(input, 0, 1)
         Dim sf As SafeFileHandle = fsOut.SafeFileHandle
      Finally
         If fsIn IsNot Nothing Then
            fsIn.Close()
            fsIn = Nothing
         End If
         If fsOut IsNot Nothing Then 
            fsOut.Close()
            fsOut = Nothing
         End If
      End Try
   End Sub
End Module

Commenti

Le classi che derivano dalla classe CriticalFinalizerObject vengono considerate in modo implicito come area a esecuzione vincolata (CER).Classes deriving from the CriticalFinalizerObject class are implicitly treated as a constrained execution region (CER). Questa operazione richiede che il codice del finalizzatore chiami solo il codice con un contratto di affidabilità forte.This requires code in the finalizer to only call code with a strong reliability contract. Per ulteriori informazioni sulle CER, vedere lo spazio dei nomi System.Runtime.ConstrainedExecution.For more information about CERs, see the System.Runtime.ConstrainedExecution namespace.

Nelle classi derivate dalla classe CriticalFinalizerObject, il Common Language Runtime (CLR) garantisce che a tutto il codice di finalizzazione critico verrà assegnata la possibilità di esecuzione, purché il finalizzatore segua le regole per un'area CER, anche nelle situazioni in cui CLR Scarica forzatamente un dominio applicazione o interrompe un thread.In classes derived from the CriticalFinalizerObject class, the common language runtime (CLR) guarantees that all critical finalization code will be given the opportunity to execute, provided the finalizer follows the rules for a CER, even in situations where the CLR forcibly unloads an application domain or aborts a thread. Se un finalizzatore viola le regole per un'area CER, potrebbe non essere eseguita correttamente.If a finalizer violates the rules for a CER, it might not successfully execute. CLR stabilisce inoltre un ordinamento debole tra i finalizzatori normali e critici: per gli oggetti recuperati da Garbage Collection contemporaneamente, tutti i finalizzatori non critici vengono chiamati prima di uno dei finalizzatori critici.In addition, the CLR establishes a weak ordering among normal and critical finalizers: for objects reclaimed by garbage collection at the same time, all the noncritical finalizers are called before any of the critical finalizers. Ad esempio, una classe come FileStream, che include i dati nella classe SafeHandle derivata da CriticalFinalizerObject, può eseguire un finalizzatore standard per scaricare i dati memorizzati nel buffer esistenti.For example, a class such as FileStream, which holds data in the SafeHandle class that is derived from CriticalFinalizerObject, can run a standard finalizer to flush out existing buffered data.

Nella maggior parte dei casi, non è necessario scrivere classi che derivano dalla classe CriticalFinalizerObject.In most cases, you do not need to write classes that derive from the CriticalFinalizerObject class. La libreria di classi .NET Framework fornisce due classi, SafeHandle e CriticalHandle, che forniscono funzionalità di finalizzazione critiche per le risorse di gestione.The .NET Framework class library provides two classes, SafeHandle and CriticalHandle, that provide critical finalization functionality for handle resources. Inoltre, il .NET Framework fornisce un set di classi prescritte derivate dalla classe SafeHandle e questo set si trova nello spazio dei nomi Microsoft.Win32.SafeHandles.Furthermore, the .NET Framework provides a set of prewritten classes derived from the SafeHandle class, and this set is located in the Microsoft.Win32.SafeHandles namespace. Queste classi sono progettate per fornire funzionalità comuni per il supporto degli handle di file e del sistema operativo.These classes are designed to provide common functionality for supporting file and operating system handles.

Costruttori

CriticalFinalizerObject()

Inizializza una nuova istanza della classe CriticalFinalizerObject.Initializes a new instance of the CriticalFinalizerObject class.

Metodi

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
Finalize()

Rilascia tutte le risorse usate dalla classe CriticalFinalizerObject.Releases all the resources used by the CriticalFinalizerObject class.

GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)

Sicurezza

SecurityPermission
per l'autorizzazione a chiamare codice non gestito.for permission to call unmanaged code. Azione di sicurezza: LinkDemand.Security action: LinkDemand. Enumerazione associata: UnmanagedCodeAssociated enumeration: UnmanagedCode

InheritanceDemand
per l'attendibilità totale per gli eredi.for full trust for inheritors. Questa classe non può essere usata da codice parzialmente attendibile.This class cannot be used by partially trusted code.

Si applica a

Vedi anche