CriticalFinalizerObject Klas

Definitie

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

Overname

Object

CriticalFinalizerObject

Afgeleid

System.IO.Enumeration.FileSystemEnumerator<TResult>

System.Runtime.InteropServices.CriticalHandle

System.Runtime.InteropServices.SafeHandle

System.Runtime.MemoryFailPoint

System.Threading.ReaderWriterLock

Meer…

Kenmerken

ComVisibleAttribute

Voorbeelden

In het volgende codevoorbeeld ziet u het gebruik van de SafeFileHandle klasse om essentiële finalisatie te bieden voor de standaardinvoer- en uitvoerstromen. De SafeFileHandle, afgeleid van de SafeHandle klasse, wordt doorgegeven aan de bestandsstroom in de 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

Opmerkingen

Klassen die zijn afgeleid van de CriticalFinalizerObject klasse, worden impliciet behandeld als een beperkte uitvoeringsregio (CER). Hiervoor is code in de finalizer vereist om alleen code aan te roepen met een sterk betrouwbaarheidscontract. Zie de System.Runtime.ConstrainedExecution naamruimte voor meer informatie over CER's.

In klassen die zijn afgeleid van de CriticalFinalizerObject klasse, garandeert de Common Language Runtime (CLR) dat alle kritieke finalisatiecode de mogelijkheid krijgt om uit te voeren, mits de finalizer de regels voor een CER volgt, zelfs in situaties waarin de CLR een toepassingsdomein geforceerd verwijdert of een thread afbreekt. Als een finalizer de regels voor een CER schendt, kan dit niet worden uitgevoerd. Bovendien stelt de CLR een zwakke volgorde vast tussen normale en kritieke finalizers: voor objecten die tegelijkertijd door garbagecollection worden vrijgemaakt, worden alle niet-kritieke finalizers aangeroepen vóór een van de kritieke finalizers. Een klasse zoals FileStream, die gegevens bevat in de SafeHandle klasse die is afgeleid van CriticalFinalizerObject, kan bijvoorbeeld een standaard finalizer uitvoeren om bestaande gebufferde gegevens leeg te maken.

In de meeste gevallen hoeft u geen klassen te schrijven die zijn afgeleid van de CriticalFinalizerObject klasse. .NET Framework-klassebibliotheek biedt twee klassen, SafeHandle en CriticalHandle, die essentiële finalisatiefunctionaliteit bieden voor het verwerken van resources. Bovendien biedt .NET Framework een set vooraf geschreven klassen die zijn afgeleid van de klasse SafeHandle en deze set bevindt zich in de naamruimte Microsoft.Win32.SafeHandles. Deze klassen zijn ontworpen om algemene functionaliteit te bieden voor ondersteunende bestands- en besturingssysteemingangen.

Zie ook

• SafeHandle
• CriticalHandle
• Microsoft.Win32.SafeHandles
• Beperkte uitvoeringsregio's
• Aanbevolen procedures voor betrouwbaarheid