RegistryKey.OpenSubKey RegistryKey.OpenSubKey RegistryKey.OpenSubKey RegistryKey.OpenSubKey Method

Définition

Récupère la sous-clé spécifiée.Retrieves the specified subkey.

Surcharges

OpenSubKey(String, Boolean) OpenSubKey(String, Boolean) OpenSubKey(String, Boolean) OpenSubKey(String, Boolean)

Extrait une sous-clé spécifiée et spécifie si un accès en écriture doit être appliquée à la clé.Retrieves a specified subkey, and specifies whether write access is to be applied to the key.

OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights) OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights) OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights) OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights)

Récupère la sous-clé spécifiée pour un accès en lecture ou en lecture/écriture, en demandant les droits d'accès spécifiés.Retrieves the specified subkey for read or read/write access, requesting the specified access rights.

OpenSubKey(String, RegistryRights) OpenSubKey(String, RegistryRights) OpenSubKey(String, RegistryRights) OpenSubKey(String, RegistryRights)

Récupère une sous-clé avec le nom et les droits d’accès spécifiés.Retrieves a subkey with the specified name and access rights. Disponible à partir de .NET Framework 4.6.Available starting with .NET Framework 4.6.

OpenSubKey(String) OpenSubKey(String) OpenSubKey(String) OpenSubKey(String)

Récupère une sous-clé en lecture seule.Retrieves a subkey as read-only.

OpenSubKey(String, RegistryKeyPermissionCheck) OpenSubKey(String, RegistryKeyPermissionCheck) OpenSubKey(String, RegistryKeyPermissionCheck) OpenSubKey(String, RegistryKeyPermissionCheck)

Récupère la sous-clé spécifiée pour un accès en lecture ou en lecture/écriture.Retrieves the specified subkey for read or read/write access.

OpenSubKey(String, Boolean) OpenSubKey(String, Boolean) OpenSubKey(String, Boolean) OpenSubKey(String, Boolean)

Extrait une sous-clé spécifiée et spécifie si un accès en écriture doit être appliquée à la clé.Retrieves a specified subkey, and specifies whether write access is to be applied to the key.

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

Paramètres

name
String String String String

Nom ou chemin d’accès de la sous-clé à ouvrir.Name or path of the subkey to open.

writable
Boolean Boolean Boolean Boolean

La valeur true si vous avez besoin d’accès en écriture à la clé.Set to true if you need write access to the key.

Retours

Sous-clé demandée ou null si l’opération a échoué.The subkey requested, or null if the operation failed.

Exceptions

Le RegistryKey est fermé (les clés fermées sont inaccessibles).The RegistryKey is closed (closed keys cannot be accessed).

L’utilisateur n’a pas les autorisations requises pour accéder à la clé de Registre dans le mode spécifié.The user does not have the permissions required to access the registry key in the specified mode.

Exemples

L’exemple de code suivant crée une clé de test et utilise le OpenSubKey méthode pour l’ouvrir, présentant les deux surcharges de la méthode.The following code example creates a test key and uses the OpenSubKey method to open it, demonstrating both overloads of the method.

#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 System
Imports Microsoft.Win32
Imports Microsoft.VisualBasic

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 'Main
End Class 'Example

Remarques

Si la clé demandée n’existe pas, cette méthode retourne null au lieu de lever une exception.If the requested key does not exist, this method returns null instead of throwing an exception.

Si writable est true, la clé doit être ouvert pour lire et écrire, dans le cas contraire, la clé sera ouvert en lecture seule.If writable is true, the key will be opened for reading and writing, otherwise, the key will be opened as read-only.

Pour pouvoir utiliser le OpenSubKey (méthode), vous devez avoir une instance de la RegistryKey (méthode).In order to use the OpenSubKey method, you must have an instance of the RegistryKey method. Pour obtenir une instance de RegistryKey, utilisez un des membres statiques de la Registry classe.To get an instance of RegistryKey, use one of the static members of the Registry class.

Sécurité

RegistryPermission
pour la capacité à lire la clé de Registre spécifiée.for the ability to read the specified registry key. Énumération associée : ReadAssociated enumeration: Read

