RegistryKey Classe

Definizione

Spazio dei nomi:

Microsoft.Win32

Assembly:

Microsoft.Win32.Registry.dll

Rappresenta un nodo a livello di chiave nel Registro di sistema di Windows. Questa classe costituisce un incapsulamento del Registro di sistema.

public ref class RegistryKey sealed : MarshalByRefObject, IDisposable

public sealed class RegistryKey : MarshalByRefObject, IDisposable

type RegistryKey = class
    inherit MarshalByRefObject
    interface IDisposable

Public NotInheritable Class RegistryKey
Inherits MarshalByRefObject
Implements IDisposable

Ereditarietà

Object

MarshalByRefObject

RegistryKey

Implementazioni

IDisposable

Esempio

Nell'esempio di codice seguente viene illustrato come creare una sottochiave in HKEY_CURRENT_USER, modificarne il contenuto e quindi eliminare la sottochiave.

using namespace System;
using namespace System::Security::Permissions;
using namespace Microsoft::Win32;

int main()
{
   // Create a subkey named Test9999 under HKEY_CURRENT_USER.
   RegistryKey ^ test9999 = Registry::CurrentUser->CreateSubKey( "Test9999" );

   // Create two subkeys under HKEY_CURRENT_USER\Test9999.
   test9999->CreateSubKey( "TestName" )->Close();
   RegistryKey ^ testSettings = test9999->CreateSubKey( "TestSettings" );

   // Create data for the TestSettings subkey.
   testSettings->SetValue( "Language", "French" );
   testSettings->SetValue( "Level", "Intermediate" );
   testSettings->SetValue( "ID", 123 );
   testSettings->Close();

   // Print the information from the Test9999 subkey.
   Console::WriteLine( "There are {0} subkeys under Test9999.", test9999->SubKeyCount.ToString() );
   array<String^>^subKeyNames = test9999->GetSubKeyNames();
   for ( int i = 0; i < subKeyNames->Length; i++ )
   {
      RegistryKey ^ tempKey = test9999->OpenSubKey( subKeyNames[ i ] );
      Console::WriteLine( "\nThere are {0} values for {1}.", tempKey->ValueCount.ToString(), tempKey->Name );
      array<String^>^valueNames = tempKey->GetValueNames();
      for ( int j = 0; j < valueNames->Length; j++ )
      {
         Console::WriteLine( "{0,-8}: {1}", valueNames[ j ], tempKey->GetValue( valueNames[ j ] )->ToString() );

      }
   }
   
   // Delete the ID value.
   testSettings = test9999->OpenSubKey( "TestSettings", true );
   testSettings->DeleteValue( "id" );

   // Verify the deletion.
   Console::WriteLine( dynamic_cast<String^>(testSettings->GetValue(  "id", "ID not found." )) );
   testSettings->Close();

   // Delete or close the new subkey.
   Console::Write( "\nDelete newly created registry key? (Y/N) " );
   if ( Char::ToUpper( Convert::ToChar( Console::Read() ) ) == 'Y' )
   {
      Registry::CurrentUser->DeleteSubKeyTree( "Test9999" );
      Console::WriteLine( "\nRegistry key {0} deleted.", test9999->Name );
   }
   else
   {
      Console::WriteLine( "\nRegistry key {0} closed.", test9999->ToString() );
      test9999->Close();
   }
}

using System;
using System.Security.Permissions;
using Microsoft.Win32;

