CriticalFinalizerObject Classe

Definição

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

Herança

Object

CriticalFinalizerObject

Derivado

System.IO.Enumeration.FileSystemEnumerator<TResult>

System.Runtime.InteropServices.CriticalHandle

System.Runtime.InteropServices.SafeHandle

System.Runtime.MemoryFailPoint

System.Threading.ReaderWriterLock

Mais…

Atributos

ComVisibleAttribute

Exemplos

O seguinte exemplo de código mostra a utilização da SafeFileHandle classe para fornecer finalização crítica dos fluxos padrão de entrada e saída. O SafeFileHandle, derivado da SafeHandle classe, é passado para o fluxo de ficheiros no FileStream construtor.

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

Observações

As classes derivadas da CriticalFinalizerObject classe são implicitamente tratadas como uma região de execução restrita (CER). Isto exige que o código no finalizador apenas chame código com um contrato de fiabilidade forte. Para mais informações sobre CERs, consulte o System.Runtime.ConstrainedExecution namespace.

Em classes derivadas da CriticalFinalizerObject classe, o tempo de execução da common language (CLR) garante que todo o código crítico de finalização terá a oportunidade de ser executado, desde que o finalizador siga as regras de uma CER, mesmo em situações em que o CLR descarrega forçadamente um domínio de aplicação ou aborta uma thread. Se um finalizador violar as regras de um CER, pode não ser executado com sucesso. Além disso, o CLR estabelece uma ordenação fraca entre finalizadores normais e críticos: para objetos recuperados por recolha de lixo ao mesmo tempo, todos os finalizadores não críticos são chamados antes de qualquer um dos finalizadores críticos. Por exemplo, uma classe como FileStream, que armazena dados na SafeHandle classe derivados de CriticalFinalizerObject, pode executar um finalizador padrão para limpar dados em buffer existentes.

Na maioria dos casos, não precisa de escrever classes que derivam da CriticalFinalizerObject classe. .NET biblioteca de classes Framework fornece duas classes, SafeHandle e CriticalHandle, que fornecem funcionalidades críticas de finalização para recursos de controlo. Além disso, .NET Framework fornece um conjunto de classes pré-escritas derivadas da classe SafeHandle, e este conjunto está localizado no espaço de nomes Microsoft.Win32.SafeHandles. Estas classes foram concebidas para fornecer funcionalidades comuns para suportar handles de ficheiros e sistemas operativos.

Ver também

• SafeHandle
• CriticalHandle
• Microsoft.Win32.SafeHandles
• Regiões de execução restritas
• Práticas recomendadas de confiabilidade