RegistryKey Classe

Définition

Représente un nœud de niveau clé dans le Registre Windows.Represents a key-level node in the Windows registry. Cette classe est une encapsulation du Registre.This class is a registry encapsulation.

public ref class RegistryKey sealed : MarshalByRefObject, IDisposable
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class RegistryKey : MarshalByRefObject, IDisposable
type RegistryKey = class
    inherit MarshalByRefObject
    interface IDisposable
Public NotInheritable Class RegistryKey
Inherits MarshalByRefObject
Implements IDisposable
Héritage
Attributs
Implémente

Exemples

L’exemple de code suivant montre comment créer une sous-clé sous HKEY_CURRENT_USER, manipuler son contenu, puis supprimer la sous-clé.The following code example shows how to create a subkey under HKEY_CURRENT_USER, manipulate its contents, and then delete the subkey.

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

Remarques

Pour récupérer une instance de RegistryKey, utilisez l’un des membres statiques de Registry la classe.To get an instance of RegistryKey, use one of the static members of the Registry class.

Le registre agit comme un référentiel central d’informations pour le système d’exploitation et les applications sur un ordinateur.The registry acts as a central repository of information for the operating system and the applications on a computer. Le Registre est organisé dans un format hiérarchique, en fonction d’un classement logique des éléments qui y sont stockés (voir Registry pour les éléments de niveau de base dans cette hiérarchie).The registry is organized in a hierarchical format, based on a logical ordering of the elements stored within it (please see Registry for the base-level items in this hierarchy). Lorsque vous stockez des informations dans le registre, sélectionnez l’emplacement approprié en fonction du type d’informations stockées.When storing information in the registry, select the appropriate location based on the type of information being stored. Veillez à ne pas détruire les informations créées par d’autres applications, car cela peut entraîner un comportement inattendu de ces applications et peut également avoir un effet néfaste sur votre propre application.Be sure to avoid destroying information created by other applications, because this can cause those applications to exhibit unexpected behavior, and can also have an adverse effect upon your own application.

Important

Ce type implémente l'interface IDisposable.This type implements the IDisposable interface. Une fois que vous avez fini d’utiliser le type, vous devez le supprimer directement ou indirectement.When you have finished using the type, you should dispose of it either directly or indirectly. Pour supprimer directement le type Dispose, appelez sa méthode dans un bloc try/catch.To dispose of the type directly, call its Dispose method in a try/catch block. Pour la supprimer indirectement, utilisez une construction de langage telle que using (dans C#) ou Using (dans Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet qui implémente IDisposable » dans la rubrique de l’interface IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Les clés de Registre sont l’unité de base de l’organisation dans le registre et peuvent être comparées aux dossiers de l’Explorateur de fichiers.Registry keys are the base unit of organization in the registry, and can be compared to folders in File Explorer. Une clé particulière peut avoir des sous-clés, tout comme un dossier peut avoir des sous-dossiers.A particular key can have subkeys, just as a folder can have subfolders. Chaque clé peut être supprimée, tant que l’utilisateur dispose des autorisations appropriées pour ce faire, et la clé n’est pas une clé de base ou au niveau directement sous les clés de base.Each key can be deleted, as long as the user has the appropriate permissions to do so, and the key is not a base key or at the level directly under the base keys. Plusieurs valeurs peuvent également être associées à chaque clé (une valeur peut être comparée à un fichier), qui sont utilisées pour stocker les informations (par exemple, des informations sur une application installée sur l’ordinateur).Each key can also have multiple values associated with it (a value can be compared to a file), which are used to store the information - for example, information about an application installed on the computer. Chaque valeur contient une information particulière, qui peut être extraite ou mise à jour à la demande.Each value holds one particular piece of information, which can be retrieved or updated when required. Par exemple, vous pouvez créer un RegistryKey pour votre société, sous la clé HKEY_LOCAL_MACHINE\Software, puis une sous-clé pour chaque application créée par votre société.For instance, you can create a RegistryKey for your company, under the key HKEY_LOCAL_MACHINE\Software, and then a subkey for each application that your company creates. Chaque sous-clé contient les informations spécifiques à cette application, telles que les paramètres de couleur, l’emplacement et la taille de l’écran, ou les extensions de fichier reconnues.Each subkey holds the information specific to that application, such as color settings, screen location and size, or recognized file extensions.

Notez que les informations stockées dans le Registre sont à la disposition d’autres applications et utilisateurs. par conséquent, elles ne doivent pas être utilisées pour stocker des données de sécurité ou des informations d’application critiques.Note that information stored in the registry is available to other applications and users, and therefore should not be used to store security data or critical application information.

Attention

N’exposez RegistryKey pas d’objets de sorte qu’un programme malveillant puisse créer des milliers de sous-clés sans signification ou de paires clé/valeur.Do not expose RegistryKey objects in such a way that a malicious program could create thousands of meaningless subkeys or key/value pairs. Par exemple, n’autorisez pas les appelants à entrer des clés ou des valeurs arbitraires.For example, do not allow callers to enter arbitrary keys or values.

