Compartir a través de


RegistryKey.OpenSubKey Método

Definición

Recupera la subclave especificada.

Sobrecargas

OpenSubKey(String, Boolean)

Recupera la subclave especificada e indica si debe aplicarse acceso de escritura a la clave.

OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights)

Recupera la subclave especificada para acceso de lectura o acceso de lectura y escritura, solicitando los derechos de acceso especificados.

OpenSubKey(String, RegistryRights)

Recupera una subclave con el nombre y los derechos de acceso especificados. Disponible a partir de .NET Framework 4.6.

OpenSubKey(String)

Recupera una subclave en forma de sólo lectura.

OpenSubKey(String, RegistryKeyPermissionCheck)

Recupera la subclave especificada para acceso de lectura o lectura y escritura.

OpenSubKey(String, Boolean)

Source:
RegistryKey.cs

Recupera la subclave especificada e indica si debe aplicarse acceso de escritura a la clave.

public:
 Microsoft::Win32::RegistryKey ^ OpenSubKey(System::String ^ name, bool writable);
public Microsoft.Win32.RegistryKey OpenSubKey (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

Parámetros

name
String

Nombre o ruta de acceso de la subclave que se va a abrir.

writable
Boolean

Ha de establecerse en true si necesita acceso de escritura a la clave.

Devoluciones

Subclave solicitada, o null si se produjo un error en la operación.

Excepciones

name es null.

El objeto RegistryKey está cerrado (no se puede tener acceso a claves cerradas).

El usuario no tiene los permisos necesarios para tener acceso a la clave del Registro en el modo especificado.

Ejemplos

En el ejemplo de código siguiente se crea una clave de prueba y se usa el OpenSubKey método para abrirla, lo que muestra ambas sobrecargas del método .

#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

Comentarios

Si la clave solicitada no existe, este método devuelve null en lugar de producir una excepción.

Si writable es true, la clave se abrirá para leer y escribir; de lo contrario, la clave se abrirá como de solo lectura.

Para usar el OpenSubKey método , debe tener una instancia del RegistryKey método . Para obtener una instancia de RegistryKey, use uno de los miembros estáticos de la Registry clase .

Consulte también

Se aplica a

OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights)

Source:
RegistryKey.cs

