RegistryKey Classe

Définition

Représente un nœud de niveau clé dans le Registre Windows. Cette classe est une encapsulation du Registre.

public ref class RegistryKey sealed : MarshalByRefObject, IDisposable
public ref class RegistryKey sealed : IDisposable
public sealed class RegistryKey : MarshalByRefObject, IDisposable
public sealed class RegistryKey : IDisposable
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class RegistryKey : MarshalByRefObject, IDisposable
type RegistryKey = class
    inherit MarshalByRefObject
    interface IDisposable
type RegistryKey = class
    interface IDisposable
[<System.Runtime.InteropServices.ComVisible(true)>]
type RegistryKey = class
    inherit MarshalByRefObject
    interface IDisposable
Public NotInheritable Class RegistryKey
Inherits MarshalByRefObject
Implements IDisposable
Public NotInheritable Class RegistryKey
Implements IDisposable
Héritage
Héritage
RegistryKey
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é.

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 obtenir une instance de RegistryKey, utilisez l’un des membres statiques de la Registry classe .

Le Registre sert de référentiel central d’informations pour le système d’exploitation et les applications sur un ordinateur. Le Registre est organisé dans un format hiérarchique, basé sur un ordre logique des éléments stockés dans celui-ci (voir Registry pour les éléments de niveau de base dans cette hiérarchie). Lorsque vous stockez des informations dans le Registre, sélectionnez l’emplacement approprié en fonction du type d’informations stockées. Veillez à éviter de détruire les informations créées par d’autres applications, car cela peut entraîner un comportement inattendu de ces applications et avoir un effet négatif sur votre propre application.

Important

Ce type implémente l'interface IDisposable. Une fois que vous avez fini d’utiliser le type, vous devez le supprimer directement ou indirectement. Pour supprimer directement le type Dispose, appelez sa méthode dans un bloc try/catch. Pour la supprimer indirectement, utilisez une construction de langage telle que using (dans C#) ou Using (dans Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet qui implémente IDisposable » dans la rubrique de l’interface IDisposable.

