CriticalFinalizerObject Classe

Définition

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

Object

CriticalFinalizerObject

Dérivé

System.IO.Enumeration.FileSystemEnumerator<TResult>

System.Runtime.InteropServices.CriticalHandle

System.Runtime.InteropServices.SafeHandle

System.Runtime.MemoryFailPoint

System.Threading.ReaderWriterLock

Plus…

Attributs

ComVisibleAttribute

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

Méthodes

S’applique à

Voir aussi

• SafeHandle
• CriticalHandle
• Microsoft.Win32.SafeHandles
• régions d'exécution limitée
• Meilleures pratiques pour la fiabilité