RegistryKey.OpenSubKey Méthode

Définition

Espace de noms:

Microsoft.Win32

Assembly:

Microsoft.Win32.Registry.dll

Récupère la sous-clé spécifiée.

Surcharges

OpenSubKey(String, Boolean)	Extrait une sous-clé spécifiée et spécifie si l'accès en écriture doit s'appliquer à la clé.
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.
OpenSubKey(String, RegistryRights)	Récupère une sous-clé avec le nom et les droits d’accès spécifiés. Disponible à partir de .NET Framework 4.6.
OpenSubKey(String)	Récupère une sous-clé en lecture seule.
OpenSubKey(String, RegistryKeyPermissionCheck)	Récupère la sous-clé spécifiée pour un accès en lecture ou en lecture/écriture.

OpenSubKey(String, Boolean)

Extrait une sous-clé spécifiée et spécifie si l'accès en écriture doit s'appliquer à la clé.

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

Nom ou chemin d'accès de la sous-clé à ouvrir.

writable

Boolean

A la valeur true si vous avez besoin d'accéder à la clé en écriture.

Retours

RegistryKey

Sous-clé demandée ou null en cas d'échec de l'opération.

Exceptions

ArgumentNullException

name a la valeur null.

ObjectDisposedException

RegistryKey est fermé (les clés fermées ne sont pas accessibles).

SecurityException

L'utilisateur n'a pas les autorisations requises pour accéder à la clé de Registre dans le mode spécifié.

Exemples

L’exemple de code suivant crée une clé de test et utilise la OpenSubKey méthode pour l’ouvrir, illustrant les deux surcharges de la méthode.

#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

Remarques

Si la clé demandée n’existe pas, cette méthode retourne null au lieu de lever une exception.

Si writable a la valeur true, la clé est ouverte pour la lecture et l’écriture, sinon, la clé est ouverte en lecture seule.

Pour utiliser la OpenSubKey méthode, vous devez disposer d’une instance de la RegistryKey méthode. Pour obtenir une instance de RegistryKey, utilisez l’un des membres statiques de la Registry classe .

Voir aussi

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

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.

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

Paramètres

name

String

Nom ou chemin d'accès de la sous-clé à créer ou ouvrir.

permissionCheck

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.

rights

RegistryRights

Combinaison d'opérations de bits des valeurs d'énumération qui spécifie l'accès de sécurité souhaité.

Retours

RegistryKey

Sous-clé demandée ou null en cas d'échec de l'opération.

Exceptions

ArgumentNullException

name a la valeur null.

ArgumentException

permissionCheck contient une valeur non valide.

ObjectDisposedException

RegistryKey est fermé (les clés fermées ne sont pas accessibles).

SecurityException

rights inclut les valeurs non valides de droits d'accès à la base de registres.

- ou -

L'utilisateur n'a pas les autorisations demandées.

Remarques

Au lieu de lever une exception, cette méthode retourne null si la clé demandée n’existe pas.

Si permissionCheck a la valeur RegistryKeyPermissionCheck.ReadWriteSubTree, la clé est ouverte pour la lecture et l’écriture ; si permissionCheck est RegistryKeyPermissionCheck.ReadSubTree ou RegistryKeyPermissionCheck.Default, la clé est ouverte pour lecture, sauf si la clé parente a été ouverte avec RegistryKeyPermissionCheck.ReadWriteSubTree.

L’accès spécifié pour permissionCheck est prioritaire sur l’accès spécifié pour rights. Par exemple, si vous spécifiez RegistryKeyPermissionCheck.ReadSubTree pour permissionCheck et RegistryRights.WriteKey pour rights, une tentative d’écriture dans la sous-clé lève une exception.

Pour utiliser la OpenSubKey méthode, vous devez disposer d’une instance de la RegistryKey classe . Pour obtenir une instance de RegistryKey, utilisez l’un des membres statiques de la Registry classe .

Voir aussi

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

OpenSubKey(String, RegistryRights)

Récupère une sous-clé avec le nom et les droits d’accès spécifiés. Disponible à partir de .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

Paramètres

name

String