Les clés de Registre sont l’unité de base de organization dans le Registre et peuvent être comparées à des dossiers dans Explorateur de fichiers. Une clé particulière peut avoir des sous-clés, tout comme un dossier peut avoir des sous-dossiers. Chaque clé peut être supprimée, tant que l’utilisateur dispose des autorisations appropriées pour le faire et que la clé n’est pas une clé de base ou au niveau directement sous les clés de base. Chaque clé peut également avoir plusieurs valeurs associées (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. Chaque valeur contient une information particulière, qui peut être récupérée ou mise à jour si nécessaire. Par instance, vous pouvez créer un RegistryKey pour votre entreprise, sous la clé HKEY_LOCAL_MACHINE\Software, puis une sous-clé pour chaque application créée par votre entreprise. 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.

Notez que les informations stockées dans le Registre sont disponibles pour d’autres applications et utilisateurs et ne doivent donc pas être utilisées pour stocker des données de sécurité ou des informations d’application critiques.

Attention

N’exposez pas d’objets RegistryKey de telle sorte qu’un programme malveillant puisse créer des milliers de sous-clés ou de paires clé/valeur sans signification. Par exemple, n’autorisez pas les appelants à entrer des clés ou des valeurs arbitraires.

À compter de .NET Framework 4, la longueur d’une clé de Registre n’est plus limitée à 255 caractères.

Propriétés

Handle

Obtient un objet SafeRegistryHandle qui représente la clé de Registre que l'objet RegistryKey actuel encapsule.

Name

Récupère le nom de la clé.

SubKeyCount

Récupère le nombre de sous-clés de la clé actuelle.

ValueCount

Récupère le nombre de valeurs dans la clé.

View

Obtient la vue utilisée pour créer la clé de Registre.

Méthodes

Close()

Ferme la clé et la vide sur le disque en cas de modification de son contenu.

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.

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

Crée une sous-clé ou en ouvre une existante pour l'accès en écriture.

CreateSubKey(String, Boolean)

Crée une sous-clé ou en ouvre une existante avec l’accès spécifié. Disponible à partir de .NET Framework 4.6.

CreateSubKey(String, Boolean, RegistryOptions)

Crée une sous-clé ou en ouvre une existante avec l’accès spécifié. Disponible à partir de .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.

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.

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.

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.

DeleteSubKey(String)

Supprime la sous-clé spécifiée.

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.

DeleteSubKeyTree(String)

Supprime récursivement une sous-clé et toutes les sous-clés enfants.

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.

DeleteValue(String)

Supprime la valeur spécifiée de cette clé.

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.

Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe RegistryKey.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
Finalize()

Ferme la clé et la vide sur le disque en cas de modification du contenu.

Flush()

Écrit tous les attributs de la clé de Registre ouverte spécifiée dans le Registre.

FromHandle(SafeRegistryHandle)

Crée une clé de Registre à partir d'un handle spécifié.

FromHandle(SafeRegistryHandle, RegistryView)

Crée une clé de Registre à partir d'un handle spécifié et de la configuration d'affichage du Registre.

GetAccessControl()

Retourne la sécurité du contrôle d'accès pour la clé de Registre actuelle.

GetAccessControl(AccessControlSections)

Retourne les sections spécifiées de la sécurité du contrôle d'accès pour la clé de Registre actuelle.

GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetLifetimeService()
Obsolète.

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.

(Hérité de MarshalByRefObject)
GetSubKeyNames()

Récupère un tableau de chaînes qui contient tous les noms de sous-clés.

GetType()

Obtient le Type de l'instance actuelle.

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

Récupère la valeur associée au nom spécifié. Retourne null si la paire nom/valeur n'existe pas dans le Registre.

GetValue(String, Object)

Récupère la valeur associée au nom spécifié. Si le nom est introuvable, la valeur par défaut que vous fournissez est retournée.

GetValue(String, Object, RegistryValueOptions)

Récupère la valeur associée au nom spécifié et aux options de récupération. Si le nom est introuvable, la valeur par défaut que vous fournissez est retournée.

GetValueKind(String)

Récupère le type de données de Registre de la valeur associée au nom spécifié.

GetValueNames()

Récupère un tableau de chaînes qui contient tous les noms de valeurs associés à cette clé.

InitializeLifetimeService()
Obsolète.

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.

(Hérité de MarshalByRefObject)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

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

Crée une copie superficielle de l'objet MarshalByRefObject actuel.

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

OpenRemoteBaseKey(RegistryHive, String)

Ouvre une nouvelle RegistryKey qui représente la clé demandée sur un ordinateur distant.

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

OpenSubKey(String)

Récupère une sous-clé en lecture seule.

OpenSubKey(String, Boolean)

Extrait une sous-clé spécifiée et spécifie si l'accès en écriture doit s'appliquer à la clé.

OpenSubKey(String, RegistryKeyPermissionCheck)

Récupère la sous-clé spécifiée pour un accès en lecture ou en lecture/écriture.

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.

OpenSubKey(String, RegistryRights)

Récupère une sous-clé avec le nom et les droits d’accès spécifiés. Disponible à partir de .NET Framework 4.6.

SetAccessControl(RegistrySecurity)

Applique la sécurité du contrôle d'accès Windows à une clé de Registre existante.

SetValue(String, Object)

Définit la paire nom/valeur spécifiée.

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

ToString()

Récupère une représentation de type chaîne de cette clé.

Implémentations d’interfaces explicites

IDisposable.Dispose()

Cette API prend en charge l'infrastructure du produit et n'est pas destinée à être utilisée directement à partir de votre code.

Effectue un Close() sur la clé actuelle.

Méthodes d’extension

GetAccessControl(RegistryKey)

Retourne les informations de sécurité d’une clé de Registre.

GetAccessControl(RegistryKey, AccessControlSections)

Retourne les informations de sécurité d’une clé de Registre.

SetAccessControl(RegistryKey, RegistrySecurity)

Change les attributs de sécurité d’une clé de Registre existante.

S’applique à

Voir aussi