RegistryKey.OpenSubKey Methode

Definition

Namespace:

Microsoft.Win32

Assembly:

Microsoft.Win32.Registry.dll

Ruft den angegebenen Unterschlüssel ab.

Überlädt

OpenSubKey(String, Boolean)	Ruft einen angegebenen Unterschlüssel ab und gibt an, ob Schreibzugriff auf den Schlüssel angewendet werden soll.
OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights)	Ruft den angegebenen Unterschlüssel für Lesezugriff oder Lese-/Schreibzugriff ab, und fordert die angegebenen Zugriffsrechte an.
OpenSubKey(String, RegistryRights)	Ruft einen Unterschlüssel mit dem angegebenen Namen und Zugriffsrechten ab. Verfügbar ab .NET Framework 4.6.
OpenSubKey(String)	Ruft einen Unterschlüssel als schreibgeschützt ab.
OpenSubKey(String, RegistryKeyPermissionCheck)	Ruft den angegebenen Unterschlüssel für Lesezugriff oder Lese-/Schreibzugriff ab.

OpenSubKey(String, Boolean)

Ruft einen angegebenen Unterschlüssel ab und gibt an, ob Schreibzugriff auf den Schlüssel angewendet werden soll.

public:
 Microsoft::Win32::RegistryKey ^ OpenSubKey(System::String ^ name, bool writable);

public Microsoft.Win32.RegistryKey? OpenSubKey (string name, bool writable);

member this.OpenSubKey : string * bool -> Microsoft.Win32.RegistryKey

Public Function OpenSubKey (name As String, writable As Boolean) As RegistryKey

Parameter

name

String

Name oder Pfad des zu öffnenden Unterschlüssels.

writable

Boolean

Muss für Schreibzugriff auf den Schlüssel auf true festgelegt werden.

Gibt zurück

RegistryKey

Der angeforderte Unterschlüssel oder null, wenn bei dem Vorgang ein Fehler aufgetreten ist.

Ausnahmen

ArgumentNullException

name ist null.

ObjectDisposedException

Der RegistryKey ist geschlossen (auf geschlossene Schlüssel kann nicht zugegriffen werden).

SecurityException

Der Benutzer verfügt nicht über die erforderlichen Berechtigungen, um auf den Registrierungsschlüssel im angegebenen Modus zuzugreifen.

Beispiele

Im folgenden Codebeispiel wird ein Testschlüssel erstellt und mithilfe der OpenSubKey -Methode geöffnet, um beide Überladungen der Methode zu demonstrieren.

#using <Microsoft.VisualBasic.dll>

using namespace System;
using namespace Microsoft::Win32;
using namespace Microsoft::VisualBasic;

int main()
{
    // Delete and recreate the test key.
    Registry::CurrentUser->DeleteSubKey( L"RegistryOpenSubKeyExample", false );
    RegistryKey ^ rk = Registry::CurrentUser->CreateSubKey( L"RegistryOpenSubKeyExample" );
    rk->Close();

    // Obtain an instance of RegistryKey for the CurrentUser registry
    // root.
    RegistryKey ^ rkCurrentUser = Registry::CurrentUser;

    // Obtain the test key (read-only) and display it.
    RegistryKey ^ rkTest = rkCurrentUser->OpenSubKey( L"RegistryOpenSubKeyExample" );
    Console::WriteLine( L"Test key: {0}", rkTest );
    rkTest->Close();
    rkCurrentUser->Close();

    // Obtain the test key in one step, using the CurrentUser registry
    // root.
    rkTest = Registry::CurrentUser->OpenSubKey( L"RegistryOpenSubKeyExample" );
    Console::WriteLine( L"Test key: {0}", rkTest );
    rkTest->Close();

    // Open the test key in read/write mode.
    rkTest = Registry::CurrentUser->OpenSubKey( L"RegistryOpenSubKeyExample", true );
    rkTest->SetValue( L"TestName", L"TestValue" );
    Console::WriteLine( L"Test value for TestName: {0}", rkTest->GetValue( L"TestName" ) );
    rkTest->Close();

    return 0;
} //Main

using System;
using Microsoft.Win32;
using Microsoft.VisualBasic;

