Freigeben über

System.Object.Finalize-Methode

Dieser Artikel enthält ergänzende Hinweise zur Referenzdokumentation für diese API.

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 kann daher nur über diese Klasse oder über eine abgeleitete Klasse zugegriffen werden.

Funktionsweise der Finalisierung

Die Object Klasse stellt keine Implementierung für die Finalize Methode bereit, und der Garbage Collector kennzeichnet Typen, die von Object abgeleitet sind, nicht für die Finalisierung, es sei denn, sie überschreiben die Finalize Methode.

Wenn ein Typ die Finalize-Methode überschreibt, fügt der Garbage Collector einen Eintrag für jede Instanz des Typs zu einer internen Struktur hinzu, die als Warteschlange für die Finalisierung bezeichnet wird. Die Warteschlange enthält Einträge für alle Objekte im verwalteten Heap, deren Finalisierungscode ausgeführt werden muss, bevor der Garbage Collector ihren Speicher zurückfordern kann. Der Garbage Collector ruft dann unter den folgenden Bedingungen automatisch die Methode Finalize auf:

  • Nachdem der Garbage Collector festgestellt hat, dass auf ein Objekt nicht zugegriffen werden kann, es sei denn, das Objekt wurde von der Finalisierung 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 von der Finalisierung ausgenommen. Beim Herunterfahren werden auch Objekte, auf die noch zugegriffen werden kann, finalisiert.

Finalize wird nur einmal für eine bestimmte Instanz aufgerufen, es sei denn, das Objekt wird durch einen Mechanismus wie GC.ReRegisterForFinalize erneut registriert und die GC.SuppressFinalize Methode wurde anschließend nicht aufgerufen.

Finalize Vorgänge weisen die folgenden Einschränkungen auf:

  • Der genaue Zeitpunkt, zu dem der Finalizer ausgeführt wird, ist nicht festgelegt. Um die deterministische Freigabe von Ressourcen für Instanzen Ihrer Klasse sicherzustellen, implementieren Sie eine Close Methode oder stellen Sie eine IDisposable.Dispose Implementierung bereit.
  • Die Finalisierer von zwei Objekten werden nicht garantiert in einer bestimmten Reihenfolge ausgeführt, auch wenn sich ein Objekt auf das andere bezieht. Das heißt, wenn Objekt A einen Verweis auf Objekt B hat und beide Finalizer besitzen, wurde Objekt B möglicherweise bereits abgeschlossen, wenn der Finalizer von Objekt A gestartet wird.
  • Der Thread, auf dem der Finalizer ausgeführt wird, ist nicht angegeben.

Die Finalize Methode kann nicht abgeschlossen werden oder unter den folgenden außergewöhnlichen Umständen überhaupt nicht ausgeführt werden:

  • Wenn ein anderer Finalizer auf unbestimmte Zeit blockiert (in eine Endlosschleife gerät, versucht, ein Lock abzurufen, das er nie abrufen kann, usw.). Da die Runtime versucht, Finalizer bis zum Abschluss auszuführen, werden andere Finalizer möglicherweise nicht aufgerufen, wenn ein Finalizer auf unbestimmte Zeit blockiert.
  • Wenn der Prozess abbricht, ohne der Laufzeit die Möglichkeit zu geben, aufzuräumen. In diesem Fall ist die erste Meldung der Laufzeit über die Beendigung des Prozesses eine DLL_PROCESS_DETACH-Meldung.

Die Runtime setzt die Finalisierung von Objekten während des Herunterfahrens nur fort, während die Anzahl der finalisierbaren Objekte weiter abnimmt.

Wenn Finalize oder eine Außerkraftsetzung von Finalize eine Ausnahme auslöst und die Laufzeitumgebung nicht von einer Anwendung gehostet wird, die die Standardrichtlinie überschreibt, 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 freigeben oder zerstören kann.

Überschreiben der Finalize-Methode