class RegKey
{
    static void Main()
    {
        // Create a subkey named Test9999 under HKEY_CURRENT_USER.
        RegistryKey test9999 =
            Registry.CurrentUser.CreateSubKey("Test9999");
        // Create two subkeys under HKEY_CURRENT_USER\Test9999. The
        // keys are disposed when execution exits the using statement.
        using(RegistryKey
            testName = test9999.CreateSubKey("TestName"),
            testSettings = test9999.CreateSubKey("TestSettings"))
        {
            // Create data for the TestSettings subkey.
            testSettings.SetValue("Language", "French");
            testSettings.SetValue("Level", "Intermediate");
            testSettings.SetValue("ID", 123);
        }

        // Print the information from the Test9999 subkey.
        Console.WriteLine("There are {0} subkeys under {1}.",
            test9999.SubKeyCount.ToString(), test9999.Name);
        foreach(string subKeyName in test9999.GetSubKeyNames())
        {
            using(RegistryKey
                tempKey = test9999.OpenSubKey(subKeyName))
            {
                Console.WriteLine("\nThere are {0} values for {1}.",
                    tempKey.ValueCount.ToString(), tempKey.Name);
                foreach(string valueName in tempKey.GetValueNames())
                {
                    Console.WriteLine("{0,-8}: {1}", valueName,
                        tempKey.GetValue(valueName).ToString());
                }
            }
        }

        using(RegistryKey
            testSettings = test9999.OpenSubKey("TestSettings", true))
        {
            // Delete the ID value.
            testSettings.DeleteValue("id");

            // Verify the deletion.
            Console.WriteLine((string)testSettings.GetValue(
                "id", "ID not found."));
        }

        // Delete or close the new subkey.
        Console.Write("\nDelete newly created registry key? (Y/N) ");
        if(Char.ToUpper(Convert.ToChar(Console.Read())) == 'Y')
        {
            Registry.CurrentUser.DeleteSubKeyTree("Test9999");
            Console.WriteLine("\nRegistry key {0} deleted.",
                test9999.Name);
        }
        else
        {
            Console.WriteLine("\nRegistry key {0} closed.",
                test9999.ToString());
            test9999.Close();
        }
    }
}

Imports System.Security.Permissions
Imports Microsoft.Win32

Public Class RegKey
    Shared Sub Main()

        ' Create a subkey named Test9999 under HKEY_CURRENT_USER.
        Dim test9999 As RegistryKey = _
            Registry.CurrentUser.CreateSubKey("Test9999")

        ' Create two subkeys under HKEY_CURRENT_USER\Test9999.
        test9999.CreateSubKey("TestName").Close()
        Dim testSettings As RegistryKey = _
            test9999.CreateSubKey("TestSettings")

        ' Create data for the TestSettings subkey.
        testSettings.SetValue("Language", "French")
        testSettings.SetValue("Level", "Intermediate")
        testSettings.SetValue("ID", 123)
        testSettings.Close()

        ' Print the information from the Test9999 subkey.
        Console.WriteLine("There are {0} subkeys under Test9999.", _
            test9999.SubKeyCount.ToString())
        For Each subKeyName As String In test9999.GetSubKeyNames()
            Dim tempKey As RegistryKey = _
                test9999.OpenSubKey(subKeyName)
            Console.WriteLine(vbCrLf & "There are {0} values for " & _
                "{1}.", tempKey.ValueCount.ToString(), tempKey.Name)
            For Each valueName As String In tempKey.GetValueNames()
                Console.WriteLine("{0,-8}: {1}", valueName, _
                    tempKey.GetValue(valueName).ToString())
            Next
        Next

        ' Delete the ID value.
        testSettings = test9999.OpenSubKey("TestSettings", True)
        testSettings.DeleteValue("id")

        ' Verify the deletion.
        Console.WriteLine(CType(testSettings.GetValue( _
            "id", "ID not found."), String))
        testSettings.Close()

        ' Delete or close the new subkey.
        Console.Write(vbCrLf & "Delete newly created " & _
            "registry key? (Y/N) ")
        If Char.ToUpper(Convert.ToChar(Console.Read())) = "Y"C Then
            Registry.CurrentUser.DeleteSubKeyTree("Test9999")
            Console.WriteLine(vbCrLf & "Registry key {0} deleted.", _
                test9999.Name)
        Else
            Console.WriteLine(vbCrLf & "Registry key {0} closed.", _
                test9999.ToString())
            test9999.Close()
        End If
   
    End Sub
End Class

Commenti

Per ottenere un'istanza di RegistryKey, usare uno dei membri statici della Registry classe .

Il Registro di sistema funge da repository centrale di informazioni per il sistema operativo e le applicazioni in un computer. Il Registro di sistema è organizzato in un formato gerarchico, in base a un ordinamento logico degli elementi archiviati al suo interno (vedere Registry per gli elementi a livello di base in questa gerarchia). Quando si archiviano le informazioni nel Registro di sistema, selezionare il percorso appropriato in base al tipo di informazioni archiviate. Assicurarsi di evitare di eliminare definitivamente le informazioni create da altre applicazioni, perché ciò può causare un comportamento imprevisto di tali applicazioni e può anche avere un effetto negativo sulla propria applicazione.

