CriticalFinalizerObject Klasse

Definition

Stellt sicher, dass der gesamte Finalisierungscode in abgeleiteten Klassen als wichtig markiert wird.

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
Vererbung
CriticalFinalizerObject
Abgeleitet
Attribute

Beispiele

Das folgende Codebeispiel zeigt die Verwendung der SafeFileHandle -Klasse, um eine kritische Finalisierung für die Standardeingabe- und Ausgabestreams bereitzustellen. Das SafeFileHandlevon der SafeHandle -Klasse abgeleitete wird an den Dateidatenstrom im FileStream Konstruktor übergeben.

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

Hinweise

Von der CriticalFinalizerObject -Klasse abgeleitete Klassen werden implizit als eingeschränkte Ausführungsregion (Cer) behandelt. Dies erfordert Code im Finalizer, um nur Code mit einem starken Zuverlässigkeitsvertrag aufzurufen. Weitere Informationen zu CERs finden Sie im System.Runtime.ConstrainedExecution Namespace.

In klassen, die von der CriticalFinalizerObject -Klasse abgeleitet werden, garantiert die Common Language Runtime (CLR), dass allen kritischen Finalisierungscode die Möglichkeit zur Ausführung gewährt wird, sofern der Finalizer den Regeln für eine CER folgt, selbst in Situationen, in denen die CLR eine Anwendungsdomäne zwangsweise entlädt oder einen Thread abbricht. Wenn ein Finalizer gegen die Regeln für eine CER verstößt, wird er möglicherweise nicht erfolgreich ausgeführt. Darüber hinaus stellt die CLR eine schwache Reihenfolge zwischen normalen und kritischen Finalizern fest: Für Objekte, die gleichzeitig von der Garbage Collection beansprucht werden, werden alle nicht kritischen Finalizer vor einem der kritischen Finalizer aufgerufen. Beispielsweise kann eine Klasse wie FileStream, die Daten in der SafeHandle von CriticalFinalizerObjectabgeleiteten Klasse enthält, einen Standard-Finalizer ausführen, um vorhandene gepufferte Daten auszuleeren.

In den meisten Fällen müssen Sie keine Klassen schreiben, die von der CriticalFinalizerObject -Klasse abgeleitet sind. Die .NET Framework Klassenbibliothek bietet zwei Klassen und SafeHandleCriticalHandle, die kritische Finalisierungsfunktionen für die Verarbeitung von Ressourcen bereitstellen. Darüber hinaus stellt die .NET Framework eine Reihe von vorgeschriebenen Klassen bereit, die von der SafeHandle -Klasse abgeleitet sind, und diese Gruppe befindet sich im Microsoft.Win32.SafeHandles -Namespace. Diese Klassen sind so konzipiert, dass sie allgemeine Funktionen für die Unterstützung von Datei- und Betriebssystemhandles bereitstellen.

Konstruktoren

CriticalFinalizerObject()

Initialisiert eine neue Instanz der CriticalFinalizerObject-Klasse.

Methoden

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
Finalize()

Gibt alle von der CriticalFinalizerObject-Klasse verwendeten Ressourcen frei.

GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)

Gilt für

Siehe auch