public class Example
{
    public static void Main()
    {
        // Delete and recreate the test key.
        Registry.CurrentUser.DeleteSubKey("RegistryOpenSubKeyExample", false);
        RegistryKey rk = Registry.CurrentUser.CreateSubKey("RegistryOpenSubKeyExample");
        rk.Close();

        // Obtain an instance of RegistryKey for the CurrentUser registry
        // root.
        RegistryKey rkCurrentUser = Registry.CurrentUser;

        // Obtain the test key (read-only) and display it.
        RegistryKey rkTest = rkCurrentUser.OpenSubKey("RegistryOpenSubKeyExample");
        Console.WriteLine("Test key: {0}", rkTest);
        rkTest.Close();
        rkCurrentUser.Close();

        // Obtain the test key in one step, using the CurrentUser registry
        // root.
        rkTest = Registry.CurrentUser.OpenSubKey("RegistryOpenSubKeyExample");
        Console.WriteLine("Test key: {0}", rkTest);
        rkTest.Close();

        // Open the test key in read/write mode.
        rkTest = Registry.CurrentUser.OpenSubKey("RegistryOpenSubKeyExample", true);
        rkTest.SetValue("TestName", "TestValue");
        Console.WriteLine("Test value for TestName: {0}", rkTest.GetValue("TestName"));
        rkTest.Close();
    } //Main
} //Example

Imports Microsoft.Win32

Public Class Example
    Public Shared Sub Main()
        ' Delete and recreate the test key.
        Registry.CurrentUser.DeleteSubKey("RegistryOpenSubKeyExample", False)
        Dim rk As RegistryKey = Registry.CurrentUser.CreateSubKey("RegistryOpenSubKeyExample")
        rk.Close

        ' Obtain an instance of RegistryKey for the CurrentUser registry 
        ' root. 
        Dim rkCurrentUser As RegistryKey = Registry.CurrentUser

        ' Obtain the test key (read-only) and display it.
        Dim rkTest As RegistryKey = rkCurrentUser.OpenSubKey("RegistryOpenSubKeyExample")
        Console.WriteLine("Test key: {0}", rkTest)
        rkTest.Close
        rkCurrentUser.Close

        ' Obtain the test key in one step, using the CurrentUser registry 
        ' root.
        rkTest = Registry.CurrentUser.OpenSubKey("RegistryOpenSubKeyExample")
        Console.WriteLine("Test key: {0}", rkTest)
        rkTest.Close

        ' Obtain the test key in read/write mode.
        rkTest = Registry.CurrentUser.OpenSubKey("RegistryOpenSubKeyExample", True)
        rkTest.SetValue("TestName", "TestValue")
        Console.WriteLine("Test value for TestName: {0}", rkTest.GetValue("TestName"))
        rkTest.Close
    End Sub
End Class

Hinweise

Wenn der angeforderte Schlüssel nicht vorhanden ist, gibt diese Methode zurück null , anstatt eine Ausnahme zu auslösen.

Wenn writable ist true, wird der Schlüssel zum Lesen und Schreiben geöffnet, andernfalls wird der Schlüssel als schreibgeschützt geöffnet.

Um die OpenSubKey -Methode verwenden zu können, müssen Sie über eine instance der RegistryKey -Methode verfügen. Um eine instance von RegistryKeyabzurufen, verwenden Sie eines der statischen Member der Registry -Klasse.

Weitere Informationen

• CreateSubKey(String)
• DeleteSubKey(String)
• DeleteSubKeyTree(String)
• GetSubKeyNames()
• OpenRemoteBaseKey(RegistryHive, String)
• SubKeyCount
• Registry

OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights)

Ruft den angegebenen Unterschlüssel für Lesezugriff oder Lese-/Schreibzugriff ab, und fordert die angegebenen Zugriffsrechte an.

public:
 Microsoft::Win32::RegistryKey ^ OpenSubKey(System::String ^ name, Microsoft::Win32::RegistryKeyPermissionCheck permissionCheck, System::Security::AccessControl::RegistryRights rights);

public Microsoft.Win32.RegistryKey? OpenSubKey (string name, Microsoft.Win32.RegistryKeyPermissionCheck permissionCheck, System.Security.AccessControl.RegistryRights rights);

member this.OpenSubKey : string * Microsoft.Win32.RegistryKeyPermissionCheck * System.Security.AccessControl.RegistryRights -> Microsoft.Win32.RegistryKey

Public Function OpenSubKey (name As String, permissionCheck As RegistryKeyPermissionCheck, rights As RegistryRights) As RegistryKey

Parameter

name

String

Name oder Pfad des zu erstellenden oder zu öffnenden Unterschlüssels.

permissionCheck

RegistryKeyPermissionCheck

