RegistryKey Klasse

Definition

Stellt einen Knoten auf Schlüsselebene in der Windows-Registrierung dar.Represents a key-level node in the Windows registry. Diese Klasse ist eine Kapselung der Registrierung.This class is a registry encapsulation.

public ref class RegistryKey sealed : MarshalByRefObject, IDisposable
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class RegistryKey : MarshalByRefObject, IDisposable
type RegistryKey = class
    inherit MarshalByRefObject
    interface IDisposable
Public NotInheritable Class RegistryKey
Inherits MarshalByRefObject
Implements IDisposable
Vererbung
Attribute
Implementiert

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie Sie unter HKEY_CURRENT_USER einen Unterschlüssel erstellen, seinen Inhalt ändern und dann den Unterschlüssel löschen.The following code example shows how to create a subkey under HKEY_CURRENT_USER, manipulate its contents, and then delete the subkey.

using namespace System;
using namespace System::Security::Permissions;
using namespace Microsoft::Win32;

int main()
{
   // Create a subkey named Test9999 under HKEY_CURRENT_USER.
   RegistryKey ^ test9999 = Registry::CurrentUser->CreateSubKey( "Test9999" );

   // Create two subkeys under HKEY_CURRENT_USER\Test9999.
   test9999->CreateSubKey( "TestName" )->Close();
   RegistryKey ^ testSettings = test9999->CreateSubKey( "TestSettings" );

   // Create data for the TestSettings subkey.
   testSettings->SetValue( "Language", "French" );
   testSettings->SetValue( "Level", "Intermediate" );
   testSettings->SetValue( "ID", 123 );
   testSettings->Close();

   // Print the information from the Test9999 subkey.
   Console::WriteLine( "There are {0} subkeys under Test9999.", test9999->SubKeyCount.ToString() );
   array<String^>^subKeyNames = test9999->GetSubKeyNames();
   for ( int i = 0; i < subKeyNames->Length; i++ )
   {
      RegistryKey ^ tempKey = test9999->OpenSubKey( subKeyNames[ i ] );
      Console::WriteLine( "\nThere are {0} values for {1}.", tempKey->ValueCount.ToString(), tempKey->Name );
      array<String^>^valueNames = tempKey->GetValueNames();
      for ( int j = 0; j < valueNames->Length; j++ )
      {
         Console::WriteLine( "{0,-8}: {1}", valueNames[ j ], tempKey->GetValue( valueNames[ j ] )->ToString() );

      }
   }
   
   // Delete the ID value.
   testSettings = test9999->OpenSubKey( "TestSettings", true );
   testSettings->DeleteValue( "id" );

   // Verify the deletion.
   Console::WriteLine( dynamic_cast<String^>(testSettings->GetValue(  "id", "ID not found." )) );
   testSettings->Close();

   // Delete or close the new subkey.
   Console::Write( "\nDelete newly created registry key? (Y/N) " );
   if ( Char::ToUpper( Convert::ToChar( Console::Read() ) ) == 'Y' )
   {
      Registry::CurrentUser->DeleteSubKeyTree( "Test9999" );
      Console::WriteLine( "\nRegistry key {0} deleted.", test9999->Name );
   }
   else
   {
      Console::WriteLine( "\nRegistry key {0} closed.", test9999->ToString() );
      test9999->Close();
   }
}
using System;
using System.Security.Permissions;
using Microsoft.Win32;