SecurityPermission
Pour pouvoir accéder au si de clé de Registre spécifiée est une clé à distance.for the ability to access the specified registry key if it is a remote key. Énumération associée : UnmanagedCodeAssociated enumeration: UnmanagedCode

Voir aussi

OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights) OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights) OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights) OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights)

Récupère la sous-clé spécifiée pour un accès en lecture ou en lecture/écriture, en demandant les droits d'accès spécifiés.Retrieves the specified subkey for read or read/write access, requesting the specified access rights.

public:
 Microsoft::Win32::RegistryKey ^ OpenSubKey(System::String ^ name, Microsoft::Win32::RegistryKeyPermissionCheck permissionCheck, System::Security::AccessControl::RegistryRights rights);
[System.Runtime.InteropServices.ComVisible(false)]
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

Paramètres

name
String String String String

Nom ou chemin d'accès de la sous-clé à créer ou ouvrir.The name or path of the subkey to create or open.

permissionCheck
RegistryKeyPermissionCheck RegistryKeyPermissionCheck RegistryKeyPermissionCheck RegistryKeyPermissionCheck

L'une des valeurs d'énumération qui spécifie si la clé est ouverte pour un accès en lecture ou en lecture/écriture.One of the enumeration values that specifies whether the key is opened for read or read/write access.

rights
RegistryRights RegistryRights RegistryRights RegistryRights

Combinaison d'opérations de bits des valeurs d'énumération qui spécifie l'accès de sécurité souhaité.A bitwise combination of enumeration values that specifies the desired security access.

Retours

Sous-clé demandée ou null si l’opération a échoué.The subkey requested, or null if the operation failed.

Exceptions

permissionCheck contient une valeur non valide.permissionCheck contains an invalid value.

Le RegistryKey est fermé (les clés fermées sont inaccessibles).The RegistryKey is closed (closed keys cannot be accessed).

rights inclut les valeurs de droits d’accès de Registre non valide.rights includes invalid registry rights values.

ou-or- L’utilisateur n’a pas les autorisations demandées.The user does not have the requested permissions.

Remarques

Au lieu de lever une exception, cette méthode retourne null si la clé demandée n’existe pas.Rather than throwing an exception, this method returns null if the requested key does not exist.

Si permissionCheck est RegistryKeyPermissionCheck.ReadWriteSubTree, la clé est ouverte pour la lecture et écriture ; si permissionCheck est RegistryKeyPermissionCheck.ReadSubTree ou RegistryKeyPermissionCheck.Default, la clé est ouverte pour la lecture, sauf si la clé parente a été ouvert avec RegistryKeyPermissionCheck.ReadWriteSubTree.If permissionCheck is RegistryKeyPermissionCheck.ReadWriteSubTree, the key is opened for reading and writing; if permissionCheck is RegistryKeyPermissionCheck.ReadSubTree or RegistryKeyPermissionCheck.Default, the key is opened for reading unless the parent key was opened with RegistryKeyPermissionCheck.ReadWriteSubTree.

L’accès spécifié pour permissionCheck est prioritaire sur l’accès spécifié pour rights.The access specified for permissionCheck takes precedence over the access specified for rights. Par exemple, si vous spécifiez RegistryKeyPermissionCheck.ReadSubTree pour permissionCheck et RegistryRights.WriteKey pour rights, une tentative d’écriture à la sous-clé lève une exception.For example, if you specify RegistryKeyPermissionCheck.ReadSubTree for permissionCheck and RegistryRights.WriteKey for rights, an attempt to write to the subkey throws an exception.

Pour pouvoir utiliser le OpenSubKey (méthode), vous devez avoir une instance de la RegistryKey classe.In order to use the OpenSubKey method, you must have an instance of the RegistryKey class. Pour obtenir une instance de RegistryKey, utilisez un des membres statiques de la Registry classe.To get an instance of RegistryKey, use one of the static members of the Registry class.

Sécurité

RegistryPermission
pour la capacité à lire la clé de Registre spécifiée.for the ability to read the specified registry key. Énumération associée : ReadAssociated enumeration: Read

SecurityPermission
Pour pouvoir accéder au si de clé de Registre spécifiée est une clé à distance.for the ability to access the specified registry key if it is a remote key. Énumération associée : UnmanagedCodeAssociated enumeration: UnmanagedCode

Voir aussi

