CriticalFinalizerObject Classe

Définition

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

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 SafeFileHandlefichier , dérivé de la SafeHandle classe, est transmis 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 le code avec un contrat de fiabilité fort. Pour plus d’informations sur les CER, consultez l’espace System.Runtime.ConstrainedExecution de noms.

Dans les classes dérivées de la CriticalFinalizerObject classe, le Common Language Runtime (CLR) garantit que tout le code de finalisation critique sera donné l’occasion d’exécuter, à condition que le finaliseur suit les règles d’un CER, même dans les cas où le CLR décharge de force un domaine d’application ou abandonne un thread. Si un finaliseur enfreint les règles d’un cer, il se peut qu’il ne s’exécute pas 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 CriticalFinalizerObjectde , 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. .NET Bibliothèque de classes Framework fournit deux classes, SafeHandle et CriticalHandle, qui fournissent des fonctionnalités de finalisation critiques pour gérer les ressources. En outre, .NET Framework fournit un ensemble de classes préécrites dérivées de la classe SafeHandle, et cet ensemble se trouve dans l’espace de noms Microsoft.Win32.SafeHandles. Ces classes sont conçues pour fournir des fonctionnalités courantes pour prendre en charge les handles de fichiers et de système d’exploitation.

Voir aussi

• SafeHandle
• CriticalHandle
• Microsoft.Win32.SafeHandles
• Régions d’exécution contraintes
• Meilleures pratiques en matière de fiabilité