RegistryKey Clase

Definición

Espacio de nombres:

Microsoft.Win32

Ensamblado:

Microsoft.Win32.Registry.dll

Representa un nodo de nivel de clave en el Registro de Windows. Esta clase es una encapsulación del 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

Herencia

Object

MarshalByRefObject

RegistryKey

Implementaciones

IDisposable

Ejemplos

En el ejemplo de código siguiente se muestra cómo crear una subclave en HKEY_CURRENT_USER, manipular su contenido y, a continuación, eliminar la subclave.

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

Comentarios

Para obtener una instancia de RegistryKey, use uno de los miembros estáticos de la Registry clase .

El registro actúa como un repositorio central de información para el sistema operativo y las aplicaciones de un equipo. El registro se organiza en un formato jerárquico, basado en una ordenación lógica de los elementos almacenados en él (consulte Registry los elementos de nivel base de esta jerarquía). Al almacenar información en el Registro, seleccione la ubicación adecuada en función del tipo de información que se va a almacenar. Asegúrese de evitar destruir la información creada por otras aplicaciones, ya que esto puede hacer que esas aplicaciones muestren un comportamiento inesperado y también pueden tener un efecto adverso en su propia aplicación.

Importante

Este tipo implementa la interfaz IDisposable. Cuando haya terminado de utilizar el tipo, debe desecharlo directa o indirectamente. Para eliminar el tipo directamente, llame a su método Dispose en un bloque try/catch. Para deshacerse de él indirectamente, use una construcción de lenguaje como using (en C#) o Using (en Visual Basic). Para más información, vea la sección "Uso de objetos que implementan IDisposable" en el tema de la interfaz IDisposable.

Las claves del Registro son la unidad base de la organización en el Registro y se pueden comparar con las carpetas de Explorador de archivos. Una clave determinada puede tener subclaves, al igual que una carpeta puede tener subcarpetas. Cada clave se puede eliminar, siempre y cuando el usuario tenga los permisos adecuados para hacerlo, y la clave no es una clave base o en el nivel directamente bajo las claves base. Cada clave también puede tener varios valores asociados (un valor se puede comparar con un archivo), que se usan para almacenar la información, por ejemplo, información sobre una aplicación instalada en el equipo. Cada valor contiene un fragmento de información determinado, que se puede recuperar o actualizar cuando sea necesario. Por ejemplo, puede crear un RegistryKey para su empresa, en la clave HKEY_LOCAL_MACHINE\Software y, a continuación, una subclave para cada aplicación que cree la empresa. Cada subclave contiene la información específica de esa aplicación, como la configuración de color, la ubicación y el tamaño de la pantalla, o las extensiones de archivo reconocidas.

Tenga en cuenta que la información almacenada en el registro está disponible para otras aplicaciones y usuarios y, por lo tanto, no debe usarse para almacenar datos de seguridad o información crítica de la aplicación.

Precaución

No exponga RegistryKey objetos de tal manera que un programa malintencionado pueda crear miles de subclaves sin significado ni pares clave-valor. Por ejemplo, no permita que los autores de llamadas escriban claves o valores arbitrarios.

A partir de .NET Framework 4, la longitud de una clave del Registro ya no se limita a 255 caracteres.

Propiedades

Handle	Obtiene un objeto SafeRegistryHandle que representa la clave del Registro encapsulada por el objeto RegistryKey actual.
Name	Recupera el nombre de la clave.
SubKeyCount	Recupera el número de subclaves de la clave actual.
ValueCount	Recupera el número de valores de la clave.
View	Obtiene la vista que se ha usado para crear la clave del Registro.

Métodos

Close()	Cierra la clave y la vuelca en el disco si se ha modificado su contenido.
CreateObjRef(Type)	Crea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto. (Heredado de MarshalByRefObject)
CreateSubKey(String)	Crea una subclave o abre una subclave existente para el acceso de escritura.
CreateSubKey(String, Boolean)	Crea una subclave o abre una subclave existente con el acceso especificado. Disponible a partir de .NET Framework 4.6.
CreateSubKey(String, Boolean, RegistryOptions)	Crea una subclave o abre una subclave existente con el acceso especificado. Disponible a partir de .NET Framework 4.6.
CreateSubKey(String, RegistryKeyPermissionCheck)	Crea una subclave o abre una subclave existente para el acceso de escritura, utilizando la opción de comprobación de permiso especificada.
CreateSubKey(String, RegistryKeyPermissionCheck, RegistryOptions)	Crea una subclave o abre una subclave para el acceso de escritura, usando las opciones del Registro y de comprobación de permisos especificadas.
CreateSubKey(String, RegistryKeyPermissionCheck, RegistryOptions, RegistrySecurity)	Crea una nueva subclave o abre una subclave para el acceso de escritura, usando la opción de comprobación de permisos, la opción del Registro y la seguridad del Registro especificadas.
CreateSubKey(String, RegistryKeyPermissionCheck, RegistrySecurity)	Crea una subclave o abre una subclave existente para el acceso de escritura, utilizando la opción de comprobación de permiso y la seguridad del Registro especificadas.
DeleteSubKey(String)	Elimina la subclave especificada.
DeleteSubKey(String, Boolean)	Elimina la subclave especificada e indica si se inicia una excepción cuando no se encuentra la subclave.
DeleteSubKeyTree(String)	Elimina una subclave y las subclaves secundarias de forma recursiva.
DeleteSubKeyTree(String, Boolean)	Elimina la subclave especificada y cualquier subclave secundaria de forma recursiva y especifica si se generará una excepción cuando no se encuentre la subclave.
DeleteValue(String)	Elimina el valor especificado de esta clave.
DeleteValue(String, Boolean)	Elimina el valor especificado de esta clave e indica si se inicia una excepción cuando no se encuentra el valor.
Dispose()	Libera todos los recursos usados por la instancia actual de la clase RegistryKey.
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
Flush()	Escribe todos los atributos de la clave del Registro abierta y especificada en el Registro.
FromHandle(SafeRegistryHandle)	Crea una clave del Registro a partir del identificador especificado.
FromHandle(SafeRegistryHandle, RegistryView)	Crea una clave del Registro a partir de una configuración especificada de controlador y vista del Registro.
GetAccessControl()	Devuelve la seguridad de control de acceso de la clave del Registro actual.
GetAccessControl(AccessControlSections)	Devuelve las secciones especificadas de la seguridad de control de acceso para la clave del Registro actual.
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetLifetimeService()	Obsoletos. Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
GetSubKeyNames()	Recupera una matriz de cadenas que contiene todos los nombres de las subclaves.
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
GetValue(String)	Recupera el valor asociado al nombre especificado. Devuelve null si el par nombre-valor no existe en el Registro.
GetValue(String, Object)	Recupera el valor asociado al nombre especificado. Si no se encuentra el nombre, devuelve el valor predeterminado que se proporcione.
GetValue(String, Object, RegistryValueOptions)	Recupera el valor asociado al nombre y a las opciones de recuperación especificados. Si no se encuentra el nombre, devuelve el valor predeterminado que se proporcione.
GetValueKind(String)	Recupera el tipo de datos del Registro del valor asociado al nombre especificado.
GetValueNames()	Recupera una matriz de cadenas que contiene todos los nombres de valores asociados a esta clave.
InitializeLifetimeService()	Obsoletos. Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
MemberwiseClone(Boolean)	Crea una copia superficial del objeto MarshalByRefObject actual. (Heredado de MarshalByRefObject)
OpenBaseKey(RegistryHive, RegistryView)	Abre un nuevo RegistryKey que representa la clave solicitada en el equipo local con la vista especificada.
OpenRemoteBaseKey(RegistryHive, String)	Abre un nuevo RegistryKey que representa la clave solicitada en un equipo remoto.
OpenRemoteBaseKey(RegistryHive, String, RegistryView)	Abre una nueva clave del Registro que representa la clave solicitada en un equipo remoto con la vista especificada.
OpenSubKey(String)	Recupera una subclave en forma de sólo lectura.
OpenSubKey(String, Boolean)	Recupera la subclave especificada e indica si debe aplicarse acceso de escritura a la clave.
OpenSubKey(String, RegistryKeyPermissionCheck)	Recupera la subclave especificada para acceso de lectura o lectura y escritura.
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.
SetAccessControl(RegistrySecurity)	Aplica la seguridad de control de acceso de Windows a una clave del Registro existente.
SetValue(String, Object)	Establece el par de nombre y valor especificado.
SetValue(String, Object, RegistryValueKind)	Establece el valor de un par de nombre y valor de la clave del Registro, utilizando el tipo de datos del Registro especificado.
ToString()	Recupera una representación en formato de cadena de la clave.

Métodos de extensión

Consulte también

• Registry
• RegistryHive