CriticalFinalizerObject Classe

Definizione

public ref class CriticalFinalizerObject abstract

[System.Runtime.InteropServices.ComVisible(true)]
public abstract class CriticalFinalizerObject

public abstract class CriticalFinalizerObject

[<System.Runtime.InteropServices.ComVisible(true)>]
type CriticalFinalizerObject = class

type CriticalFinalizerObject = class

Public MustInherit Class CriticalFinalizerObject

Ereditarietà

Object

CriticalFinalizerObject

Derivato

System.IO.Enumeration.FileSystemEnumerator<TResult>

System.Runtime.InteropServices.CriticalHandle

System.Runtime.InteropServices.SafeHandle

System.Runtime.MemoryFailPoint

System.Threading.ReaderWriterLock

Altro…

Attributi

ComVisibleAttribute

Esempio

Nell'esempio di codice seguente viene illustrato l'uso della SafeFileHandle classe per fornire la finalizzazione critica per i flussi di input e output standard. L'oggetto SafeFileHandleSafeHandle , derivato dalla classe , viene passato al flusso di file nel FileStream costruttore .

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 derivate dalla CriticalFinalizerObject classe vengono considerate in modo implicito come un'area di esecuzione vincolata (CER). Questo richiede il codice nel finalizzatore per chiamare solo il codice con un contratto di affidabilità forte. Per altre informazioni sulle richieste di archiviazione, vedere lo spazio dei System.Runtime.ConstrainedExecution nomi .

Nelle classi derivate dalla CriticalFinalizerObject classe , Common Language Runtime (CLR) garantisce che a tutto il codice di finalizzazione critico venga data la possibilità di eseguire, purché il finalizzatore segua le regole per un cer, anche in situazioni in cui CLR scarica forzatamente un dominio applicazione o interrompe un thread. Se un finalizzatore viola le regole per un cer, potrebbe non essere eseguito correttamente. Inoltre, CLR stabilisce un ordinamento debole tra i finalizzatori normali e critici: per gli oggetti recuperati contemporaneamente da Garbage Collection, tutti i finalizzatori non critici vengono chiamati prima di uno dei finalizzatori critici. Ad esempio, una classe come FileStream, che contiene i dati nella SafeHandle classe derivata da CriticalFinalizerObject, può eseguire un finalizzatore standard per scaricare i dati memorizzati nel buffer esistenti.

Nella maggior parte dei casi, non è necessario scrivere classi che derivano dalla CriticalFinalizerObject classe . .NET Framework libreria di classi fornisce due classi, SafeHandle e CriticalHandle, che forniscono funzionalità di finalizzazione critiche per gestire le risorse. Inoltre, .NET Framework fornisce un set di classi prescritte derivate dalla classe SafeHandle e questo set si trova nello spazio dei nomi Microsoft.Win32.SafeHandles. Queste classi sono progettate per fornire funzionalità comuni per supportare handle di file e sistemi operativi.

Vedi anche

• SafeHandle
• CriticalHandle
• Microsoft.Win32.SafeHandles
• Aree di esecuzione vincolate
• Procedure consigliate per l'affidabilità