Recupera la subclave especificada para acceso de lectura o acceso de lectura y escritura, solicitando los derechos de acceso especificados.

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);
public Microsoft.Win32.RegistryKey? OpenSubKey (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
[<System.Runtime.InteropServices.ComVisible(false)>]
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

Parámetros

name
String

Nombre o ruta de acceso de la subclave que se va a crear o abrir.

permissionCheck
RegistryKeyPermissionCheck

Uno de los valores de enumeración que especifica si la clave se abre para acceso de lectura o para acceso de lectura y escritura.

rights
RegistryRights

Una combinación bit a bit de los valores de enumeración que especifican el acceso de seguridad deseado.

Devoluciones

Subclave solicitada, o null si se produjo un error en la operación.

Atributos

Excepciones

name es null

permissionCheck contiene un valor no válido.

El objeto RegistryKey está cerrado (no se puede tener acceso a claves cerradas).

rights incluye valores de derechos de Registro no válidos.

o bien

El usuario no tiene los permisos solicitados.

Comentarios

En lugar de iniciar una excepción, este método devuelve null si la clave solicitada no existe.

Si permissionCheck es RegistryKeyPermissionCheck.ReadWriteSubTree, la clave se abre para leer y escribir; si permissionCheck es RegistryKeyPermissionCheck.ReadSubTree o RegistryKeyPermissionCheck.Default, la clave se abre para leer a menos que se abra la clave primaria con RegistryKeyPermissionCheck.ReadWriteSubTree.

El acceso especificado para permissionCheck tiene prioridad sobre el acceso especificado para rights. Por ejemplo, si especifica RegistryKeyPermissionCheck.ReadSubTree para permissionCheck y RegistryRights.WriteKey para rights, un intento de escribir en la subclave produce una excepción.

Para usar el OpenSubKey método , debe tener una instancia de la RegistryKey clase . Para obtener una instancia de RegistryKey, use uno de los miembros estáticos de la Registry clase .

Consulte también

Se aplica a

OpenSubKey(String, RegistryRights)

Source:
RegistryKey.cs

Recupera una subclave con el nombre y los derechos de acceso especificados. Disponible a 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);
public Microsoft.Win32.RegistryKey? OpenSubKey (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
[<System.Runtime.InteropServices.ComVisible(false)>]
member this.OpenSubKey : string * System.Security.AccessControl.RegistryRights -> Microsoft.Win32.RegistryKey
Public Function OpenSubKey (name As String, rights As RegistryRights) As RegistryKey

Parámetros

name
String

Nombre o ruta de acceso de la subclave que se va a crear o abrir.

rights
RegistryRights

Derechos para la clave del Registro.

Devoluciones

Subclave solicitada, o null si se produjo un error en la operación.

Atributos

Excepciones

name es null.

El objeto RegistryKey está cerrado (no se puede tener acceso a claves cerradas).

El usuario no tiene los permisos necesarios para tener acceso a la clave del Registro en el modo especificado.

Comentarios

Debe abrir una clave para poder manipularla con otros métodos y propiedades. Para modificar una clave, debe abrirla con una sobrecarga del OpenSubKey método que le permite especificar el acceso de escritura.

Se aplica a

OpenSubKey(String)

Source:
RegistryKey.cs

Recupera una subclave en forma de sólo lectura.

public:
 Microsoft::Win32::RegistryKey ^ OpenSubKey(System::String ^ name);
public Microsoft.Win32.RegistryKey OpenSubKey (string name);
public Microsoft.Win32.RegistryKey? OpenSubKey (string name);
member this.OpenSubKey : string -> Microsoft.Win32.RegistryKey
Public Function OpenSubKey (name As String) As RegistryKey

Parámetros

name
String

Nombre o ruta de acceso a la subclave que se va a abrir como de solo lectura.

Devoluciones

Subclave solicitada, o null si se produjo un error en la operación.

Excepciones

name es null

El objeto RegistryKey está cerrado (no se puede tener acceso a claves cerradas).

El usuario no tiene los permisos necesarios para leer la clave del Registro.

Ejemplos

En el ejemplo de código siguiente se crea una clave de prueba y se usa el OpenSubKey método para abrirla, lo que muestra ambas sobrecargas del método .

#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

Comentarios

Debe abrir una clave para poder manipularla con otros métodos y propiedades. Para modificar una clave, debe abrirla con una sobrecarga del OpenSubKey método que le permite especificar el acceso de escritura, como la OpenSubKey(String, RegistryKeyPermissionCheck) sobrecarga o la OpenSubKey(String, Boolean) sobrecarga.

Si no se encuentra la subclave especificada, null se devuelve .

Para usar el OpenSubKey método , debe tener una instancia de RegistryKey. Para obtener una instancia de RegistryKey, use uno de los miembros estáticos de la Registry clase .

Consulte también

Se aplica a

OpenSubKey(String, RegistryKeyPermissionCheck)

Source:
RegistryKey.cs

Recupera la subclave especificada para acceso de lectura o lectura y escritura.

public:
 Microsoft::Win32::RegistryKey ^ OpenSubKey(System::String ^ name, Microsoft::Win32::RegistryKeyPermissionCheck permissionCheck);
public Microsoft.Win32.RegistryKey OpenSubKey (string name, Microsoft.Win32.RegistryKeyPermissionCheck permissionCheck);
public Microsoft.Win32.RegistryKey? OpenSubKey (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
[<System.Runtime.InteropServices.ComVisible(false)>]
member this.OpenSubKey : string * Microsoft.Win32.RegistryKeyPermissionCheck -> Microsoft.Win32.RegistryKey
Public Function OpenSubKey (name As String, permissionCheck As RegistryKeyPermissionCheck) As RegistryKey

Parámetros

name
String

Nombre o ruta de acceso de la subclave que se va a crear o abrir.

permissionCheck
RegistryKeyPermissionCheck

Uno de los valores de enumeración que especifica si la clave se abre para acceso de lectura o para acceso de lectura y escritura.

Devoluciones

Subclave solicitada, o null si se produjo un error en la operación.

Atributos

Excepciones

name es null

permissionCheck contiene un valor no válido.

El objeto RegistryKey está cerrado (no se puede tener acceso a claves cerradas).

El usuario no tiene los permisos necesarios para leer la clave del Registro.

Ejemplos

En el ejemplo de código siguiente se crea una subclave que contiene 100 pares clave-valor y lo cierra. En el ejemplo se abre la subclave con Default, se registra el tiempo necesario para leer todos los valores y se cierra la subclave. En el ejemplo se abre la subclave con ReadSubTree y se registra el tiempo necesario para leer todos los valores. Por último, el ejemplo calcula y muestra la mejora porcentual.

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

Comentarios

En lugar de iniciar una excepción, este método devuelve null si la clave solicitada no existe.

Si permissionCheck es RegistryKeyPermissionCheck.ReadWriteSubTree, la clave se abre para leer y escribir; si permissionCheck es RegistryKeyPermissionCheck.ReadSubTree o RegistryKeyPermissionCheck.Default, la clave se abre para leer a menos que se abra la clave primaria con RegistryKeyPermissionCheck.ReadWriteSubTree.

Para usar el OpenSubKey método , debe tener una instancia de la RegistryKey clase . Para obtener una instancia de RegistryKey, use uno de los miembros estáticos de la Registry clase .

Consulte también

Se aplica a