OpenSubKey(String, RegistryRights) OpenSubKey(String, RegistryRights) OpenSubKey(String, RegistryRights) OpenSubKey(String, RegistryRights)

Récupère une sous-clé avec le nom et les droits d’accès spécifiés.Retrieves a subkey with the specified name and access rights. Disponible à partir de .NET Framework 4.6.Available starting with .NET Framework 4.6.

public:
 Microsoft::Win32::RegistryKey ^ OpenSubKey(System::String ^ name, System::Security::AccessControl::RegistryRights rights);
[System.Runtime.InteropServices.ComVisible(false)]
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

Paramètres

name
String String String String

Nom ou chemin d'accès de la sous-clé à créer ou ouvrir.The name or path of the subkey to create or open.

rights
RegistryRights RegistryRights RegistryRights RegistryRights

Droits pour la clé de Registre.The rights for the registry key.

Retours

Sous-clé demandée ou null si l’opération a échoué.The subkey requested, or null if the operation failed.

Exceptions

Le RegistryKey est fermé (les clés fermées sont inaccessibles).The RegistryKey is closed (closed keys cannot be accessed).

L’utilisateur n’a pas les autorisations requises pour accéder à la clé de Registre dans le mode spécifié.The user does not have the permissions required to access the registry key in the specified mode.

Remarques

Elles peuvent être manipulées avec d’autres méthodes et propriétés, vous devez ouvrir une clé.You must open a key before it can be manipulated with other methods and properties. Pour modifier une clé, vous devez l’ouvrir avec une surcharge de la OpenSubKey méthode qui vous permet de spécifier un accès en écriture.To modify a key, you must open it with an overload of the OpenSubKey method that allows you to specify write access.

OpenSubKey(String) OpenSubKey(String) OpenSubKey(String) OpenSubKey(String)

Récupère une sous-clé en lecture seule.Retrieves a subkey as read-only.

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

Paramètres

name
String String String String

Le nom ou le chemin d’accès de la sous-clé à ouvrir en lecture seule.The name or path of the subkey to open as read-only.

Retours

Sous-clé demandée ou null si l’opération a échoué.The subkey requested, or null if the operation failed.

Exceptions

Le RegistryKey est fermé (les clés fermées sont inaccessibles).The RegistryKey is closed (closed keys cannot be accessed).

L’utilisateur n’a pas les autorisations nécessaires pour lire la clé de Registre.The user does not have the permissions required to read the registry key.

Exemples

L’exemple de code suivant crée une clé de test et utilise le OpenSubKey méthode pour l’ouvrir, présentant les deux surcharges de la méthode.The following code example creates a test key and uses the OpenSubKey method to open it, demonstrating both overloads of the method.

#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 System
Imports Microsoft.Win32
Imports Microsoft.VisualBasic

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 'Main
End Class 'Example

Remarques

Elles peuvent être manipulées avec d’autres méthodes et propriétés, vous devez ouvrir une clé.You must open a key before it can be manipulated with other methods and properties. Pour modifier une clé, vous devez l’ouvrir avec une surcharge de la OpenSubKey méthode qui vous permet de spécifier un accès en écriture, comme le OpenSubKey(String, RegistryKeyPermissionCheck) surcharger ou le OpenSubKey(String, Boolean) de surcharge.To modify a key, you must open it with an overload of the OpenSubKey method that allows you to specify write access, such as the OpenSubKey(String, RegistryKeyPermissionCheck) overload or the OpenSubKey(String, Boolean) overload.

Si la sous-clé spécifiée est introuvable, puis null est retourné.If the specified subkey cannot be found, then null is returned.

Pour pouvoir utiliser le OpenSubKey (méthode), vous devez avoir une instance de RegistryKey.In order to use the OpenSubKey method, you must have an instance of RegistryKey. Pour obtenir une instance de RegistryKey, utilisez l’un des membres statiques de la Registry classe.To get an instance of RegistryKey, use the one of the static members of the Registry class.

Sécurité

RegistryPermission
pour la capacité à lire la clé de Registre spécifiée.for the ability to read the specified registry key. Énumération associée : ReadAssociated enumeration: Read