class RegKey
{
    static void Main()
    {
        // Create a subkey named Test9999 under HKEY_CURRENT_USER.
        RegistryKey test9999 = 
            Registry.CurrentUser.CreateSubKey("Test9999");
        // Create two subkeys under HKEY_CURRENT_USER\Test9999. The
        // keys are disposed when execution exits the using statement.
        using(RegistryKey 
            testName = test9999.CreateSubKey("TestName"),
            testSettings = test9999.CreateSubKey("TestSettings"))
        {
            // Create data for the TestSettings subkey.
            testSettings.SetValue("Language", "French");
            testSettings.SetValue("Level", "Intermediate");
            testSettings.SetValue("ID", 123);
        }

        // Print the information from the Test9999 subkey.
        Console.WriteLine("There are {0} subkeys under {1}.", 
            test9999.SubKeyCount.ToString(), test9999.Name);
        foreach(string subKeyName in test9999.GetSubKeyNames())
        {
            using(RegistryKey 
                tempKey = test9999.OpenSubKey(subKeyName))
            {
                Console.WriteLine("\nThere are {0} values for {1}.", 
                    tempKey.ValueCount.ToString(), tempKey.Name);
                foreach(string valueName in tempKey.GetValueNames())
                {
                    Console.WriteLine("{0,-8}: {1}", valueName, 
                        tempKey.GetValue(valueName).ToString());
                }
            }
        }

        using(RegistryKey 
            testSettings = test9999.OpenSubKey("TestSettings", true))
        {
            // Delete the ID value.
            testSettings.DeleteValue("id");

            // Verify the deletion.
            Console.WriteLine((string)testSettings.GetValue(
                "id", "ID not found."));
        }

        // Delete or close the new subkey.
        Console.Write("\nDelete newly created registry key? (Y/N) ");
        if(Char.ToUpper(Convert.ToChar(Console.Read())) == 'Y')
        {
            Registry.CurrentUser.DeleteSubKeyTree("Test9999");
            Console.WriteLine("\nRegistry key {0} deleted.", 
                test9999.Name);
        }
        else
        {
            Console.WriteLine("\nRegistry key {0} closed.", 
                test9999.ToString());
            test9999.Close();
        }
    }
}
Imports System.Security.Permissions
Imports Microsoft.Win32

Public Class RegKey
    Shared Sub Main()

        ' Create a subkey named Test9999 under HKEY_CURRENT_USER.
        Dim test9999 As RegistryKey = _
            Registry.CurrentUser.CreateSubKey("Test9999")

        ' Create two subkeys under HKEY_CURRENT_USER\Test9999.
        test9999.CreateSubKey("TestName").Close()
        Dim testSettings As RegistryKey = _
            test9999.CreateSubKey("TestSettings")

        ' Create data for the TestSettings subkey.
        testSettings.SetValue("Language", "French")
        testSettings.SetValue("Level", "Intermediate")
        testSettings.SetValue("ID", 123)
        testSettings.Close()

        ' Print the information from the Test9999 subkey.
        Console.WriteLine("There are {0} subkeys under Test9999.", _
            test9999.SubKeyCount.ToString())
        For Each subKeyName As String In test9999.GetSubKeyNames()
            Dim tempKey As RegistryKey = _
                test9999.OpenSubKey(subKeyName)
            Console.WriteLine(vbCrLf & "There are {0} values for " & _
                "{1}.", tempKey.ValueCount.ToString(), tempKey.Name)
            For Each valueName As String In tempKey.GetValueNames()
                Console.WriteLine("{0,-8}: {1}", valueName, _
                    tempKey.GetValue(valueName).ToString())
            Next
        Next

        ' Delete the ID value.
        testSettings = test9999.OpenSubKey("TestSettings", True)
        testSettings.DeleteValue("id")

        ' Verify the deletion.
        Console.WriteLine(CType(testSettings.GetValue( _
            "id", "ID not found."), String))
        testSettings.Close()

        ' Delete or close the new subkey.
        Console.Write(vbCrLf & "Delete newly created " & _
            "registry key? (Y/N) ")
        If Char.ToUpper(Convert.ToChar(Console.Read())) = "Y"C Then
            Registry.CurrentUser.DeleteSubKeyTree("Test9999")
            Console.WriteLine(vbCrLf & "Registry key {0} deleted.", _
                test9999.Name)
        Else
            Console.WriteLine(vbCrLf & "Registry key {0} closed.", _
                test9999.ToString())
            test9999.Close()
        End If
   
    End Sub
End Class

Hinweise

Um eine Instanz von RegistryKeyzu erhalten, verwenden Sie eines der statischen Member Registry der-Klasse.To get an instance of RegistryKey, use one of the static members of the Registry class.