Einer der Enumerationswerte, der angibt, ob der Schlüssel für Lesezugriff oder für Lese-/Schreibzugriff geöffnet wird.

rights

RegistryRights

Eine bitweise Kombination von Enumerationswerten, die den gewünschten Sicherheitszugriff angeben.

Gibt zurück

RegistryKey

Der angeforderte Unterschlüssel oder null, wenn bei dem Vorgang ein Fehler aufgetreten ist.

Ausnahmen

ArgumentNullException

name ist gleich null.

ArgumentException

permissionCheck enthält einen ungültigen Wert.

ObjectDisposedException

Der RegistryKey ist geschlossen (auf geschlossene Schlüssel kann nicht zugegriffen werden).

SecurityException

rights enthält ungültige Werte für Registrierungsrechte.

- oder -

Der Benutzer verfügt nicht über die angeforderten Berechtigungen.

Hinweise

Anstatt eine Ausnahme zu auslösen, gibt diese Methode zurück null , wenn der angeforderte Schlüssel nicht vorhanden ist.

Wenn permissionCheck istRegistryKeyPermissionCheck.ReadWriteSubTree, wird der Schlüssel zum Lesen und Schreiben geöffnet. Wenn permissionCheck oder RegistryKeyPermissionCheck.DefaultistRegistryKeyPermissionCheck.ReadSubTree, wird der Schlüssel zum Lesen geöffnet, es sei denn, der übergeordnete Schlüssel wurde mit RegistryKeyPermissionCheck.ReadWriteSubTreegeöffnet.

Der für permissionCheck angegebene Zugriff hat Vorrang vor dem für rightsangegebenen Zugriff. Wenn Sie beispielsweise für permissionCheck und RegistryRights.WriteKey für rightsangebenRegistryKeyPermissionCheck.ReadSubTree, löst ein Schreibversuch in den Unterschlüssel eine Ausnahme aus.

Um die OpenSubKey -Methode verwenden zu können, müssen Sie über einen instance der RegistryKey -Klasse verfügen. Um eine instance von RegistryKeyabzurufen, verwenden Sie eines der statischen Member der Registry -Klasse.

Weitere Informationen

• CreateSubKey(String)
• DeleteSubKey(String)
• DeleteSubKeyTree(String)
• GetSubKeyNames()
• OpenRemoteBaseKey(RegistryHive, String)
• SubKeyCount
• Registry

OpenSubKey(String, RegistryRights)

Ruft einen Unterschlüssel mit dem angegebenen Namen und Zugriffsrechten ab. Verfügbar ab .NET Framework 4.6.

public:
 Microsoft::Win32::RegistryKey ^ OpenSubKey(System::String ^ name, System::Security::AccessControl::RegistryRights rights);

public Microsoft.Win32.RegistryKey? OpenSubKey (string name, System.Security.AccessControl.RegistryRights rights);

member this.OpenSubKey : string * System.Security.AccessControl.RegistryRights -> Microsoft.Win32.RegistryKey

Public Function OpenSubKey (name As String, rights As RegistryRights) As RegistryKey

Parameter

name

String

Name oder Pfad des zu erstellenden oder zu öffnenden Unterschlüssels.

rights

RegistryRights

Die Berechtigungen für den Registrierungsschlüssel.

Gibt zurück

RegistryKey

Der angeforderte Unterschlüssel oder null, wenn bei dem Vorgang ein Fehler aufgetreten ist.

Ausnahmen

ArgumentNullException

name ist null.

ObjectDisposedException

Der RegistryKey ist geschlossen (auf geschlossene Schlüssel kann nicht zugegriffen werden).

SecurityException

Der Benutzer verfügt nicht über die erforderlichen Berechtigungen, um auf den Registrierungsschlüssel im angegebenen Modus zuzugreifen.

Hinweise

Sie müssen einen Schlüssel öffnen, bevor er mit anderen Methoden und Eigenschaften bearbeitet werden kann. Um einen Schlüssel zu ändern, müssen Sie ihn mit einer Überladung der -Methode öffnen, mit der OpenSubKey Sie Schreibzugriff angeben können.

OpenSubKey(String)

Ruft einen Unterschlüssel als schreibgeschützt ab.

public:
 Microsoft::Win32::RegistryKey ^ OpenSubKey(System::String ^ name);

public Microsoft.Win32.RegistryKey? OpenSubKey (string name);

member this.OpenSubKey : string -> Microsoft.Win32.RegistryKey

Public Function OpenSubKey (name As String) As RegistryKey

Parameter

name

String