À partir de, la longueur d’une clé de Registre n’est plus limitée à 255 caractères. .NET Framework 4.NET Framework 4Starting in the .NET Framework 4.NET Framework 4, the length of a registry key is no longer limited to 255 characters.

Propriétés

Handle

Obtient un objet SafeRegistryHandle qui représente la clé de Registre que l'objet RegistryKey actuel encapsule.Gets a SafeRegistryHandle object that represents the registry key that the current RegistryKey object encapsulates.

Name

Récupère le nom de la clé.Retrieves the name of the key.

SubKeyCount

Récupère le nombre de sous-clés de la clé actuelle.Retrieves the count of subkeys of the current key.

ValueCount

Récupère le nombre de valeurs dans la clé.Retrieves the count of values in the key.

View

Obtient la vue utilisée pour créer la clé de Registre.Gets the view that was used to create the registry key.

Méthodes

Close()

Ferme la clé et la vide sur le disque en cas de modification de son contenu.Closes the key and flushes it to disk if its contents have been modified.

CreateObjRef(Type)

Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Hérité de MarshalByRefObject)
CreateSubKey(String)

Crée une sous-clé ou en ouvre une existante pour l'accès en écriture.Creates a new subkey or opens an existing subkey for write access.

CreateSubKey(String, Boolean)

Crée une sous-clé ou en ouvre une existante avec l’accès spécifié.Creates a new subkey or opens an existing subkey with the specified access. Disponible à partir de .NET Framework 4.6.Available starting with .NET Framework 4.6.

CreateSubKey(String, Boolean, RegistryOptions)

Crée une sous-clé ou en ouvre une existante avec l’accès spécifié.Creates a new subkey or opens an existing subkey with the specified access. Disponible à partir de .NET Framework 4.6.Available starting with .NET Framework 4.6.

CreateSubKey(String, RegistryKeyPermissionCheck)

Crée une sous-clé ou en ouvre une existante pour l'accès en écriture, à l'aide de l'option de vérification des autorisations spécifiées.Creates a new subkey or opens an existing subkey for write access, using the specified permission check option.

CreateSubKey(String, RegistryKeyPermissionCheck, RegistryOptions)

Crée une sous-clé ou en ouvre une pour l'accès en écriture, à l'aide des options de vérification des autorisations et de registre spécifiées.Creates a subkey or opens a subkey for write access, using the specified permission check and registry options.

CreateSubKey(String, RegistryKeyPermissionCheck, RegistryOptions, RegistrySecurity)

Crée une sous-clé ou en ouvre une pour l'accès en écriture, à l'aide de l'option de vérification des autorisations, de l'option de Registre et de la sécurité du Registre spécifiées.Creates a subkey or opens a subkey for write access, using the specified permission check option, registry option, and registry security.

CreateSubKey(String, RegistryKeyPermissionCheck, RegistrySecurity)

Crée une sous-clé ou en ouvre une existante pour l'accès en écriture, à l'aide de l'option de vérification des autorisations spécifiées et de la sécurité du Registre.Creates a new subkey or opens an existing subkey for write access, using the specified permission check option and registry security.

DeleteSubKey(String)

Supprime la sous-clé spécifiée.Deletes the specified subkey.

DeleteSubKey(String, Boolean)

Supprime la sous-clé spécifiée et spécifie si une exception est levée lorsque la sous-clé est introuvable.Deletes the specified subkey, and specifies whether an exception is raised if the subkey is not found.

DeleteSubKeyTree(String)

Supprime récursivement une sous-clé et toutes les sous-clés enfants.Deletes a subkey and any child subkeys recursively.

DeleteSubKeyTree(String, Boolean)

Supprime de manière récursive la sous-clé spécifiée et toutes les sous-clés enfants, et spécifie si une exception est levée si la sous-clé est introuvable.Deletes the specified subkey and any child subkeys recursively, and specifies whether an exception is raised if the subkey is not found.

DeleteValue(String)

Supprime la valeur spécifiée de cette clé.Deletes the specified value from this key.

DeleteValue(String, Boolean)

Supprime la valeur spécifiée de cette clé et spécifie si une exception est levée lorsque la valeur est introuvable.Deletes the specified value from this key, and specifies whether an exception is raised if the value is not found.

Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe RegistryKey.Releases all resources used by the current instance of the RegistryKey class.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
Finalize()

Ferme la clé et la vide sur le disque en cas de modification du contenu.Closes the key and flushes it to disk if the contents have been modified.

Flush()

Écrit tous les attributs de la clé de Registre ouverte spécifiée dans le Registre.Writes all the attributes of the specified open registry key into the registry.

FromHandle(SafeRegistryHandle)

Crée une clé de Registre à partir d'un handle spécifié.Creates a registry key from a specified handle.