SecurityPermission
Pour pouvoir accéder au si de clé de Registre spécifiée est une clé à distance.for the ability to access the specified registry key if it is a remote key. Énumération associée : UnmanagedCodeAssociated enumeration: UnmanagedCode

Voir aussi

OpenSubKey(String, RegistryKeyPermissionCheck) OpenSubKey(String, RegistryKeyPermissionCheck) OpenSubKey(String, RegistryKeyPermissionCheck) OpenSubKey(String, RegistryKeyPermissionCheck)

Récupère la sous-clé spécifiée pour un accès en lecture ou en lecture/écriture.Retrieves the specified subkey for read or read/write access.

public:
 Microsoft::Win32::RegistryKey ^ OpenSubKey(System::String ^ name, Microsoft::Win32::RegistryKeyPermissionCheck permissionCheck);
[System.Runtime.InteropServices.ComVisible(false)]
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

Paramètres

name
String String String String

Nom ou chemin d'accès de la sous-clé à créer ou ouvrir.The name or path of the subkey to create or open.

permissionCheck
RegistryKeyPermissionCheck RegistryKeyPermissionCheck RegistryKeyPermissionCheck RegistryKeyPermissionCheck

L'une des valeurs d'énumération qui spécifie si la clé est ouverte pour un accès en lecture ou en lecture/écriture.One of the enumeration values that specifies whether the key is opened for read or read/write access.

Retours

Sous-clé demandée ou null si l’opération a échoué.The subkey requested, or null if the operation failed.

Exceptions

permissionCheck contient une valeur non valide.permissionCheck contains an invalid value.

Le RegistryKey est fermé (les clés fermées sont inaccessibles).The RegistryKey is closed (closed keys cannot be accessed).

L’utilisateur n’a pas les autorisations nécessaires pour lire la clé de Registre.The user does not have the permissions required to read the registry key.

Exemples

L’exemple de code suivant crée une sous-clé contenant 100 paires clé/valeur et le ferme.The following code example creates a subkey containing 100 key/value pairs and closes it. L’exemple ouvre la sous-clé avec Default, enregistre le temps nécessaire pour lire toutes les valeurs, puis ferme la sous-clé.The example opens the subkey with Default, records the time it takes to read all the values, and closes the subkey. L’exemple ouvre la sous-clé avec ReadSubTree et enregistre le temps nécessaire pour lire toutes les valeurs.The example opens the subkey with ReadSubTree and records the time it takes to read all the values. Enfin, l’exemple calcule et affiche le pourcentage d’amélioration.Finally, the example computes and displays the percentage improvement.

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 System
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.
' 

Remarques

Au lieu de lever une exception, cette méthode retourne null si la clé demandée n’existe pas.Rather than throwing an exception, this method returns null if the requested key does not exist.

Si permissionCheck est RegistryKeyPermissionCheck.ReadWriteSubTree, la clé est ouverte pour la lecture et écriture ; si permissionCheck est RegistryKeyPermissionCheck.ReadSubTree ou RegistryKeyPermissionCheck.Default, la clé est ouverte pour la lecture, sauf si la clé parente a été ouvert avec RegistryKeyPermissionCheck.ReadWriteSubTree.If permissionCheck is RegistryKeyPermissionCheck.ReadWriteSubTree, the key is opened for reading and writing; if permissionCheck is RegistryKeyPermissionCheck.ReadSubTree or RegistryKeyPermissionCheck.Default, the key is opened for reading unless the parent key was opened with RegistryKeyPermissionCheck.ReadWriteSubTree.

Pour pouvoir utiliser le OpenSubKey (méthode), vous devez avoir une instance de la RegistryKey classe.In order to use the OpenSubKey method, you must have an instance of the RegistryKey class. Pour obtenir une instance de RegistryKey, utilisez un des membres statiques de la Registry classe.To get an instance of RegistryKey, use one of the static members of the Registry class.

Sécurité

RegistryPermission
pour la capacité à lire la clé de Registre spécifiée.for the ability to read the specified registry key. Énumération associée : ReadAssociated enumeration: Read

SecurityPermission
Pour pouvoir accéder au si de clé de Registre spécifiée est une clé à distance.for the ability to access the specified registry key if it is a remote key. Énumération associée : UnmanagedCodeAssociated enumeration: UnmanagedCode

Voir aussi

S’applique à