Die Registrierung fungiert als zentrales Repository mit Informationen für das Betriebssystem und die Anwendungen auf einem Computer.The registry acts as a central repository of information for the operating system and the applications on a computer. Die Registrierung wird in einem hierarchischen Format organisiert, basierend auf einer logischen Reihenfolge der darin gespeicherten Elemente (Weitere Informationen Registry finden Sie unter für die basisebenenelemente in dieser Hierarchie).The registry is organized in a hierarchical format, based on a logical ordering of the elements stored within it (please see Registry for the base-level items in this hierarchy). Wenn Sie Informationen in der Registrierung speichern, wählen Sie den entsprechenden Speicherort basierend auf dem Typ der gespeicherten Informationen aus.When storing information in the registry, select the appropriate location based on the type of information being stored. Vermeiden Sie das zerstören von Informationen, die von anderen Anwendungen erstellt wurden, da dies dazu führen kann, dass diese Anwendungen unerwartetes Verhalten aufweisen und auch eine negative Auswirkung auf Ihre eigene Anwendung haben können.Be sure to avoid destroying information created by other applications, because this can cause those applications to exhibit unexpected behavior, and can also have an adverse effect upon your own application.

Wichtig

Dieser Typ implementiert die IDisposable-Schnittstelle.This type implements the IDisposable interface. Nach Abschluss der Verwendung sollten Sie den Typ entweder direkt oder indirekt löschen.When you have finished using the type, you should dispose of it either directly or indirectly. Zum direkten Löschen des Typs rufen Sie seine Dispose-Methode in einem try/catch-Block auf.To dispose of the type directly, call its Dispose method in a try/catch block. Zum indirekten Löschen verwenden Sie ein Sprachkonstrukt wie using (in C#) oder Using (in Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Weitere Informationen finden Sie im Abschnitt „Verwenden eines Objekts, das IDisposable implementiert“ des Themas „Die IDisposable-Schnittstelle“.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Registrierungsschlüssel sind die Basiseinheit der Organisation in der Registrierung und können mit Ordnern im Datei-Explorer verglichen werden.Registry keys are the base unit of organization in the registry, and can be compared to folders in File Explorer. Ein bestimmter Schlüssel kann Unterschlüssel aufweisen, ebenso wie ein Ordner Unterordner aufweisen kann.A particular key can have subkeys, just as a folder can have subfolders. Jeder Schlüssel kann gelöscht werden, solange der Benutzer über die entsprechenden Berechtigungen verfügt, und der Schlüssel ist kein Basis Schlüssel oder auf der Ebene direkt unter den Basis Schlüsseln.Each key can be deleted, as long as the user has the appropriate permissions to do so, and the key is not a base key or at the level directly under the base keys. Jedem Schlüssel können auch mehrere Werte zugeordnet sein (ein Wert kann mit einer Datei verglichen werden), die zum Speichern der Informationen verwendet werden, z. b. Informationen zu einer Anwendung, die auf dem Computer installiert ist.Each key can also have multiple values associated with it (a value can be compared to a file), which are used to store the information - for example, information about an application installed on the computer. Jeder Wert enthält ein bestimmtes Informationselement, das bei Bedarf abgerufen oder aktualisiert werden kann.Each value holds one particular piece of information, which can be retrieved or updated when required. Beispielsweise können Sie einen RegistryKey für Ihr Unternehmen erstellen, unter dem Schlüssel HKEY_LOCAL_MACHINE\Software und dann einen Unterschlüssel für jede Anwendung, die von Ihrem Unternehmen erstellt wird.For instance, you can create a RegistryKey for your company, under the key HKEY_LOCAL_MACHINE\Software, and then a subkey for each application that your company creates. Jeder Unterschlüssel enthält die Informationen, die für diese Anwendung spezifisch sind, z. b. Farbeinstellungen, Bildschirmposition und Größe oder erkannte Dateierweiterungen.Each subkey holds the information specific to that application, such as color settings, screen location and size, or recognized file extensions.

Beachten Sie, dass die in der Registrierung gespeicherten Informationen für andere Anwendungen und Benutzer verfügbar sind und daher nicht zum Speichern von Sicherheitsdaten oder kritischen Anwendungsinformationen verwendet werden sollten.Note that information stored in the registry is available to other applications and users, and therefore should not be used to store security data or critical application information.

Achtung

Machen Sie RegistryKey Objekte nicht so verfügbar, dass ein schädliches Programm Tausende von bedeutungslosen unter Schlüsseln oder Schlüssel-Wert-Paaren erstellen könnte.Do not expose RegistryKey objects in such a way that a malicious program could create thousands of meaningless subkeys or key/value pairs. Gestatten Sie z. b. nicht, dass Aufrufer beliebige Schlüssel oder Werte eingeben.For example, do not allow callers to enter arbitrary keys or values.

.NET Framework 4.NET Framework 4Ab ist die Länge eines Registrierungsschlüssels nicht mehr auf 255 Zeichen beschränkt.Starting in the .NET Framework 4.NET Framework 4, the length of a registry key is no longer limited to 255 characters.

Eigenschaften

Handle

Ruft ein SafeRegistryHandle-Objekt ab, das den Registrierungsschlüssel darstellt, der vom aktuellen RegistryKey-Objekt gekapselt wird.Gets a SafeRegistryHandle object that represents the registry key that the current RegistryKey object encapsulates.

Name

Ruft den Namen des Schlüssels ab.Retrieves the name of the key.

SubKeyCount

Ruft die Anzahl der Unterschlüssel des aktuellen Schlüssels ab.Retrieves the count of subkeys of the current key.

ValueCount

Ruft die Anzahl der Werte im Schlüssel ab.Retrieves the count of values in the key.

View

Ruft die Ansicht ab, mit der der Registrierungsschlüssel erstellt wurde.Gets the view that was used to create the registry key.

Methoden

Close()

Schließt den Schlüssel und schreibt diesen auf den Datenträger weg, sofern der Inhalt verändert wurde.Closes the key and flushes it to disk if its contents have been modified.

CreateObjRef(Type)

Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Geerbt von MarshalByRefObject)
CreateSubKey(String)