Importante

Il tipo implementa l'interfaccia IDisposable. Dopo aver utilizzato il tipo, è necessario eliminarlo direttamente o indirettamente. Per eliminare direttamente il tipo, chiamare il metodo Dispose in un blocco try/catch. Per eliminarlo indirettamente, utilizzare un costrutto di linguaggio come ad esempio using in C# o Using in Visual Basic. Per altre informazioni, vedere la sezione "Uso di un oggetto che implementa IDisposable" nell'argomento relativo all'interfaccia IDisposable.

Le chiavi del Registro di sistema sono l'unità di base dell'organizzazione nel Registro di sistema e possono essere confrontate con le cartelle in Esplora file. Una chiave specifica può avere sottochiavi, proprio come una cartella può avere sottocartelle. Ogni chiave può essere eliminata, purché l'utente disponga delle autorizzazioni appropriate per farlo e la chiave non sia una chiave di base o a livello direttamente sotto le chiavi di base. A ogni chiave possono essere associati anche più valori (un valore può essere confrontato con un file), che vengono usati per archiviare le informazioni, ad esempio informazioni su un'applicazione installata nel computer. Ogni valore contiene una particolare informazione, che può essere recuperata o aggiornata quando necessario. Ad esempio, è possibile creare un RegistryKey per l'azienda, sotto la chiave HKEY_LOCAL_MACHINE\Software, e quindi una sottochiave per ogni applicazione creata dall'azienda. Ogni sottochiave contiene le informazioni specifiche dell'applicazione, ad esempio le impostazioni dei colori, la posizione e le dimensioni dello schermo o le estensioni di file riconosciute.

Si noti che le informazioni archiviate nel Registro di sistema sono disponibili per altre applicazioni e utenti e pertanto non devono essere usate per archiviare i dati di sicurezza o le informazioni critiche sull'applicazione.

Attenzione

Non esporre RegistryKey oggetti in modo che un programma dannoso possa creare migliaia di sottochiavi senza significato o coppie chiave/valore. Ad esempio, non consentire ai chiamanti di immettere chiavi o valori arbitrari.

A partire da .NET Framework 4, la lunghezza di una chiave del Registro di sistema non è più limitata a 255 caratteri.

Proprietà

Handle	Ottiene un oggetto SafeRegistryHandle che rappresenta la chiave del Registro di sistema incapsulata dall'oggetto RegistryKey corrente.
Name	Recupera il nome della chiave.
SubKeyCount	Recupera il numero di sottochiavi della chiave corrente.
ValueCount	Recupera il numero di valori nella chiave.
View	Ottiene la visualizzazione usata per creare la chiave del Registro di sistema.

Metodi

