Compartilhar via

CriticalFinalizerObject Classe

  • Referência

Definição

Namespace:
System.Runtime.ConstrainedExecution
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Garante que todo o código de finalização em classes derivadas seja marcado como crítico.

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
Herança
Object
CriticalFinalizerObject
Derivado
Atributos
ComVisibleAttribute

Exemplos

O exemplo de código a SafeFileHandle seguir mostra o uso da classe para fornecer finalização crítica para os fluxos de entrada e saída padrão. O SafeFileHandle, derivado da SafeHandle classe, é passado para o fluxo de arquivos 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

Comentários

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

Em classes derivadas da CriticalFinalizerObject classe, o CLR (Common Language Runtime) garante que todo o código de finalização crítico 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ça um domínio do aplicativo ou anula um thread. Se um finalizador violar as regras de um CER, ele poderá não ser executado com êxito. Além disso, o CLR estabelece uma ordenação fraca entre finalizadores normais e críticos: para objetos recuperados pela coleta 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 contém dados na SafeHandle classe derivada CriticalFinalizerObject, pode executar um finalizador padrão para liberar dados em buffer existentes.

Na maioria dos casos, você não precisa escrever classes que derivam da CriticalFinalizerObject classe. A biblioteca de classes .NET Framework fornece duas classes SafeHandle e CriticalHandleque fornecem funcionalidade de finalização crítica para lidar com recursos. Além disso, o .NET Framework fornece um conjunto de classes pré-escritas derivadas da SafeHandle classe e esse conjunto está localizado no Microsoft.Win32.SafeHandles namespace. Essas classes foram projetadas para fornecer funcionalidade comum para dar suporte a identificadores de arquivo e sistema operacional.

Construtores

CriticalFinalizerObject()

Inicializa uma nova instância da classe CriticalFinalizerObject.

Métodos

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.

(Herdado de Object)
Finalize()

Libera todos os recursos usados pela classe CriticalFinalizerObject.
GetHashCode()

Serve como a função de hash padrão.

(Herdado de Object)
GetType()

Obtém o Type da instância atual.

(Herdado de Object)
MemberwiseClone()

Cria uma cópia superficial do Object atual.

(Herdado de Object)
ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.

(Herdado de Object)

Aplica-se a

Confira também