Erstellt einen neuen Unterschlüssel oder öffnet einen vorhandenen Unterschlüssel für Schreibzugriff.Creates a new subkey or opens an existing subkey for write access.

CreateSubKey(String, Boolean)

Erstellt einen neuen Unterschlüssel oder öffnet einen vorhandenen Unterschlüssel mit dem angegebenen Zugriffsmodus.Creates a new subkey or opens an existing subkey with the specified access. Verfügbar ab .NET Framework 4.6.Available starting with .NET Framework 4.6.

CreateSubKey(String, Boolean, RegistryOptions)

Erstellt einen neuen Unterschlüssel oder öffnet einen vorhandenen Unterschlüssel mit dem angegebenen Zugriffsmodus.Creates a new subkey or opens an existing subkey with the specified access. Verfügbar ab .NET Framework 4.6.Available starting with .NET Framework 4.6.

CreateSubKey(String, RegistryKeyPermissionCheck)

Erstellt einen neuen Unterschlüssel oder öffnet einen vorhandenen Unterschlüssel für Schreibzugriff unter Verwendung der angegebenen Berechtigungsprüfungsoption.Creates a new subkey or opens an existing subkey for write access, using the specified permission check option.

CreateSubKey(String, RegistryKeyPermissionCheck, RegistryOptions)

Erstellt oder öffnet einen Unterschlüssel für Schreibzugriff unter Verwendung der angegebenen Berechtigungsprüfungs- und Registrierungsoptionen.Creates a subkey or opens a subkey for write access, using the specified permission check and registry options.

CreateSubKey(String, RegistryKeyPermissionCheck, RegistryOptions, RegistrySecurity)

Erstellt oder öffnet einen Unterschlüssel für Schreibzugriff unter Verwendung der angegebenen Berechtigungsprüfungsoption, Registrierungsoption und Registrierungssicherheit.Creates a subkey or opens a subkey for write access, using the specified permission check option, registry option, and registry security.

CreateSubKey(String, RegistryKeyPermissionCheck, RegistrySecurity)