FromHandle(SafeRegistryHandle, RegistryView)

Crée une clé de Registre à partir d'un handle spécifié et de la configuration d'affichage du Registre.Creates a registry key from a specified handle and registry view setting.

GetAccessControl()

Retourne la sécurité du contrôle d'accès pour la clé de Registre actuelle.Returns the access control security for the current registry key.

GetAccessControl(AccessControlSections)

Retourne les sections spécifiées de la sécurité du contrôle d'accès pour la clé de Registre actuelle.Returns the specified sections of the access control security for the current registry key.

GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetLifetimeService()

Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Hérité de MarshalByRefObject)
GetSubKeyNames()

Récupère un tableau de chaînes qui contient tous les noms de sous-clés.Retrieves an array of strings that contains all the subkey names.

GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
GetValue(String)

Récupère la valeur associée au nom spécifié.Retrieves the value associated with the specified name. Retourne null si la paire nom/valeur n'existe pas dans le Registre.Returns null if the name/value pair does not exist in the registry.

GetValue(String, Object)

Récupère la valeur associée au nom spécifié.Retrieves the value associated with the specified name. Si le nom est introuvable, la valeur par défaut que vous fournissez est retournée.If the name is not found, returns the default value that you provide.

GetValue(String, Object, RegistryValueOptions)

Récupère la valeur associée au nom spécifié et aux options de récupération.Retrieves the value associated with the specified name and retrieval options. Si le nom est introuvable, la valeur par défaut que vous fournissez est retournée.If the name is not found, returns the default value that you provide.

GetValueKind(String)

Récupère le type de données de Registre de la valeur associée au nom spécifié.Retrieves the registry data type of the value associated with the specified name.

GetValueNames()

Récupère un tableau de chaînes qui contient tous les noms de valeurs associés à cette clé.Retrieves an array of strings that contains all the value names associated with this key.

InitializeLifetimeService()

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.Obtains a lifetime service object to control the lifetime policy for this instance.

(Hérité de MarshalByRefObject)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
MemberwiseClone(Boolean)

Crée une copie superficielle de l'objet MarshalByRefObject actuel.Creates a shallow copy of the current MarshalByRefObject object.

(Hérité de MarshalByRefObject)
OpenBaseKey(RegistryHive, RegistryView)

Ouvre une nouvelle RegistryKey qui représente la clé demandée sur l'ordinateur local avec la vue spécifiée.Opens a new RegistryKey that represents the requested key on the local machine with the specified view.

OpenRemoteBaseKey(RegistryHive, String)

Ouvre une nouvelle RegistryKey qui représente la clé demandée sur un ordinateur distant.Opens a new RegistryKey that represents the requested key on a remote machine.

OpenRemoteBaseKey(RegistryHive, String, RegistryView)

Ouvre une nouvelle clé de Registre qui représente la clé demandée sur un ordinateur distant avec l'affichage spécifié.Opens a new registry key that represents the requested key on a remote machine with the specified view.

OpenSubKey(String)

Récupère une sous-clé en lecture seule.Retrieves a subkey as read-only.

OpenSubKey(String, Boolean)

Extrait une sous-clé spécifiée et spécifie si l'accès en écriture doit s'appliquer à la clé.Retrieves a specified subkey, and specifies whether write access is to be applied to the key.

OpenSubKey(String, RegistryKeyPermissionCheck)

Récupère la sous-clé spécifiée pour un accès en lecture ou en lecture/écriture.Retrieves the specified subkey for read or read/write access.

OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights)

Récupère la sous-clé spécifiée pour un accès en lecture ou en lecture/écriture, en demandant les droits d'accès spécifiés.Retrieves the specified subkey for read or read/write access, requesting the specified access rights.

OpenSubKey(String, RegistryRights)

Récupère une sous-clé avec le nom et les droits d’accès spécifiés.Retrieves a subkey with the specified name and access rights. Disponible à partir de .NET Framework 4.6.Available starting with .NET Framework 4.6.

SetAccessControl(RegistrySecurity)

Applique la sécurité du contrôle d'accès Windows à une clé de Registre existante.Applies Windows access control security to an existing registry key.

SetValue(String, Object)

Définit la paire nom/valeur spécifiée.Sets the specified name/value pair.

SetValue(String, Object, RegistryValueKind)

Définit la valeur d'une paire nom/valeur dans la clé de Registre à l'aide du type de données de Registre spécifié.Sets the value of a name/value pair in the registry key, using the specified registry data type.

ToString()

Récupère une représentation de type chaîne de cette clé.Retrieves a string representation of this key.

Implémentations d’interfaces explicites

IDisposable.Dispose()

Effectue un Close() sur la clé actuelle.Performs a Close() on the current key.

Méthodes d’extension

GetAccessControl(RegistryKey)
GetAccessControl(RegistryKey, AccessControlSections)
SetAccessControl(RegistryKey, RegistrySecurity)

S’applique à

Voir aussi