CriticalFinalizerObject Classe

Définition

Garantit que tout le code de finalisation contenu dans les classes dérivées est marqué comme critique.

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
Héritage
CriticalFinalizerObject
Dérivé
Attributs

Exemples

L’exemple de code suivant montre l’utilisation de la SafeFileHandle classe pour fournir une finalisation critique pour les flux d’entrée et de sortie standard. Le SafeFileHandle, dérivé de la SafeHandle classe , est passé au flux de fichiers dans le FileStream constructeur .

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

Remarques

Les classes dérivant de la CriticalFinalizerObject classe sont implicitement traitées comme une région d’exécution contrainte (CER). Cela nécessite que le code du finaliseur appelle uniquement du code avec un contrat de fiabilité fort. Pour plus d’informations sur les CER, consultez l’espace de System.Runtime.ConstrainedExecution noms .

Dans les classes dérivées de la CriticalFinalizerObject classe, le Common Language Runtime (CLR) garantit que tout le code de finalisation critique aura la possibilité de s’exécuter, à condition que le finaliseur suive les règles d’une cer, même dans les situations où le CLR décharge de force un domaine d’application ou abandonne un thread. Si un finaliseur enfreint les règles d’une cer, il risque de ne pas s’exécuter correctement. En outre, le CLR établit un ordre faible entre les finaliseurs normaux et critiques : pour les objets récupérés par garbage collection en même temps, tous les finaliseurs non critiques sont appelés avant l’un des finaliseurs critiques. Par exemple, une classe telle que FileStream, qui contient des données dans la SafeHandle classe dérivée de CriticalFinalizerObject, peut exécuter un finaliseur standard pour vider les données mises en mémoire tampon existantes.

Dans la plupart des cas, vous n’avez pas besoin d’écrire des classes qui dérivent de la CriticalFinalizerObject classe . La bibliothèque de classes .NET Framework fournit deux classes, SafeHandle et CriticalHandle, qui fournissent des fonctionnalités de finalisation critiques pour les ressources de gestion. En outre, le .NET Framework fournit un ensemble de classes pré-écrites dérivées de la SafeHandle classe , et cet ensemble se trouve dans l’espace Microsoft.Win32.SafeHandles de noms . Ces classes sont conçues pour fournir des fonctionnalités courantes pour la prise en charge des handles de système d’exploitation et de fichiers.

Constructeurs

CriticalFinalizerObject()

Initialise une nouvelle instance de la classe CriticalFinalizerObject.

Méthodes

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
Finalize()

Libère toutes les ressources utilisées par la classe CriticalFinalizerObject.

GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)

S’applique à

Voir aussi