Erstellt einen neuen Unterschlüssel oder öffnet einen vorhandenen Unterschlüssel für Schreibzugriff unter Verwendung der angegebenen Berechtigungsprüfungsoption und der Registrierungssicherheit.Creates a new subkey or opens an existing subkey for write access, using the specified permission check option and registry security.

DeleteSubKey(String)

Löscht den angegebenen Unterschlüssel.Deletes the specified subkey.

DeleteSubKey(String, Boolean)

Löscht den angegebenen Unterschlüssel und gibt an, ob eine Ausnahme ausgelöst wird, wenn der Unterschlüssel nicht gefunden wird.Deletes the specified subkey, and specifies whether an exception is raised if the subkey is not found.

DeleteSubKeyTree(String)

Löscht einen Unterschlüssel und alle untergeordneten Unterschlüssel rekursiv.Deletes a subkey and any child subkeys recursively.

DeleteSubKeyTree(String, Boolean)

Löscht den angegebenen Unterschlüssel und untergeordnete Unterschlüssel rekursiv und gibt an, ob eine Ausnahme ausgelöst wird, wenn der Unterschlüssel nicht gefunden wird.Deletes the specified subkey and any child subkeys recursively, and specifies whether an exception is raised if the subkey is not found.

DeleteValue(String)

Löscht den angegebenen Wert aus diesem Schlüssel.Deletes the specified value from this key.

DeleteValue(String, Boolean)

Löscht den angegebenen Wert aus diesem Schlüssel und gibt an, ob eine Ausnahme ausgelöst wird, wenn der Wert nicht gefunden wird.Deletes the specified value from this key, and specifies whether an exception is raised if the value is not found.

Dispose()

Gibt alle von der aktuellen Instanz der RegistryKey-Klasse verwendeten Ressourcen frei.Releases all resources used by the current instance of the RegistryKey class.

Equals(Object)

Ermittelt, ob das angegebene Objekt und das aktuelle Objekt gleich sind.Determines whether the specified object is equal to the current object.

(Geerbt von Object)
Finalize()

Schließt den Schlüssel und leert diesen auf den Datenträger, sofern der Inhalt verändert wurde.Closes the key and flushes it to disk if the contents have been modified.

Flush()

Schreibt alle Attribute des angegebenen geöffneten Registrierungsschlüssels in die Registrierung.Writes all the attributes of the specified open registry key into the registry.

FromHandle(SafeRegistryHandle)

Erstellt einen Registrierungsschlüssel aus einem angegebenen Handle.Creates a registry key from a specified handle.

FromHandle(SafeRegistryHandle, RegistryView)

Erstellt einen Registrierungsschlüssel aus einem angegebenen Handle und einer Registrierungsansichtseinstellung.Creates a registry key from a specified handle and registry view setting.

GetAccessControl()

Gibt die Zugriffssteuerungssicherheit für den aktuellen Registrierungsschlüssel zurück.Returns the access control security for the current registry key.

GetAccessControl(AccessControlSections)

Gibt die angegebenen Abschnitte der Zugriffssteuerungssicherheit für den aktuellen Registrierungsschlüssel zurück.Returns the specified sections of the access control security for the current registry key.

GetHashCode()

Dient als die Standard-HashfunktionServes as the default hash function.

(Geerbt von Object)
GetLifetimeService()

Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Geerbt von MarshalByRefObject)
GetSubKeyNames()

Ruft ein Array von Zeichenfolgen mit den Namen aller Unterschlüssel ab.Retrieves an array of strings that contains all the subkey names.

GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Geerbt von Object)
GetValue(String)

Ruft den Wert ab, der dem angegebenen Namen zugeordnet ist.Retrieves the value associated with the specified name. Gibt null zurück, wenn das Name-Wert-Paar in der Registrierung nicht vorhanden ist.Returns null if the name/value pair does not exist in the registry.

GetValue(String, Object)

Ruft den Wert ab, der dem angegebenen Namen zugeordnet ist.Retrieves the value associated with the specified name. Wenn der Name nicht gefunden wird, wird der von Ihnen bereitgestellte Standardwert zurückgegeben.If the name is not found, returns the default value that you provide.

GetValue(String, Object, RegistryValueOptions)