Der Name oder der Pfad des Unterschlüssels, der schreibgeschützt geöffnet werden soll.

Gibt zurück

RegistryKey

Der angeforderte Unterschlüssel oder null, wenn bei dem Vorgang ein Fehler aufgetreten ist.

Ausnahmen

ArgumentNullException

name ist gleich null.

ObjectDisposedException

Der RegistryKey ist geschlossen (auf geschlossene Schlüssel kann nicht zugegriffen werden).

SecurityException

Der Benutzer verfügt nicht über die erforderlichen Berechtigungen, um den Registrierungsschlüssel zu lesen.

Beispiele

Im folgenden Codebeispiel wird ein Testschlüssel erstellt und mithilfe der OpenSubKey -Methode geöffnet, um beide Überladungen der Methode zu demonstrieren.

#using <Microsoft.VisualBasic.dll>

using namespace System;
using namespace Microsoft::Win32;
using namespace Microsoft::VisualBasic;

int main()
{
    // Delete and recreate the test key.
    Registry::CurrentUser->DeleteSubKey( L"RegistryOpenSubKeyExample", false );
    RegistryKey ^ rk = Registry::CurrentUser->CreateSubKey( L"RegistryOpenSubKeyExample" );
    rk->Close();

    // Obtain an instance of RegistryKey for the CurrentUser registry
    // root.
    RegistryKey ^ rkCurrentUser = Registry::CurrentUser;

    // Obtain the test key (read-only) and display it.
    RegistryKey ^ rkTest = rkCurrentUser->OpenSubKey( L"RegistryOpenSubKeyExample" );
    Console::WriteLine( L"Test key: {0}", rkTest );
    rkTest->Close();
    rkCurrentUser->Close();

    // Obtain the test key in one step, using the CurrentUser registry
    // root.
    rkTest = Registry::CurrentUser->OpenSubKey( L"RegistryOpenSubKeyExample" );
    Console::WriteLine( L"Test key: {0}", rkTest );
    rkTest->Close();

    // Open the test key in read/write mode.
    rkTest = Registry::CurrentUser->OpenSubKey( L"RegistryOpenSubKeyExample", true );
    rkTest->SetValue( L"TestName", L"TestValue" );
    Console::WriteLine( L"Test value for TestName: {0}", rkTest->GetValue( L"TestName" ) );
    rkTest->Close();

    return 0;
} //Main

using System;
using Microsoft.Win32;
using Microsoft.VisualBasic;

public class Example
{
    public static void Main()
    {
        // Delete and recreate the test key.
        Registry.CurrentUser.DeleteSubKey("RegistryOpenSubKeyExample", false);
        RegistryKey rk = Registry.CurrentUser.CreateSubKey("RegistryOpenSubKeyExample");
        rk.Close();

        // Obtain an instance of RegistryKey for the CurrentUser registry
        // root.
        RegistryKey rkCurrentUser = Registry.CurrentUser;

        // Obtain the test key (read-only) and display it.
        RegistryKey rkTest = rkCurrentUser.OpenSubKey("RegistryOpenSubKeyExample");
        Console.WriteLine("Test key: {0}", rkTest);
        rkTest.Close();
        rkCurrentUser.Close();

        // Obtain the test key in one step, using the CurrentUser registry
        // root.
        rkTest = Registry.CurrentUser.OpenSubKey("RegistryOpenSubKeyExample");
        Console.WriteLine("Test key: {0}", rkTest);
        rkTest.Close();

        // Open the test key in read/write mode.
        rkTest = Registry.CurrentUser.OpenSubKey("RegistryOpenSubKeyExample", true);
        rkTest.SetValue("TestName", "TestValue");
        Console.WriteLine("Test value for TestName: {0}", rkTest.GetValue("TestName"));
        rkTest.Close();
    } //Main
} //Example

Imports Microsoft.Win32

