CriticalFinalizerObject Classe

Définition

Garantit que tout le code de finalisation contenu dans les classes dérivées est marqué comme critique.Ensures that all finalization code in derived classes is marked as critical.

public ref class CriticalFinalizerObject abstract
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class CriticalFinalizerObject
type CriticalFinalizerObject = class
Public MustInherit Class CriticalFinalizerObject
Héritage
CriticalFinalizerObject
Dérivé
Attributs

Exemples

L’exemple de code suivant illustre l’utilisation de SafeFileHandle la classe pour fournir une finalisation critique pour les flux d’entrée et de sortie standard.The following code example shows the use of the SafeFileHandle class to provide critical finalization for the standard input and output streams. Le SafeFileHandle, dérivé de la SafeHandle classe, est passé au flux de fichier dans le FileStream constructeur.The SafeFileHandle, derived from the SafeHandle class, is passed to the file stream in the FileStream constructor.

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 qui dérivent de la CriticalFinalizerObject classe sont traitées implicitement comme une région d’exécution limitée (CER).Classes deriving from the CriticalFinalizerObject class are implicitly treated as a constrained execution region (CER). Cela nécessite que le code dans le finaliseur appelle uniquement le code avec un contrat de fiabilité fort.This requires code in the finalizer to only call code with a strong reliability contract. Pour plus d’informations sur les zones CER System.Runtime.ConstrainedExecution , consultez l’espace de noms.For more information about CERs, see the System.Runtime.ConstrainedExecution namespace.

Dans les classes dérivées CriticalFinalizerObject de la 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 pour une région d’exécution limitée, même dans les situations où le CLR décharge de force un domaine d’application ou abandonne un thread.In classes derived from the CriticalFinalizerObject class, the common language runtime (CLR) guarantees that all critical finalization code will be given the opportunity to execute, provided the finalizer follows the rules for a CER, even in situations where the CLR forcibly unloads an application domain or aborts a thread. Si un finaliseur enfreint les règles pour une région d’exécution limitée, il risque de ne pas s’exécuter correctement.If a finalizer violates the rules for a CER, it might not successfully execute. En outre, le CLR établit un classement 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 les finaliseurs critiques.In addition, the CLR establishes a weak ordering among normal and critical finalizers: for objects reclaimed by garbage collection at the same time, all the noncritical finalizers are called before any of the critical finalizers. Par exemple, une classe telle que FileStream, qui contient des données dans SafeHandle la classe dérivée de CriticalFinalizerObject, peut exécuter un finaliseur standard pour vider les données mises en mémoire tampon existantes.For example, a class such as FileStream, which holds data in the SafeHandle class that is derived from CriticalFinalizerObject, can run a standard finalizer to flush out existing buffered data.

Dans la plupart des cas, vous n’avez pas besoin d’écrire des classes CriticalFinalizerObject qui dérivent de la classe.In most cases, you do not need to write classes that derive from the CriticalFinalizerObject class. La bibliothèque de classes .NET Framework fournit deux classes SafeHandle , CriticalHandleet, qui fournissent des fonctionnalités de finalisation critiques pour les ressources de gestion.The .NET Framework class library provides two classes, SafeHandle and CriticalHandle, that provide critical finalization functionality for handle resources. En outre, l' .NET Framework fournit un ensemble de classes préécrites dérivées de la SafeHandle classe, et cet ensemble se trouve dans l' Microsoft.Win32.SafeHandles espace de noms.Furthermore, the .NET Framework provides a set of prewritten classes derived from the SafeHandle class, and this set is located in the Microsoft.Win32.SafeHandles namespace. Ces classes sont conçues pour fournir des fonctionnalités communes pour la prise en charge des handles de fichiers et de systèmes d’exploitation.These classes are designed to provide common functionality for supporting file and operating system handles.

Constructeurs

CriticalFinalizerObject()

Initialise une nouvelle instance de la classe CriticalFinalizerObject.Initializes a new instance of the CriticalFinalizerObject class.

Méthodes

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
Finalize()

Libère toutes les ressources utilisées par la classe CriticalFinalizerObject.Releases all the resources used by the CriticalFinalizerObject class.

GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
ToString()

Retourne une chaîne qui représente l'objet en cours.Returns a string that represents the current object.

(Hérité de Object)

Sécurité

SecurityPermission
pour obtenir l’autorisation d’appeler du code non managé.for permission to call unmanaged code. Action de sécurité LinkDemand:.Security action: LinkDemand. Énumération associée:UnmanagedCodeAssociated enumeration: UnmanagedCode

InheritanceDemand
pour une confiance totale pour les héritiers.for full trust for inheritors. Cette classe ne peut pas être utilisée par du code d'un niveau de confiance partiel.This class cannot be used by partially trusted code.

S’applique à

Voir aussi