RegistryKey.OpenSubKey Metodo

Definizione

Spazio dei nomi:

Microsoft.Win32

Assembly:

Microsoft.Win32.Registry.dll

Recupera la sottochiave specificata.

Overload

OpenSubKey(String, Boolean)	Recupera una sottochiave specificata e specifica se l'accesso in scrittura deve essere applicato alla chiave.
OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights)	Recupera la sottochiave specificata per l'accesso in lettura o in lettura/scrittura, richiedendo i diritti di accesso specificati.
OpenSubKey(String, RegistryRights)	Recupera una sottochiave con il nome e i diritti di accesso specificati. Disponibile a partire da .NET Framework 4.6.
OpenSubKey(String)	Recupera una sottochiave in sola lettura.
OpenSubKey(String, RegistryKeyPermissionCheck)	Recupera la sottochiave specificata per l'accesso in lettura o in lettura/scrittura.

OpenSubKey(String, Boolean)

Recupera una sottochiave specificata e specifica se l'accesso in scrittura deve essere applicato alla chiave.

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

Parametri

name

String

Nome o percorso della sottochiave da aprire.

writable

Boolean

Impostare su true se è necessario disporre dell'accesso in scrittura alla chiave.

Restituisce

RegistryKey

Sottochiave richiesta oppure null se l'operazione non è riuscita.

Eccezioni

ArgumentNullException

name è null.

ObjectDisposedException

La chiave RegistryKey è chiusa, pertanto non è possibile accedere ad essa.

SecurityException

L'utente non dispone delle autorizzazioni necessarie per accedere alla chiave del Registro di sistema nella modalità specificata.

Esempio

Nell'esempio di codice seguente viene creata una chiave di test e viene usato il OpenSubKey metodo per aprirlo, dimostrando entrambi gli overload del metodo.

#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

Commenti

Se la chiave richiesta non esiste, questo metodo restituisce null anziché generare un'eccezione.

Se writable è true, la chiave verrà aperta per la lettura e la scrittura, in caso contrario, la chiave verrà aperta come di sola lettura.

Per usare il OpenSubKey metodo, è necessario disporre di un'istanza RegistryKey del metodo. Per ottenere un'istanza di RegistryKey, usare uno dei membri statici della Registry classe.

Vedi anche

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

OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights)

Recupera la sottochiave specificata per l'accesso in lettura o in lettura/scrittura, richiedendo i diritti di accesso specificati.

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

Parametri

name

String

Nome o percorso della sottochiave da creare o aprire.

permissionCheck

RegistryKeyPermissionCheck

Uno dei valori di enumerazione che specifica se la chiave è aperta per l'accesso in lettura o in lettura/scrittura.

rights

RegistryRights

Combinazione bit per bit di valori di enumerazione che specifica l'accesso di sicurezza desiderato.

Restituisce

RegistryKey

Sottochiave richiesta oppure null se l'operazione non è riuscita.

Eccezioni

ArgumentNullException

name è null

ArgumentException

permissionCheck contiene un valore non valido.

ObjectDisposedException

La chiave RegistryKey è chiusa, pertanto non è possibile accedere ad essa.

SecurityException

rights include valori dei diritti relativi al Registro di sistema non validi.

-oppure-

L'utente non dispone delle autorizzazioni necessarie.

Commenti

Anziché generare un'eccezione, questo metodo restituisce null se la chiave richiesta non esiste.

Se permissionCheck è RegistryKeyPermissionCheck.ReadWriteSubTree, la chiave viene aperta per la lettura e la scrittura; se permissionCheck è RegistryKeyPermissionCheck.ReadSubTree o RegistryKeyPermissionCheck.Default, la chiave viene aperta per la lettura a meno che la chiave padre non sia stata aperta con RegistryKeyPermissionCheck.ReadWriteSubTree.

L'accesso specificato per permissionCheck ha la precedenza sull'accesso specificato per rights. Ad esempio, se si specifica RegistryKeyPermissionCheck.ReadSubTree per e RegistryRights.WriteKey per rightspermissionCheck , un tentativo di scrittura nella sottochiave genera un'eccezione.

Per usare il OpenSubKey metodo, è necessario disporre di un'istanza della RegistryKey classe. Per ottenere un'istanza di RegistryKey, usare uno dei membri statici della Registry classe.

