Object.Finalize Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Gibt einem Objekt Gelegenheit zu dem Versuch, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird.
!Object ()~Object ();abstract member Finalize : unit -> unit
override this.Finalize : unit -> unitFinalize ()Beispiele
Im folgenden Beispiel wird überprüft, ob die Finalize Methode aufgerufen wird, wenn ein Objekt, das außer Finalize Kraft gesetzt wird, zerstört wird. Beachten Sie, dass die Finalize Methode in einer Produktionsanwendung überschrieben wird, um nicht verwaltete Ressourcen freizugeben, die vom Objekt gehalten werden. Beachten Sie außerdem, dass das C#-Beispiel einen Destruktor bereitstellt, anstatt die Finalize Methode außer Kraft zu setzen.
using System;
using System.Diagnostics;
public class ExampleClass
{
Stopwatch sw;
public ExampleClass()
{
sw = Stopwatch.StartNew();
Console.WriteLine("Instantiated object");
}
public void ShowDuration()
{
Console.WriteLine("This instance of {0} has been in existence for {1}",
this, sw.Elapsed);
}
~ExampleClass()
{
Console.WriteLine("Finalizing object");
sw.Stop();
Console.WriteLine("This instance of {0} has been in existence for {1}",
this, sw.Elapsed);
}
}
public class Demo
{
public static void Main()
{
ExampleClass ex = new ExampleClass();
ex.ShowDuration();
}
}
// The example displays output like the following:
// Instantiated object
// This instance of ExampleClass has been in existence for 00:00:00.0011060
// Finalizing object
// This instance of ExampleClass has been in existence for 00:00:00.0036294
open System.Diagnostics
type ExampleClass() =
let sw = Stopwatch.StartNew()
do
printfn "Instantiated object"
member this.ShowDuration() =
printfn $"This instance of {this} has been in existence for {sw.Elapsed}"
override this.Finalize() =
printfn "Finalizing object"
sw.Stop()
printfn $"This instance of {this} has been in existence for {sw.Elapsed}"
let ex = ExampleClass()
ex.ShowDuration()
// The example displays output like the following:
// Instantiated object
// This instance of ExampleClass has been in existence for 00:00:00.0011060
// Finalizing object
// This instance of ExampleClass has been in existence for 00:00:00.0036294
Imports System.Diagnostics
Public Class ExampleClass
Dim sw As StopWatch
Public Sub New()
sw = Stopwatch.StartNew()
Console.WriteLine("Instantiated object")
End Sub
Public Sub ShowDuration()
Console.WriteLine("This instance of {0} has been in existence for {1}",
Me, sw.Elapsed)
End Sub
Protected Overrides Sub Finalize()
Console.WriteLine("Finalizing object")
sw.Stop()
Console.WriteLine("This instance of {0} has been in existence for {1}",
Me, sw.Elapsed)
End Sub
End Class
Module Demo
Public Sub Main()
Dim ex As New ExampleClass()
ex.ShowDuration()
End Sub
End Module
' The example displays output like the following:
' Instantiated object
' This instance of ExampleClass has been in existence for 00:00:00.0011060
' Finalizing object
' This instance of ExampleClass has been in existence for 00:00:00.0036294
Ein weiteres Beispiel, das die Finalize Methode außer Kraft setzt, finden Sie in der GC.SuppressFinalize Methode.
Hinweise
Die Finalize Methode wird verwendet, um Bereinigungsvorgänge für nicht verwaltete Ressourcen auszuführen, die vom aktuellen Objekt gehalten werden, bevor das Objekt zerstört wird. Die Methode ist geschützt und ist daher nur über diese Klasse oder über eine abgeleitete Klasse zugänglich.
In diesem Abschnitt
Funktionsweise der Endisierung
Die Object Klasse stellt keine Implementierung für die Finalize Methode bereit, und der Garbage Collector markiert keine Typen, die von Object der Finalisierung abgeleitet wurden, sofern sie die Finalize Methode außer Kraft setzen.
Wenn ein Typ die Methode außer Kraft setzt, fügt der Garbage Collector für jede Instanz des Typs einen Eintrag zu einer internen Struktur hinzu, die Finalize als Endisierungswarteschlange bezeichnet wird. Die Endisierungswarteschlange enthält Einträge für alle Objekte im verwalteten Heap, deren Endisierungscode ausgeführt werden muss, bevor der Garbage Collector seinen Speicher zurückfordern kann. Der Garbage Collector ruft dann die Finalize Methode automatisch unter den folgenden Bedingungen auf:
Nachdem der Garbage Collector festgestellt hat, dass ein Objekt nicht zugegriffen werden kann, es sei denn, das Objekt wurde von der Endisierung durch einen Aufruf der GC.SuppressFinalize Methode ausgenommen.
Nur bei .NET Framework während des Herunterfahrens einer Anwendungsdomäne, es sei denn, das Objekt ist vom Abschluss ausgenommen. Während des Herunterfahrens werden auch Objekte, die noch zugänglich sind, abgeschlossen.
Finalize wird nur einmal in einer bestimmten Instanz aufgerufen, es sei denn, das Objekt wird mithilfe eines Mechanismus wie GC.ReRegisterForFinalize z GC.SuppressFinalize . B. der Methode erneut registriert.
Finalize Vorgänge verfügen über die folgenden Einschränkungen:
Die genaue Uhrzeit, zu der der Finalizer ausgeführt wird, ist nicht definiert. Um die deterministische Veröffentlichung von Ressourcen für Instanzen Ihrer Klasse sicherzustellen, implementieren Sie eine Methode oder geben Sie eine
CloseIDisposable.Dispose Implementierung an.Die Finalizer von zwei Objekten werden nicht in einer bestimmten Reihenfolge ausgeführt, auch wenn ein Objekt auf die andere verweist. Das heißt, wenn Object A über einen Verweis auf Object B verfügt und beide Finalizer enthalten, wurde Object B möglicherweise bereits abgeschlossen, wenn der Finalizer von Object A gestartet wird.
Der Thread, auf dem der Finalizer ausgeführt wird, ist nicht angegeben.
Die Finalize Methode wird möglicherweise nicht ausgeführt oder kann unter den folgenden außergewöhnlichen Umständen nicht ausgeführt werden:
Wenn ein weiterer Finalizer unbegrenzt blockiert wird (geht in eine unendliche Schleife, versucht, eine Sperre zu erhalten, die sie nie abrufen kann und so weiter). Da die Laufzeit versucht, Finalizer zum Abschluss auszuführen, werden möglicherweise andere Finalizer nicht aufgerufen, wenn ein Finalizer unbegrenzt blockiert wird.
Wenn der Prozess beendet wird, ohne die Laufzeit zu bereinigen. In diesem Fall ist die erste Benachrichtigung über die Beendigung des Prozesses eine DLL_PROCESS_DETACH Benachrichtigung.
Die Laufzeit beendet weiterhin Objekte während des Herunterfahrens, während die Anzahl der finalizierbaren Objekte weiterhin verringert wird.
Wenn Finalize oder eine Außerkraftsetzung Finalize einer Ausnahme ausgelöst wird und die Laufzeit nicht von einer Anwendung gehostet wird, die die Standardrichtlinie außer Kraft setzt, beendet die Laufzeit den Prozess und keine aktiven try/finally Blöcke oder Finalizer werden ausgeführt. Dieses Verhalten stellt die Prozessintegrität sicher, wenn der Finalizer Ressourcen nicht frei oder zerstören kann.
Überschreiben der Finalize-Methode
Sie sollten eine Klasse außer Kraft Finalize setzen, die nicht verwaltete Ressourcen verwendet, z. B. Dateihandpunkte oder Datenbankverbindungen, die veröffentlicht werden müssen, wenn das verwaltete Objekt, das sie verwendet, während der Garbage Collection verworfen wird. Sie sollten keine Finalize Methode für verwaltete Objekte implementieren, da der Garbage Collector verwaltete Ressourcen automatisch veröffentlicht.
Wichtig
Wenn ein SafeHandle Objekt verfügbar ist, das Ihre nicht verwaltete Ressource umschließt, empfiehlt es sich, das Entsorgungsmuster mit einem sicheren Handle zu implementieren und nicht außer Kraft zu setzen Finalize. Weitere Informationen finden Sie im Abschnitt "SafeHandle" .
Die Object.Finalize Methode führt standardmäßig nichts aus, sie sollten jedoch nur bei Bedarf außer Finalize Kraft setzen und nur nicht verwaltete Ressourcen freigeben. Wenn ein Abschlussvorgang ausgeführt wird, dauert das Zurückgeben des Arbeitsspeichers viel länger, da mindestens zwei Garbage Collections erforderlich sind. Darüber hinaus sollten Sie die Finalize Methode nur für Referenztypen außer Kraft setzen. Die allgemeine Sprachlaufzeit beendet nur Referenztypen. Es ignoriert Finalizer für Werttypen.
Der Bereich der Object.Finalize Methode ist protected. Sie sollten diesen eingeschränkten Gültigkeitsbereich beibehalten, wenn Sie die Methode in der Klasse überschreiben. Indem Sie eine Finalize Methode geschützt halten, verhindern Sie, dass Benutzer Ihrer Anwendung die Methode eines Objekts Finalize direkt aufrufen.
Jede Implementierung in Finalize einem abgeleiteten Typ muss die Implementierung des FinalizeBasistyps aufrufen. Dies ist der einzige Fall, in dem Anwendungscode aufgerufen Finalizewerden darf. Die Methode eines Objekts Finalize sollte keine Methode für andere Objekte als die der Basisklasse aufrufen. Der Grund hierfür ist, dass das aufrufende Objekt möglicherweise zur gleichen Zeit an die Garbage Collection übergeben wird wie die anderen aufgerufenen Objekte, z. B. wenn eine Common Language Runtime beendet wird.
Hinweis
Der C#-Compiler ermöglicht es Ihnen nicht, die Finalize Methode außer Kraft zu setzen. Stattdessen stellen Sie einen Finalizer bereit, indem Sie einen Destruktor für Ihre Klasse implementieren. Ein C#-Destruktor ruft automatisch den Destruktor seiner Basisklasse auf.
Visual C++ bietet auch eine eigene Syntax für die Implementierung der Finalize Methode. Weitere Informationen finden Sie im Abschnitt "Destructors und Finalizers" von How to: Define and Consume Classes and Structs (C++/CLI).
Da die Garbage Collection nicht deterministisch ist, wissen Sie nicht genau, wann der Garbage Collector die Fertigstellung durchführt. Um Ressourcen sofort freizugeben, können Sie auch das Entsorgungsmuster und die IDisposable Schnittstelle implementieren. Die IDisposable.Dispose Implementierung kann von Verbrauchern Ihrer Klasse aufgerufen werden, um nicht verwaltete Ressourcen freizugeben, und Sie können die Finalize Methode verwenden, um nicht verwaltete Ressourcen freizugeben, wenn die Dispose Methode nicht aufgerufen wird.
Finalize kann fast jede Aktion ausführen, einschließlich der Resurrecting eines Objekts (das heißt, das Objekt kann erneut zugänglich gemacht werden), nachdem es während der Garbage Collection gelöscht wurde. Das Objekt kann jedoch nur einmal wiederbelebt werden; Finalize Während der Garbage Collection können keine wiederbelebten Objekte aufgerufen werden.
Die SafeHandle-Alternative
Das Erstellen zuverlässiger Finalizer ist häufig schwierig, da Sie keine Annahmen über den Status Ihrer Anwendung treffen können, und weil nicht behandelte Systemabnahmen wie z OutOfMemoryException . B. und StackOverflowException Beenden des Finalizers nicht möglich sind. Anstatt einen Finalizer für Ihre Klasse zu implementieren, um nicht verwaltete Ressourcen freizugeben, können Sie ein Objekt verwenden, das von der System.Runtime.InteropServices.SafeHandle Klasse abgeleitet wird, um Ihre nicht verwalteten Ressourcen umzuschließen und dann das Entsorgungsmuster ohne Finalizer zu implementieren. Die .NET Framework stellt die folgenden Klassen im Namespace bereit, die Microsoft.Win32 von System.Runtime.InteropServices.SafeHandle:
SafeFileHandle ist eine Wrapperklasse für einen Dateihandpunkt.
SafeMemoryMappedFileHandle ist eine Wrapperklasse für Speicherzuordnungsdateihandles.
SafeMemoryMappedViewHandle ist eine Wrapperklasse für einen Zeiger auf einen Block des nicht verwalteten Arbeitsspeichers.
SafeNCryptKeyHandle, SafeNCryptProviderHandleund SafeNCryptSecretHandle sind Wrapperklassen für kryptografische Handle.
SafePipeHandle ist eine Wrapperklasse für Rohrziehpunkte.
SafeRegistryHandle ist eine Wrapperklasse für einen Handle zu einem Registrierungsschlüssel.
SafeWaitHandle ist eine Wrapperklasse für einen Wartepunkt.
Im folgenden Beispiel wird das Dispose-Muster mit sicheren Ziehpunkten verwendet, anstatt die Finalize Methode außer Kraft zu setzen. Es definiert eine FileAssociation Klasse, die Registrierungsinformationen über die Anwendung umschließt, die Dateien mit einer bestimmten Dateierweiterung behandelt. Die beiden Registrierungshandles, die von Windows RegOpenKeyEx-Funktionsaufrufen zurückgegeben out werden, werden an den SafeRegistryHandle Konstruktor übergeben. Die geschützte Dispose Methode des Typs ruft dann die SafeRegistryHandle.Dispose Methode auf, um diese beiden Handle freizugeben.
using Microsoft.Win32.SafeHandles;
using System;
using System.ComponentModel;
using System.IO;
using System.Runtime.InteropServices;
public class FileAssociationInfo : IDisposable
{
// Private variables.
private String ext;
private String openCmd;
private String args;
private SafeRegistryHandle hExtHandle, hAppIdHandle;
// Windows API calls.
[DllImport("advapi32.dll", CharSet= CharSet.Auto, SetLastError=true)]
private static extern int RegOpenKeyEx(IntPtr hKey,
String lpSubKey, int ulOptions, int samDesired,
out IntPtr phkResult);
[DllImport("advapi32.dll", CharSet= CharSet.Unicode, EntryPoint = "RegQueryValueExW",
SetLastError=true)]
private static extern int RegQueryValueEx(IntPtr hKey,
string lpValueName, int lpReserved, out uint lpType,
string lpData, ref uint lpcbData);
[DllImport("advapi32.dll", SetLastError = true)]
private static extern int RegSetValueEx(IntPtr hKey, [MarshalAs(UnmanagedType.LPStr)] string lpValueName,
int Reserved, uint dwType, [MarshalAs(UnmanagedType.LPStr)] string lpData,
int cpData);
[DllImport("advapi32.dll", SetLastError=true)]
private static extern int RegCloseKey(UIntPtr hKey);
// Windows API constants.
private const int HKEY_CLASSES_ROOT = unchecked((int) 0x80000000);
private const int ERROR_SUCCESS = 0;
private const int KEY_QUERY_VALUE = 1;
private const int KEY_SET_VALUE = 0x2;
private const uint REG_SZ = 1;
private const int MAX_PATH = 260;
public FileAssociationInfo(String fileExtension)
{
int retVal = 0;
uint lpType = 0;
if (!fileExtension.StartsWith("."))
fileExtension = "." + fileExtension;
ext = fileExtension;
IntPtr hExtension = IntPtr.Zero;
// Get the file extension value.
retVal = RegOpenKeyEx(new IntPtr(HKEY_CLASSES_ROOT), fileExtension, 0, KEY_QUERY_VALUE, out hExtension);
if (retVal != ERROR_SUCCESS)
throw new Win32Exception(retVal);
// Instantiate the first SafeRegistryHandle.
hExtHandle = new SafeRegistryHandle(hExtension, true);
string appId = new string(' ', MAX_PATH);
uint appIdLength = (uint) appId.Length;
retVal = RegQueryValueEx(hExtHandle.DangerousGetHandle(), String.Empty, 0, out lpType, appId, ref appIdLength);
if (retVal != ERROR_SUCCESS)
throw new Win32Exception(retVal);
// We no longer need the hExtension handle.
hExtHandle.Dispose();
// Determine the number of characters without the terminating null.
appId = appId.Substring(0, (int) appIdLength / 2 - 1) + @"\shell\open\Command";
// Open the application identifier key.
string exeName = new string(' ', MAX_PATH);
uint exeNameLength = (uint) exeName.Length;
IntPtr hAppId;
retVal = RegOpenKeyEx(new IntPtr(HKEY_CLASSES_ROOT), appId, 0, KEY_QUERY_VALUE | KEY_SET_VALUE,
out hAppId);
if (retVal != ERROR_SUCCESS)
throw new Win32Exception(retVal);
// Instantiate the second SafeRegistryHandle.
hAppIdHandle = new SafeRegistryHandle(hAppId, true);
// Get the executable name for this file type.
string exePath = new string(' ', MAX_PATH);
uint exePathLength = (uint) exePath.Length;
retVal = RegQueryValueEx(hAppIdHandle.DangerousGetHandle(), String.Empty, 0, out lpType, exePath, ref exePathLength);
if (retVal != ERROR_SUCCESS)
throw new Win32Exception(retVal);
// Determine the number of characters without the terminating null.
exePath = exePath.Substring(0, (int) exePathLength / 2 - 1);
// Remove any environment strings.
exePath = Environment.ExpandEnvironmentVariables(exePath);
int position = exePath.IndexOf('%');
if (position >= 0) {
args = exePath.Substring(position);
// Remove command line parameters ('%0', etc.).
exePath = exePath.Substring(0, position).Trim();
}
openCmd = exePath;
}
public String Extension
{ get { return ext; } }
public String Open
{ get { return openCmd; }
set {
if (hAppIdHandle.IsInvalid | hAppIdHandle.IsClosed)
throw new InvalidOperationException("Cannot write to registry key.");
if (! File.Exists(value)) {
string message = String.Format("'{0}' does not exist", value);
throw new FileNotFoundException(message);
}
string cmd = value + " %1";
int retVal = RegSetValueEx(hAppIdHandle.DangerousGetHandle(), String.Empty, 0,
REG_SZ, value, value.Length + 1);
if (retVal != ERROR_SUCCESS)
throw new Win32Exception(retVal);
} }
public void Dispose()
{
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
protected void Dispose(bool disposing)
{
// Ordinarily, we release unmanaged resources here;
// but all are wrapped by safe handles.
// Release disposable objects.
if (disposing) {
if (hExtHandle != null) hExtHandle.Dispose();
if (hAppIdHandle != null) hAppIdHandle.Dispose();
}
}
}
open Microsoft.Win32.SafeHandles
open System
open System.ComponentModel
open System.IO
open System.Runtime.InteropServices
// Windows API constants.
let HKEY_CLASSES_ROOT = 0x80000000
let ERROR_SUCCESS = 0
let KEY_QUERY_VALUE = 1
let KEY_SET_VALUE = 0x2
let REG_SZ = 1u
let MAX_PATH = 260
// Windows API calls.
[<DllImport("advapi32.dll", CharSet= CharSet.Auto, SetLastError=true)>]
extern int RegOpenKeyEx(nativeint hKey, string lpSubKey, int ulOptions, int samDesired, nativeint& phkResult)
[<DllImport("advapi32.dll", CharSet= CharSet.Unicode, EntryPoint = "RegQueryValueExW", SetLastError=true)>]
extern int RegQueryValueEx(nativeint hKey, string lpValueName, int lpReserved, uint& lpType, string lpData, uint& lpcbData)
[<DllImport("advapi32.dll", SetLastError = true)>]
extern int RegSetValueEx(nativeint hKey, [<MarshalAs(UnmanagedType.LPStr)>] string lpValueName, int Reserved, uint dwType, [<MarshalAs(UnmanagedType.LPStr)>] string lpData, int cpData)
[<DllImport("advapi32.dll", SetLastError=true)>]
extern int RegCloseKey(unativeint hKey)
type FileAssociationInfo(fileExtension: string) =
// Private values.
let ext =
if fileExtension.StartsWith "." |> not then
"." + fileExtension
else
fileExtension
let mutable args = ""
let mutable hAppIdHandle = Unchecked.defaultof<SafeRegistryHandle>
let mutable hExtHandle = Unchecked.defaultof<SafeRegistryHandle>
let openCmd =
let mutable lpType = 0u
let mutable hExtension = 0n
// Get the file extension value.
let retVal = RegOpenKeyEx(nativeint HKEY_CLASSES_ROOT, fileExtension, 0, KEY_QUERY_VALUE, &hExtension)
if retVal <> ERROR_SUCCESS then
raise (Win32Exception retVal)
// Instantiate the first SafeRegistryHandle.
hExtHandle <- new SafeRegistryHandle(hExtension, true)
let appId = String(' ', MAX_PATH)
let mutable appIdLength = uint appId.Length
let retVal = RegQueryValueEx(hExtHandle.DangerousGetHandle(), String.Empty, 0, &lpType, appId, &appIdLength)
if retVal <> ERROR_SUCCESS then
raise (Win32Exception retVal)
// We no longer need the hExtension handle.
hExtHandle.Dispose()
// Determine the number of characters without the terminating null.
let appId = appId.Substring(0, int appIdLength / 2 - 1) + @"\shell\open\Command"
// Open the application identifier key.
let exeName = String(' ', MAX_PATH)
let exeNameLength = uint exeName.Length
let mutable hAppId = 0n
let retVal = RegOpenKeyEx(nativeint HKEY_CLASSES_ROOT, appId, 0, KEY_QUERY_VALUE ||| KEY_SET_VALUE, &hAppId)
if retVal <> ERROR_SUCCESS then
raise (Win32Exception retVal)
// Instantiate the second SafeRegistryHandle.
hAppIdHandle <- new SafeRegistryHandle(hAppId, true)
// Get the executable name for this file type.
let exePath = String(' ', MAX_PATH)
let mutable exePathLength = uint exePath.Length
let retVal = RegQueryValueEx(hAppIdHandle.DangerousGetHandle(), String.Empty, 0, &lpType, exePath, &exePathLength)
if retVal <> ERROR_SUCCESS then
raise (Win32Exception retVal)
// Determine the number of characters without the terminating null.
let exePath =
exePath.Substring(0, int exePathLength / 2 - 1)
// Remove any environment strings.
|> Environment.ExpandEnvironmentVariables
let position = exePath.IndexOf '%'
if position >= 0 then
args <- exePath.Substring position
// Remove command line parameters ('%0', etc.).
exePath.Substring(0, position).Trim()
else
exePath
member _.Extension =
ext
member _.Open
with get () = openCmd
and set (value) =
if hAppIdHandle.IsInvalid || hAppIdHandle.IsClosed then
raise (InvalidOperationException "Cannot write to registry key.")
if not (File.Exists value) then
raise (FileNotFoundException $"'{value}' does not exist")
let cmd = value + " %1"
let retVal = RegSetValueEx(hAppIdHandle.DangerousGetHandle(), String.Empty, 0, REG_SZ, value, value.Length + 1)
if retVal <> ERROR_SUCCESS then
raise (Win32Exception retVal)
member this.Dispose() =
this.Dispose true
GC.SuppressFinalize this
member _.Dispose(disposing) =
// Ordinarily, we release unmanaged resources here
// but all are wrapped by safe handles.
// Release disposable objects.
if disposing then
if hExtHandle <> null then hExtHandle.Dispose()
if hAppIdHandle <> null then hAppIdHandle.Dispose()
interface IDisposable with
member this.Dispose() =
this.Dispose()
Imports Microsoft.Win32.SafeHandles
Imports System.ComponentModel
Imports System.IO
Imports System.Runtime.InteropServices
Imports System.Text
Public Class FileAssociationInfo : Implements IDisposable
' Private variables.
Private ext As String
Private openCmd As String
Private args As String
Private hExtHandle, hAppIdHandle As SafeRegistryHandle
' Windows API calls.
Private Declare Unicode Function RegOpenKeyEx Lib"advapi32.dll" _
Alias "RegOpenKeyExW" (hKey As IntPtr, lpSubKey As String, _
ulOptions As Integer, samDesired As Integer, _
ByRef phkResult As IntPtr) As Integer
Private Declare Unicode Function RegQueryValueEx Lib "advapi32.dll" _
Alias "RegQueryValueExW" (hKey As IntPtr, _
lpValueName As String, lpReserved As Integer, _
ByRef lpType As UInteger, lpData As String, _
ByRef lpcbData As UInteger) As Integer
Private Declare Function RegSetValueEx Lib "advapi32.dll" _
(hKey As IntPtr, _
<MarshalAs(UnmanagedType.LPStr)> lpValueName As String, _
reserved As Integer, dwType As UInteger, _
<MarshalAs(UnmanagedType.LPStr)> lpData As String, _
cpData As Integer) As Integer
Private Declare Function RegCloseKey Lib "advapi32.dll" _
(hKey As IntPtr) As Integer
' Windows API constants.
Private Const HKEY_CLASSES_ROOT As Integer = &h80000000
Private Const ERROR_SUCCESS As Integer = 0
Private Const KEY_QUERY_VALUE As Integer = 1
Private Const KEY_SET_VALUE As Integer = &h2
Private REG_SZ As UInteger = 1
Private Const MAX_PATH As Integer = 260
Public Sub New(fileExtension As String)
Dim retVal As Integer = 0
Dim lpType As UInteger = 0
If Not fileExtension.StartsWith(".") Then
fileExtension = "." + fileExtension
End If
ext = fileExtension
Dim hExtension As IntPtr = IntPtr.Zero
' Get the file extension value.
retVal = RegOpenKeyEx(New IntPtr(HKEY_CLASSES_ROOT), fileExtension, 0,
KEY_QUERY_VALUE, hExtension)
if retVal <> ERROR_SUCCESS Then
Throw New Win32Exception(retVal)
End If
' Instantiate the first SafeRegistryHandle.
hExtHandle = New SafeRegistryHandle(hExtension, True)
Dim appId As New String(" "c, MAX_PATH)
Dim appIdLength As UInteger = CUInt(appId.Length)
retVal = RegQueryValueEx(hExtHandle.DangerousGetHandle(), String.Empty, _
0, lpType, appId, appIdLength)
if retVal <> ERROR_SUCCESS Then
Throw New Win32Exception(retVal)
End If
' We no longer need the hExtension handle.
hExtHandle.Dispose()
' Determine the number of characters without the terminating null.
appId = appId.Substring(0, CInt(appIdLength) \ 2 - 1) + "\shell\open\Command"
' Open the application identifier key.
Dim exeName As New string(" "c, MAX_PATH)
Dim exeNameLength As UInteger = CUInt(exeName.Length)
Dim hAppId As IntPtr
retVal = RegOpenKeyEx(New IntPtr(HKEY_CLASSES_ROOT), appId, 0,
KEY_QUERY_VALUE Or KEY_SET_VALUE, hAppId)
If retVal <> ERROR_SUCCESS Then
Throw New Win32Exception(retVal)
End If
' Instantiate the second SafeRegistryHandle.
hAppIdHandle = New SafeRegistryHandle(hAppId, True)
' Get the executable name for this file type.
Dim exePath As New string(" "c, MAX_PATH)
Dim exePathLength As UInteger = CUInt(exePath.Length)
retVal = RegQueryValueEx(hAppIdHandle.DangerousGetHandle(), _
String.Empty, 0, lpType, exePath, exePathLength)
If retVal <> ERROR_SUCCESS Then
Throw New Win32Exception(retVal)
End If
' Determine the number of characters without the terminating null.
exePath = exePath.Substring(0, CInt(exePathLength) \ 2 - 1)
exePath = Environment.ExpandEnvironmentVariables(exePath)
Dim position As Integer = exePath.IndexOf("%"c)
If position >= 0 Then
args = exePath.Substring(position)
' Remove command line parameters ('%0', etc.).
exePath = exePath.Substring(0, position).Trim()
End If
openCmd = exePath
End Sub
Public ReadOnly Property Extension As String
Get
Return ext
End Get
End Property
Public Property Open As String
Get
Return openCmd
End Get
Set
If hAppIdHandle.IsInvalid Or hAppIdHandle.IsClosed Then
Throw New InvalidOperationException("Cannot write to registry key.")
End If
If Not File.Exists(value) Then
Dim message As String = String.Format("'{0}' does not exist", value)
Throw New FileNotFoundException(message)
End If
Dim cmd As String = value + " %1"
Dim retVal As Integer = RegSetValueEx(hAppIdHandle.DangerousGetHandle(), String.Empty, 0,
REG_SZ, value, value.Length + 1)
If retVal <> ERROR_SUCCESS Then
Throw New Win32Exception(retVal)
End If
End Set
End Property
Public Sub Dispose() _
Implements IDisposable.Dispose
Dispose(disposing:=True)
GC.SuppressFinalize(Me)
End Sub
Protected Sub Dispose(disposing As Boolean)
' Ordinarily, we release unmanaged resources here
' but all are wrapped by safe handles.
' Release disposable objects.
If disposing Then
If hExtHandle IsNot Nothing Then hExtHandle.Dispose()
If hAppIdHandle IsNot Nothing Then hAppIdHandle.Dispose()
End If
End Sub
End Class