CriticalFinalizerObject Classe

Definizione

public ref class CriticalFinalizerObject abstract

public abstract class CriticalFinalizerObject

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

type CriticalFinalizerObject = class

[<System.Runtime.InteropServices.ComVisible(true)>]
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 classe per fornire la SafeFileHandle 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 . Questo richiede il codice nel finalizzatore per chiamare solo il codice con un contratto di affidabilità sicuro. Per altre informazioni sulle richieste cer, vedere lo System.Runtime.ConstrainedExecution spazio dei nomi .

Nelle classi derivate dalla CriticalFinalizerObject classe , Common Language Runtime (CLR) garantisce che tutto il codice di finalizzazione critico possa essere eseguito, 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 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 . La libreria di classi .NET Framework fornisce due classi e SafeHandleCriticalHandle, che forniscono funzionalità di finalizzazione critiche per gestire le risorse. Inoltre, .NET Framework fornisce un set di classi prescritte derivate dalla SafeHandle classe e questo set si trova nello spazio dei Microsoft.Win32.SafeHandles nomi . Queste classi sono progettate per fornire funzionalità comuni per il supporto di handle di file e sistemi operativi.

Costruttori

Metodi

Si applica a

Vedi anche

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