Public Class Example
    Public Shared Sub Main()
        ' Delete and recreate the test key.
        Registry.CurrentUser.DeleteSubKey("RegistryOpenSubKeyExample", False)
        Dim rk As RegistryKey = Registry.CurrentUser.CreateSubKey("RegistryOpenSubKeyExample")
        rk.Close

        ' Obtain an instance of RegistryKey for the CurrentUser registry 
        ' root. 
        Dim rkCurrentUser As RegistryKey = Registry.CurrentUser

        ' Obtain the test key (read-only) and display it.
        Dim rkTest As RegistryKey = rkCurrentUser.OpenSubKey("RegistryOpenSubKeyExample")
        Console.WriteLine("Test key: {0}", rkTest)
        rkTest.Close
        rkCurrentUser.Close

        ' Obtain the test key in one step, using the CurrentUser registry 
        ' root.
        rkTest = Registry.CurrentUser.OpenSubKey("RegistryOpenSubKeyExample")
        Console.WriteLine("Test key: {0}", rkTest)
        rkTest.Close

        ' Obtain the test key in read/write mode.
        rkTest = Registry.CurrentUser.OpenSubKey("RegistryOpenSubKeyExample", True)
        rkTest.SetValue("TestName", "TestValue")
        Console.WriteLine("Test value for TestName: {0}", rkTest.GetValue("TestName"))
        rkTest.Close
    End Sub
End Class

Hinweise

Sie müssen einen Schlüssel öffnen, bevor er mit anderen Methoden und Eigenschaften bearbeitet werden kann. Um einen Schlüssel zu ändern, müssen Sie ihn mit einer Überladung der -Methode öffnen, mit der OpenSubKey Sie Schreibzugriff angeben können, z. B. die OpenSubKey(String, RegistryKeyPermissionCheck) Überladung oder die OpenSubKey(String, Boolean) Überladung.

Wenn der angegebene Unterschlüssel nicht gefunden werden kann, wird zurückgegeben null .

Um die OpenSubKey -Methode verwenden zu können, müssen Sie über einen instance von RegistryKeyverfügen. Verwenden Sie zum Abrufen eines instance von RegistryKeydas eines der statischen Member der Registry -Klasse.

Weitere Informationen

• CreateSubKey(String)
• DeleteSubKey(String)
• DeleteSubKeyTree(String)
• GetSubKeyNames()
• OpenRemoteBaseKey(RegistryHive, String)
• SubKeyCount
• Registry

OpenSubKey(String, RegistryKeyPermissionCheck)

Ruft den angegebenen Unterschlüssel für Lesezugriff oder Lese-/Schreibzugriff ab.

public:
 Microsoft::Win32::RegistryKey ^ OpenSubKey(System::String ^ name, Microsoft::Win32::RegistryKeyPermissionCheck permissionCheck);

public Microsoft.Win32.RegistryKey? OpenSubKey (string name, Microsoft.Win32.RegistryKeyPermissionCheck permissionCheck);

member this.OpenSubKey : string * Microsoft.Win32.RegistryKeyPermissionCheck -> Microsoft.Win32.RegistryKey

Public Function OpenSubKey (name As String, permissionCheck As RegistryKeyPermissionCheck) As RegistryKey

Parameter

name

String

Name oder Pfad des zu erstellenden oder zu öffnenden Unterschlüssels.

permissionCheck

RegistryKeyPermissionCheck

Einer der Enumerationswerte, der angibt, ob der Schlüssel für Lesezugriff oder für Lese-/Schreibzugriff geöffnet wird.

Gibt zurück

RegistryKey

Der angeforderte Unterschlüssel oder null, wenn bei dem Vorgang ein Fehler aufgetreten ist.

Ausnahmen

ArgumentNullException

name ist gleich null.

ArgumentException

permissionCheck enthält einen ungültigen Wert.

ObjectDisposedException

Der RegistryKey ist geschlossen (auf geschlossene Schlüssel kann nicht zugegriffen werden).

SecurityException

Der Benutzer verfügt nicht über die erforderlichen Berechtigungen, um den Registrierungsschlüssel zu lesen.

Beispiele

Im folgenden Codebeispiel wird ein Unterschlüssel mit 100 Schlüssel-Wert-Paaren erstellt und geschlossen. Das Beispiel öffnet den Unterschlüssel mit Default, zeichnet die Zeit auf, die zum Lesen aller Werte benötigt wird, und schließt den Unterschlüssel. Das Beispiel öffnet den Unterschlüssel mit ReadSubTree und zeichnet die Zeit auf, die zum Lesen aller Werte benötigt wird. Schließlich wird im Beispiel die prozentuale Verbesserung berechnet und angezeigt.

using System;
using Microsoft.Win32;
using System.Diagnostics;