Sie sollten Finalize für eine Klasse überschreiben, die nicht verwaltete Ressourcen wie z. B. Datei-Handles oder Datenbankverbindungen verwendet, die freigegeben werden müssen, wenn das verwaltete Objekt, das sie verwendet, bei der Garbage Collection verworfen wird. Sie sollten keine Finalize Methode für verwaltete Objekte implementieren, da der Garbage Collector verwaltete Ressourcen automatisch freigibt.

Von Bedeutung

Wenn ein SafeHandle-Objekt verfügbar ist, das Ihre nicht verwaltete Ressource umhüllt, empfiehlt es sich, das Dispose-Muster mit einem sicheren Handle zu implementieren und Finalize nicht zu überschreiben. Weitere Informationen finden Sie im Abschnitt "SafeHandle-Alternative ".

Die Object.Finalize Methode führt standardmäßig nichts aus, Sie sollten Finalize jedoch nur bei Bedarf außer Kraft setzen, und dies nur, um nicht verwaltete Ressourcen freizugeben. Die Rückgewinnung des Speichers dauert in der Regel viel länger, wenn ein Finalisierungsvorgang ausgeführt wird, da dafür mindestens zwei Garbage Collections erforderlich sind. Darüber hinaus sollten Sie die Finalize Methode nur für Verweistypen außer Kraft setzen. Die Common Language Runtime finalisiert nur Referenztypen. Es ignoriert Finalizer für Werttypen.

Der Bereich der Object.Finalize Methode lautet protected. Sie sollten diesen eingeschränkten Bereich beibehalten, wenn Sie die Methode in Ihrer Klasse außer Kraft setzen. Indem Sie eine Finalize Methode geschützt lassen, verhindern Sie, dass Benutzer Ihrer Anwendung die Methode eines Objekts Finalize direkt aufrufen.

Jede Implementierung von Finalize in einem abgeleiteten Typ muss die Implementierung des Basistyps von Finalize aufrufen. Dies ist der einzige Fall, in dem Anwendungscode Finalize aufrufen darf. Die Methode eines Finalize Objekts 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 Ihren Kurs implementieren. Ein C# Destruktor ruft automatisch den Destruktor seiner Basisklasse auf.

Visual C++ stellt außerdem eine eigene Syntax für die Implementierung der Finalize Methode bereit. Weitere Informationen finden Sie im Abschnitt "Destructors and finalizers" in 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 Finalisierung durchführt. Um Ressourcen sofort freizugeben, können Sie auch das Dispose-Muster 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 Wiederaufnahme eines Objekts (d. h., das Objekt wieder zugänglich zu machen), nachdem es während der Garbage Collection bereinigt wurde. Das Objekt kann jedoch nur einmal wiederbelebt werden; Finalize kann bei wiederbelebten Objekten während der Garbage Collection nicht aufgerufen werden.

Die SafeHandle-Alternative

Das Erstellen zuverlässiger Finalizer ist häufig schwierig, da Sie keine Annahmen über den Zustand Ihrer Anwendung treffen können und da nicht behandelte Systemausnahmen wie OutOfMemoryException und StackOverflowException den Finalizer beenden. 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 zu umschließen und dann das Dispose-Muster ohne Finalizer zu implementieren. Das .NET Framework stellt die folgenden Klassen im Microsoft.Win32-Namespace bereit, die von System.Runtime.InteropServices.SafeHandle abgeleitet sind:

Das folgende Beispiel verwendet das dispose-Muster mit sicheren Handles, anstatt die Finalize-Methode zu überschreiben. Sie definiert eine FileAssociation Klasse, die Registrierungsinformationen über die Anwendung umschließt, die Dateien mit einer bestimmten Dateierweiterung verarbeitet. Die beiden Registrierungshandles, die von Windows out als Parameter zurückgegeben werden, werden an den SafeRegistryHandle Konstruktor übergeben. Die geschützte Methode Dispose des Typs ruft dann die Methode SafeRegistryHandle.Dispose auf, um diese beiden Handles 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