RegistryKey Classe

Definição

Namespace:

Microsoft.Win32

Assembly:

Microsoft.Win32.Registry.dll

Representa um nó de nível de chave no Registro do Windows. Essa classe é um encapsulamento de Registro.

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

Herança

Object

MarshalByRefObject

RegistryKey

Implementações

IDisposable

Exemplos

O exemplo de código a seguir mostra como criar uma subchave em HKEY_CURRENT_USER, manipular seu conteúdo e, em seguida, excluir a subchave.

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

Comentários

Para obter uma instância de RegistryKey, use um dos membros estáticos da classe Registry.

O registro atua como um repositório central de informações para o sistema operacional e os aplicativos em um computador. O registro é organizado em um formato hierárquico, com base em uma ordenação lógica dos elementos armazenados nele (consulte Registry para os itens de nível base nessa hierarquia). Ao armazenar informações no registro, selecione o local apropriado com base no tipo de informação que está sendo armazenado. Evite destruir informações criadas por outros aplicativos, pois isso pode fazer com que esses aplicativos apresentem um comportamento inesperado e também possam ter um efeito adverso em seu próprio aplicativo.

Importante

Esse tipo implementa a interface IDisposable. Quando você terminar de usar o tipo, deverá descartá-lo direta ou indiretamente. Para descartar o tipo diretamente, chame o método Dispose dele em um bloco try/catch. Para descartá-lo indiretamente, use um constructo de linguagem como using ( em C#) ou Using (em Visual Basic). Saiba mais na seção "Como usar um objeto que implementa IDisposable" no tópico da interface IDisposable.

As chaves do Registro são a unidade base da organização no registro e podem ser comparadas com pastas em Explorador de Arquivos. Uma chave específica pode ter subchaves, assim como uma pasta pode ter subpastas. Cada chave pode ser excluída, desde que o usuário tenha as permissões apropriadas para fazer isso, e a chave não seja uma chave base ou no nível diretamente sob as chaves base. Cada chave também pode ter vários valores associados a ela (um valor pode ser comparado a um arquivo), que são usados para armazenar as informações , por exemplo, informações sobre um aplicativo instalado no computador. Cada valor contém uma informação específica, que pode ser recuperada ou atualizada quando necessário. Por exemplo, você pode criar um RegistryKey para sua empresa, sob a chave HKEY_LOCAL_MACHINE\Software e, em seguida, uma subchave para cada aplicativo que sua empresa cria. Cada subchave contém as informações específicas desse aplicativo, como configurações de cor, local e tamanho da tela ou extensões de arquivo reconhecidas.

Observe que as informações armazenadas no registro estão disponíveis para outros aplicativos e usuários e, portanto, não devem ser usadas para armazenar dados de segurança ou informações críticas do aplicativo.

Cuidado

Não exponha objetos RegistryKey de maneira que um programa mal-intencionado possa criar milhares de subchaves sem sentido ou os pares de chave/valor. Por exemplo, não permita que chamadores insiram chaves ou valores arbitrários.

A partir do .NET Framework 4, o comprimento de uma chave do Registro não é mais limitado a 255 caracteres.

Propriedades

Handle	Obtém um objeto SafeRegistryHandle que representa a chave do Registro que o objeto RegistryKey atual encapsula.
Name	Recupera o nome da chave.
SubKeyCount	Recupera a contagem de subchaves da chave atual.
ValueCount	Recupera a contagem de valores na chave.
View	Obtém a exibição que foi usada para criar a chave do Registro.

Métodos

Close()	Fecha a chave e libera-a no disco se o conteúdo foi modificado.
CreateObjRef(Type)	Cria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto remoto. (Herdado de MarshalByRefObject)
CreateSubKey(String)	Cria uma nova subchave ou abre uma subchave existente para acesso de gravação.
CreateSubKey(String, Boolean)	Cria uma nova subchave ou abre uma subchave existente com o acesso especificado. Disponível a partir do .NET Framework 4.6.
CreateSubKey(String, Boolean, RegistryOptions)	Cria uma nova subchave ou abre uma subchave existente com o acesso especificado. Disponível a partir do .NET Framework 4.6.
CreateSubKey(String, RegistryKeyPermissionCheck)	Cria uma nova subchave ou abre uma subchave existente para acesso de gravação, usando a opção de verificação de permissão especificada.
CreateSubKey(String, RegistryKeyPermissionCheck, RegistryOptions)	Cria uma subchave ou abre uma subchave para acesso de gravação, usando as opções de verificação e Registro de permissão especificadas.
CreateSubKey(String, RegistryKeyPermissionCheck, RegistryOptions, RegistrySecurity)	Cria uma subchave ou abre uma subchave para acesso de gravação, usando a opção de verificação de permissão, opção de Registro e a segurança de Registro especificadas.
CreateSubKey(String, RegistryKeyPermissionCheck, RegistrySecurity)	Cria uma nova subchave ou abre uma subchave existente para acesso de gravação, usando a segurança do Registro e a opção de verificação de permissão especificada.
DeleteSubKey(String)	Exclui a subchave especificada.
DeleteSubKey(String, Boolean)	Exclui a subchave especificada e define se uma exceção será gerada se a subchave não for encontrada.
DeleteSubKeyTree(String)	Exclui uma subchave e as subchaves filho recursivamente.
DeleteSubKeyTree(String, Boolean)	Exclui a subchave especificada e qualquer subchave filho recursivamente, bem como especifica se uma exceção será gerada se a subchave não for encontrada.
DeleteValue(String)	Exclui o valor especificado dessa chave.
DeleteValue(String, Boolean)	Exclui o valor especificado dessa chave e especifica se uma exceção será gerada se o valor não for encontrado.
Dispose()	Libera todos os recursos usados pela instância atual da classe RegistryKey.
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
Flush()	Grava no Registro todos os atributos da chave do Registro aberta especificada.
FromHandle(SafeRegistryHandle)	Cria uma chave do Registro com base em um identificador especificado.
FromHandle(SafeRegistryHandle, RegistryView)	Cria uma chave do Registro com base em um identificador e uma configuração de exibição do Registro especificados.
GetAccessControl()	Retorna a segurança de controle de acesso à chave do Registro atual.
GetAccessControl(AccessControlSections)	Retorna as seções de segurança de controle de acesso especificadas para a chave do Registro atual.
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetLifetimeService()	Obsoleto. Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância. (Herdado de MarshalByRefObject)
GetSubKeyNames()	Recupera uma matriz de cadeias de caracteres que contém todos os nomes da subchave.
GetType()	Obtém o Type da instância atual. (Herdado de Object)
GetValue(String)	Recupera o valor associado ao nome especificado. Retorna null se o par nome/valor não existir no Registro.
GetValue(String, Object)	Recupera o valor associado ao nome especificado. Se o nome não for encontrado, retornará o valor padrão que você fornecer.
GetValue(String, Object, RegistryValueOptions)	Recupera o valor associado ao nome especificado e às operações de recuperação. Se o nome não for encontrado, retornará o valor padrão que você fornecer.
GetValueKind(String)	Recupera o tipo de dados de Registro do valor associado com o nome especificado.
GetValueNames()	Recupera uma matriz de cadeias de caracteres que contém todos os nomes de valor associados a essa chave.
InitializeLifetimeService()	Obsoleto. Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida para essa instância. (Herdado de MarshalByRefObject)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
MemberwiseClone(Boolean)	Cria uma cópia superficial do objeto MarshalByRefObject atual. (Herdado de MarshalByRefObject)
OpenBaseKey(RegistryHive, RegistryView)	Abre um novo RegistryKey que representa a chave solicitada no computador local com o modo de exibição especificado.
OpenRemoteBaseKey(RegistryHive, String)	Abre um novo RegistryKey que representa a chave solicitada em um computador remoto.
OpenRemoteBaseKey(RegistryHive, String, RegistryView)	Abre uma nova chave do Registro que representa a chave solicitada em um computador remoto com a exibição especificada.
OpenSubKey(String)	Recupera uma subchave como somente leitura.
OpenSubKey(String, Boolean)	Recupera uma subchave especificada e especifica se o acesso de gravação deve ser aplicado à chave.
OpenSubKey(String, RegistryKeyPermissionCheck)	Recupera a subchave especificada para acesso de leitura ou de leitura/gravação.
OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights)	Recupera a subchave especificada para acesso de leitura ou leitura/gravação, solicitando direitos de acesso especificados.
OpenSubKey(String, RegistryRights)	Recupera uma subchave com o nome e os direitos de acesso especificados. Disponível a partir do .NET Framework 4.6.
SetAccessControl(RegistrySecurity)	Aplica a segurança de controle de acesso do Windows a uma chave do Registro existente.
SetValue(String, Object)	Define o par nome-valor especificado.
SetValue(String, Object, RegistryValueKind)	Define o valor de um par nome-valor na chave do Registro, usando o tipo de dados do Registro especificado.
ToString()	Recupera uma representação de cadeia de caracteres dessa chave.

Métodos de Extensão

Confira também

• Registry
• RegistryHive