Vedi anche

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

OpenSubKey(String, RegistryRights)

Recupera una sottochiave con il nome e i diritti di accesso specificati. Disponibile a partire da .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

Parametri

name

String

Nome o percorso della sottochiave da creare o aprire.

rights

RegistryRights

Diritti per il Registro di sistema.

Restituisce

RegistryKey

Sottochiave richiesta oppure null se l'operazione non è riuscita.

Eccezioni

ArgumentNullException

name è null.

ObjectDisposedException

La chiave RegistryKey è chiusa, pertanto non è possibile accedere ad essa.

SecurityException

L'utente non dispone delle autorizzazioni necessarie per accedere alla chiave del Registro di sistema nella modalità specificata.

Commenti

È necessario aprire una chiave prima di poterla modificare con altri metodi e proprietà. Per modificare una chiave, è necessario aprirla con un overload del metodo che consente di specificare l'accesso OpenSubKey in scrittura.

OpenSubKey(String)

Recupera una sottochiave in sola lettura.

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

Parametri

name

String

Nome o percorso della sottochiave da aprire in sola lettura.

Restituisce

RegistryKey

Sottochiave richiesta oppure null se l'operazione non è riuscita.

Eccezioni

ArgumentNullException

name è null

ObjectDisposedException

La chiave RegistryKey è chiusa, pertanto non è possibile accedere ad essa.

SecurityException

L'utente non dispone delle autorizzazioni necessarie per la lettura della chiave del Registro di sistema.

Esempio

Nell'esempio di codice seguente viene creata una chiave di test e viene usato il OpenSubKey metodo per aprirlo, dimostrando entrambi gli overload del metodo.

#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

Commenti

È necessario aprire una chiave prima di poterla modificare con altri metodi e proprietà. Per modificare una chiave, è necessario aprirla con un overload del OpenSubKey metodo che consente di specificare l'accesso in scrittura, ad esempio l'overload o l'overload OpenSubKey(String, RegistryKeyPermissionCheck)OpenSubKey(String, Boolean) .

Se non è possibile trovare la sottochiave specificata, null viene restituita.

Per usare il metodo, è necessario disporre di un'istanza OpenSubKey di RegistryKey. Per ottenere un'istanza di RegistryKey, usare uno dei membri statici della Registry classe.

Vedi anche

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

OpenSubKey(String, RegistryKeyPermissionCheck)

Recupera la sottochiave specificata per l'accesso in lettura o in lettura/scrittura.

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

Parametri

name

String

Nome o percorso della sottochiave da creare o aprire.

permissionCheck

RegistryKeyPermissionCheck

Uno dei valori di enumerazione che specifica se la chiave è aperta per l'accesso in lettura o in lettura/scrittura.

Restituisce

RegistryKey

Sottochiave richiesta oppure null se l'operazione non è riuscita.

Eccezioni

ArgumentNullException

name è null

ArgumentException

permissionCheck contiene un valore non valido.

ObjectDisposedException

La chiave RegistryKey è chiusa, pertanto non è possibile accedere ad essa.

SecurityException

L'utente non dispone delle autorizzazioni necessarie per la lettura della chiave del Registro di sistema.

Esempio

Nell'esempio di codice seguente viene creata una sottochiave contenente 100 coppie chiave/valore e la chiude. L'esempio apre la sottochiave con Default, registra il tempo necessario per leggere tutti i valori e chiude la sottochiave. L'esempio apre la sottochiave con ReadSubTree e registra il tempo necessario per leggere tutti i valori. Infine, l'esempio calcola e visualizza il miglioramento percentuale.

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

Commenti

Anziché generare un'eccezione, questo metodo restituisce null se la chiave richiesta non esiste.

Se permissionCheck è RegistryKeyPermissionCheck.ReadWriteSubTree, la chiave viene aperta per la lettura e la scrittura; se permissionCheck è RegistryKeyPermissionCheck.ReadSubTree o RegistryKeyPermissionCheck.Default, la chiave viene aperta per la lettura a meno che la chiave padre non sia stata aperta con RegistryKeyPermissionCheck.ReadWriteSubTree.

Per usare il OpenSubKey metodo, è necessario disporre di un'istanza della RegistryKey classe. Per ottenere un'istanza di RegistryKey, usare uno dei membri statici della Registry classe.

Vedi anche

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