Close()	Chiude la chiave e la scarica su disco se il contenuto è stato modificato.
CreateObjRef(Type)	Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto. (Ereditato da MarshalByRefObject)
CreateSubKey(String)	Crea una nuova sottochiave o apre una sottochiave esistente per l'accesso in scrittura.
CreateSubKey(String, Boolean)	Crea una nuova sottochiave o apre una sottochiave esistente con l'accesso specificato. Disponibile a partire da .NET Framework 4.6.
CreateSubKey(String, Boolean, RegistryOptions)	Crea una nuova sottochiave o apre una sottochiave esistente con l'accesso specificato. Disponibile a partire da .NET Framework 4.6.
CreateSubKey(String, RegistryKeyPermissionCheck)	Crea una nuova sottochiave o apre una sottochiave esistente per l'accesso in scrittura, usando l'opzione di controllo dell'autorizzazione specificata.
CreateSubKey(String, RegistryKeyPermissionCheck, RegistryOptions)	Crea una sottochiave o apre una sottochiave per l'accesso in scrittura, usando le opzioni del Registro di sistema e di verifica delle autorizzazioni specificate.
CreateSubKey(String, RegistryKeyPermissionCheck, RegistryOptions, RegistrySecurity)	Crea una nuova sottochiave o apre una sottochiave per l'accesso in scrittura, usando l'opzione di verifica delle autorizzazioni, l'opzione del Registro di sistema e la sicurezza del Registro di sistema specificate.
CreateSubKey(String, RegistryKeyPermissionCheck, RegistrySecurity)	Crea una nuova sottochiave o apre una sottochiave esistente per l'accesso in scrittura, usando l'opzione di controllo dell'autorizzazione e la sicurezza del Registro di sistema specificate.
DeleteSubKey(String)	Elimina la sottochiave specificata.
DeleteSubKey(String, Boolean)	Elimina la sottochiave specificata e specifica se generare un'eccezione se la sottochiave non viene trovata.
DeleteSubKeyTree(String)	Elimina in modo ricorsivo una sottochiave e le eventuali sottochiavi figlio.
DeleteSubKeyTree(String, Boolean)	Elimina in modo ricorsivo la sottochiave specificata e qualsiasi sottochiave figlio e specifica se generare un'eccezione se la sottochiave non viene trovata.
DeleteValue(String)	Elimina il valore specificato dalla chiave.
DeleteValue(String, Boolean)	Elimina il valore specificato da questa chiave e specifica se generare un'eccezione se il valore non viene trovato.
Dispose()	Rilascia tutte le risorse usate dall'istanza corrente della classe RegistryKey.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
Flush()	Scrive nel Registro di sistema tutti gli attributi della chiave aperta specificata.
FromHandle(SafeRegistryHandle)	Crea una chiave del Registro di sistema da un handle specificato.
FromHandle(SafeRegistryHandle, RegistryView)	Crea una chiave del Registro di sistema da un handle e da un'impostazione di visualizzazione del Registro di sistema specificati.
GetAccessControl()	Restituisce la sicurezza del controllo di accesso per la chiave del Registro di sistema corrente.
GetAccessControl(AccessControlSections)	Restituisce le sezioni specificate della sicurezza del controllo di accesso per la chiave del Registro di sistema corrente.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLifetimeService()	Obsoleti. Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza. (Ereditato da MarshalByRefObject)
GetSubKeyNames()	Recupera una matrice di stringhe contenente i nomi delle sottochiavi.
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
GetValue(String)	Recupera il valore associato al nome specificato. Restituisce null se la coppia nome/valore non esiste nel Registro di sistema.
GetValue(String, Object)	Recupera il valore associato al nome specificato. Se il nome non viene trovato, restituisce il valore predefinito fornito dall'utente.
GetValue(String, Object, RegistryValueOptions)	Recupera il valore associato al nome specificato e le opzioni di recupero. Se il nome non viene trovato, restituisce il valore predefinito fornito dall'utente.
GetValueKind(String)	Recupera il tipo di dati del Registro di sistema del valore associato al nome specificato.
GetValueNames()	Recupera una matrice di stringhe contenente tutti i nomi dei valori associati alla chiave.
InitializeLifetimeService()	Obsoleti. Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
OpenBaseKey(RegistryHive, RegistryView)	Apre un nuovo oggetto RegistryKey che rappresenta la chiave richiesta nel computer locale con la visualizzazione specificata.
OpenRemoteBaseKey(RegistryHive, String)	Apre un nuovo oggetto RegistryKey che rappresenta la chiave richiesta su un computer remoto.
OpenRemoteBaseKey(RegistryHive, String, RegistryView)	Apre una nuova chiave del Registro di sistema che rappresenta la chiave richiesta in un computer remoto con la visualizzazione specificata.
OpenSubKey(String)	Recupera una sottochiave in sola lettura.
OpenSubKey(String, Boolean)	Recupera una sottochiave specificata e specifica se l'accesso in scrittura deve essere applicato alla chiave.
OpenSubKey(String, RegistryKeyPermissionCheck)	Recupera la sottochiave specificata per l'accesso in lettura o in lettura/scrittura.
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.
SetAccessControl(RegistrySecurity)	Applica la sicurezza del controllo di accesso Windows a una chiave del Registro di sistema esistente.
SetValue(String, Object)	Imposta la coppia nome/valore specificata.
SetValue(String, Object, RegistryValueKind)	Imposta il valore di una coppia nome/valore nella chiave del Registro di sistema, usando il tipo di dati del Registro di sistema specificato.
ToString()	Recupera una rappresentazione di stringa della chiave.

Metodi di estensione

Vedi anche

• Registry
• RegistryHive