public class Example
{
    public static void Main()
    {
        const int LIMIT = 100;
        RegistryKey cu = Registry.CurrentUser;
        const string testKey = "RegistryKeyPermissionCheckExample";

        Console.WriteLine("Generating {0} key/value pairs.", LIMIT);
        RegistryKey rk = cu.CreateSubKey(testKey);
        for (int i = 0; i < LIMIT; i++)
        {
            rk.SetValue("Key" + i, i);
        }

        rk.Close();

        Stopwatch s = new Stopwatch();

        // On the default setting, security is checked every time
        // a key/value pair is read.
        rk = cu.OpenSubKey(testKey, RegistryKeyPermissionCheck.Default);

        s.Start();
        for (int i = 0; i < LIMIT; i++)
        {
            rk.GetValue("Key" + i, i);
        }
        s.Stop();
        rk.Close();
        long delta1 = s.ElapsedTicks;

        s.Reset();

        // When the key is opened with ReadSubTree, security is
        // not checked when the values are read.
        rk = cu.OpenSubKey(testKey, RegistryKeyPermissionCheck.ReadSubTree);

        s.Start();
        for (int i = 0; i < LIMIT; i++)
        {
            rk.GetValue("Key" + i, i);
        }
        s.Stop();
        rk.Close();
        long delta2 = s.ElapsedTicks;

        double faster = (double) (delta1 - delta2) / (double) delta1;
        Console.WriteLine("ReadSubTree is {0}% faster for {1} values.",
            (faster * 100).ToString("0.0"), LIMIT);

        cu.DeleteSubKey(testKey);
    }
}

/* This code example produces output similar to the following:

Generating 100 key/value pairs.
ReadSubTree is 23.4% faster for 100 values.
 */

Imports Microsoft.Win32
Imports System.Diagnostics

Public Class Example
    
    Public Shared Sub Main() 

        Const LIMIT As Integer = 100
        Dim cu As RegistryKey = Registry.CurrentUser
        Const testKey As String = "RegistryKeyPermissionCheckExample"
        
        Console.WriteLine("Generating {0} key/value pairs.", LIMIT)
        Dim rk As RegistryKey = cu.CreateSubKey(testKey)

        For i As Integer = 0 To LIMIT
            rk.SetValue("Key" & i, i)
        Next i
        
        rk.Close()
        
        Dim s As New Stopwatch()
        
        ' On the default setting, security is checked every time
        ' a key/value pair is read.
        rk = cu.OpenSubKey(testKey, _
            RegistryKeyPermissionCheck.Default)
        
        s.Start()
        For i As Integer = 0 To LIMIT
            rk.GetValue("Key" & i, i)
        Next i
        s.Stop()
        rk.Close()
        Dim delta1 As Long = s.ElapsedTicks
        
        s.Reset()
        
        ' When the key is opened with ReadSubTree, security is 
        ' not checked when the values are read.
        rk = cu.OpenSubKey(testKey, _
            RegistryKeyPermissionCheck.ReadSubTree)
        
        s.Start()
        For i As Integer = 0 To LIMIT
            rk.GetValue("Key" & i, i)
        Next i
        s.Stop()
        rk.Close()
        Dim delta2 As Long = s.ElapsedTicks
        
        Dim faster As Double = _
            CDbl(delta1 - delta2) * 100.0 / CDbl(delta1)
        Console.WriteLine("ReadSubTree is {0}% faster for {1} values.", _
            faster.ToString("0.0"), LIMIT)
        
        cu.DeleteSubKey(testKey)
    
    End Sub 
End Class 

' This code example produces output similar to the following:
'
'Generating 100 key/value pairs.
'ReadSubTree is 23.4% faster for 100 values.
'

Hinweise

Anstatt eine Ausnahme zu auslösen, gibt diese Methode zurück null , wenn der angeforderte Schlüssel nicht vorhanden ist.

Wenn permissionCheck istRegistryKeyPermissionCheck.ReadWriteSubTree, wird der Schlüssel zum Lesen und Schreiben geöffnet. Wenn permissionCheck oder RegistryKeyPermissionCheck.DefaultistRegistryKeyPermissionCheck.ReadSubTree, wird der Schlüssel zum Lesen geöffnet, es sei denn, der übergeordnete Schlüssel wurde mit RegistryKeyPermissionCheck.ReadWriteSubTreegeöffnet.

Um die OpenSubKey -Methode verwenden zu können, müssen Sie über einen instance der RegistryKey -Klasse verfügen. Um eine instance von RegistryKeyabzurufen, verwenden Sie eines der statischen Member der Registry -Klasse.

Weitere Informationen

• CreateSubKey(String)
• DeleteSubKey(String)
• DeleteSubKeyTree(String)
• GetSubKeyNames()
• OpenRemoteBaseKey(RegistryHive, String)
• SubKeyCount
• Registry