Ruft den Wert ab, der dem angegebenen Namen und den Abrufoptionen zugeordnet ist.Retrieves the value associated with the specified name and retrieval options. Wenn der Name nicht gefunden wird, wird der von Ihnen bereitgestellte Standardwert zurückgegeben.If the name is not found, returns the default value that you provide.

GetValueKind(String)

Ruft den Registrierungsdatentyp des Werts ab, der dem angegebenen Namen zugeordnet ist.Retrieves the registry data type of the value associated with the specified name.

GetValueNames()

Ruft ein Array von Zeichenfolgen ab, das die Namen aller diesem Schlüssel zugeordneten Werte enthält.Retrieves an array of strings that contains all the value names associated with this key.

InitializeLifetimeService()

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab.Obtains a lifetime service object to control the lifetime policy for this instance.

(Geerbt von MarshalByRefObject)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Geerbt von Object)
MemberwiseClone(Boolean)

Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts.Creates a shallow copy of the current MarshalByRefObject object.

(Geerbt von MarshalByRefObject)
OpenBaseKey(RegistryHive, RegistryView)

Öffnet einen neuen RegistryKey, der den angeforderten Schlüssel auf dem lokalen Computer mit der angegebenen Ansicht darstellt.Opens a new RegistryKey that represents the requested key on the local machine with the specified view.

OpenRemoteBaseKey(RegistryHive, String)

Öffnet einen neuen RegistryKey, der den angeforderten Schlüssel für einen Remotecomputer darstellt.Opens a new RegistryKey that represents the requested key on a remote machine.

OpenRemoteBaseKey(RegistryHive, String, RegistryView)

Öffnet einen neuen Registrierungsschlüssel, der den angeforderten Schlüssel auf einem Remotecomputer mit der angegebenen Ansicht darstellt.Opens a new registry key that represents the requested key on a remote machine with the specified view.

OpenSubKey(String)

Ruft einen Unterschlüssel als schreibgeschützt ab.Retrieves a subkey as read-only.

OpenSubKey(String, Boolean)

Ruft einen angegebenen Unterschlüssel ab und gibt an, ob Schreibzugriff auf den Schlüssel angewendet werden soll.Retrieves a specified subkey, and specifies whether write access is to be applied to the key.

OpenSubKey(String, RegistryKeyPermissionCheck)

Ruft den angegebenen Unterschlüssel für Lesezugriff oder Lese-/Schreibzugriff ab.Retrieves the specified subkey for read or read/write access.

OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights)

Ruft den angegebenen Unterschlüssel für Lesezugriff oder Lese-/Schreibzugriff ab, und fordert die angegebenen Zugriffsrechte an.Retrieves the specified subkey for read or read/write access, requesting the specified access rights.

OpenSubKey(String, RegistryRights)

Ruft einen Unterschlüssel mit dem angegebenen Namen und Zugriffsrechten ab.Retrieves a subkey with the specified name and access rights. Verfügbar ab .NET Framework 4.6.Available starting with .NET Framework 4.6.

SetAccessControl(RegistrySecurity)

Übernimmt Windows-Zugriffssteuerungssicherheit für einen vorhandenen Registrierungsschlüssel.Applies Windows access control security to an existing registry key.

SetValue(String, Object)

Legt das angegebene Name-Wert-Paar fest.Sets the specified name/value pair.

SetValue(String, Object, RegistryValueKind)

Legt mithilfe des angegebenen Registrierungsdatentyps den Wert eines Name-Wert-Paars im Registrierungsschlüssel fest.Sets the value of a name/value pair in the registry key, using the specified registry data type.

ToString()

Ruft eine Zeichenfolgenentsprechung dieses Schlüssels ab.Retrieves a string representation of this key.

Explizite Schnittstellenimplementierungen

IDisposable.Dispose()

Führt Close() für den aktuellen Schlüssel durch.Performs a Close() on the current key.

Erweiterungsmethoden

GetAccessControl(RegistryKey)
GetAccessControl(RegistryKey, AccessControlSections)
SetAccessControl(RegistryKey, RegistrySecurity)

Gilt für:

Siehe auch