Nom ou chemin d'accès de la sous-clé à créer ou ouvrir.

rights

RegistryRights

Droits pour la clé de Registre.

Retours

RegistryKey

Sous-clé demandée ou null en cas d'échec de l'opération.

Exceptions

ArgumentNullException

name a la valeur null.

ObjectDisposedException

RegistryKey est fermé (les clés fermées ne sont pas accessibles).

SecurityException

L'utilisateur n'a pas les autorisations requises pour accéder à la clé de Registre dans le mode spécifié.

Remarques

Vous devez ouvrir une clé avant de pouvoir la manipuler avec d’autres méthodes et propriétés. Pour modifier une clé, vous devez l’ouvrir avec une surcharge de la OpenSubKey méthode qui vous permet de spécifier l’accès en écriture.

OpenSubKey(String)

Récupère une sous-clé en lecture seule.

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

Nom ou chemin d'accès de la sous-clé à ouvrir en lecture seule.

Retours

RegistryKey

Sous-clé demandée ou null en cas d'échec de l'opération.

Exceptions

ArgumentNullException

name a la valeur null.

ObjectDisposedException

RegistryKey est fermé (les clés fermées ne sont pas accessibles).

SecurityException

L'utilisateur n'a pas les autorisations requises pour lire la clé de Registre.

Exemples

L’exemple de code suivant crée une clé de test et utilise la OpenSubKey méthode pour l’ouvrir, illustrant les deux surcharges de la méthode.

#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

Remarques

Vous devez ouvrir une clé avant de pouvoir la manipuler avec d’autres méthodes et propriétés. Pour modifier une clé, vous devez l’ouvrir avec une surcharge de la OpenSubKey méthode qui vous permet de spécifier l’accès en écriture, comme la OpenSubKey(String, RegistryKeyPermissionCheck) surcharge ou la OpenSubKey(String, Boolean) surcharge.

Si la sous-clé spécifiée est introuvable, elle null est retournée.

Pour utiliser la OpenSubKey méthode, vous devez disposer d’une instance de RegistryKey. Pour obtenir une instance de RegistryKey, utilisez l’un des membres statiques de la Registry classe .

Voir aussi

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

OpenSubKey(String, RegistryKeyPermissionCheck)

Récupère la sous-clé spécifiée pour un accès en lecture ou en lecture/écriture.

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

Paramètres

name

String

Nom ou chemin d'accès de la sous-clé à créer ou ouvrir.

permissionCheck

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.

Retours

RegistryKey

Sous-clé demandée ou null en cas d'échec de l'opération.

Exceptions

ArgumentNullException

name a la valeur null.

ArgumentException

permissionCheck contient une valeur non valide.

ObjectDisposedException

RegistryKey est fermé (les clés fermées ne sont pas accessibles).

SecurityException

L'utilisateur n'a pas les autorisations requises pour lire la clé de Registre.

Exemples

L’exemple de code suivant crée une sous-clé contenant 100 paires clé/valeur et la ferme. L’exemple ouvre la sous-clé avec Default, enregistre le temps nécessaire pour lire toutes les valeurs et ferme la sous-clé. L’exemple ouvre la sous-clé avec ReadSubTree et enregistre le temps nécessaire à la lecture de toutes les valeurs. Enfin, l’exemple calcule et affiche l’amélioration du pourcentage.

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

Remarques

Au lieu de lever une exception, cette méthode retourne null si la clé demandée n’existe pas.

Si permissionCheck a la valeur RegistryKeyPermissionCheck.ReadWriteSubTree, la clé est ouverte pour la lecture et l’écriture ; si permissionCheck est RegistryKeyPermissionCheck.ReadSubTree ou RegistryKeyPermissionCheck.Default, la clé est ouverte pour lecture, sauf si la clé parente a été ouverte avec RegistryKeyPermissionCheck.ReadWriteSubTree.

Pour utiliser la OpenSubKey méthode, vous devez disposer d’une instance de la RegistryKey classe . Pour obtenir une instance de RegistryKey, utilisez l’un des membres statiques de la Registry classe .

Voir aussi

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