Registry Class

Definition

Fournit des objets RegistryKey qui représentent les clés racine du Registre Windows et des méthodes static permettant d'accéder à des paires clé/valeur.Provides RegistryKey objects that represent the root keys in the Windows registry, and static methods to access key/value pairs.

public ref class Registry abstract sealed
public ref class Registry sealed
public static class Registry
public sealed class Registry
[System.Runtime.InteropServices.ComVisible(true)]
public static class Registry
type Registry = class
Public Class Registry
Public NotInheritable Class Registry
Inheritance
Registry
Attributes

Examples

Cette section contient deux exemples de code.This section contains two code examples. Le premier exemple illustre les clés racines, et le deuxième exemple montre les méthodes staticGetValue et SetValue.The first example demonstrates root keys, and the second example demonstrates the staticGetValue and SetValue methods.

Exemple 1Example 1

L’exemple de code suivant montre comment récupérer les sous-clés de la HKEY_USERS clé et imprimer leurs noms à l’écran.The following code example demonstrates how to retrieve the subkeys of the HKEY_USERS key, and print their names to the screen. Utilisez la méthode OpenSubKey pour créer une instance de la sous-clé particulière qui vous intéresse.Use the OpenSubKey method to create an instance of the particular subkey of interest. Vous pouvez ensuite utiliser d’autres opérations dans RegistryKey pour manipuler cette clé.You can then use other operations in RegistryKey to manipulate that key.

using namespace System;
using namespace Microsoft::Win32;
void PrintKeys( RegistryKey ^ rkey )
{
   
   // Retrieve all the subkeys for the specified key.
   array<String^>^names = rkey->GetSubKeyNames();
   int icount = 0;
   Console::WriteLine( "Subkeys of {0}", rkey->Name );
   Console::WriteLine( "-----------------------------------------------" );
   
   // Print the contents of the array to the console.
   System::Collections::IEnumerator^ enum0 = names->GetEnumerator();
   while ( enum0->MoveNext() )
   {
      String^ s = safe_cast<String^>(enum0->Current);
      Console::WriteLine( s );
      
      // The following code puts a limit on the number
      // of keys displayed.  Comment it out to print the
      // complete list.
      icount++;
      if ( icount >= 10 )
            break;
   }
}

int main()
{
   
   // Create a RegistryKey, which will access the HKEY_USERS
   // key in the registry of this machine.
   RegistryKey ^ rk = Registry::Users;
   
   // Print out the keys.
   PrintKeys( rk );
}

using System;
using Microsoft.Win32;

class Reg {
    public static void Main() {

        // Create a RegistryKey, which will access the HKEY_USERS
        // key in the registry of this machine.
        RegistryKey rk = Registry.Users;

        // Print out the keys.
        PrintKeys(rk);
    }

    static void PrintKeys(RegistryKey rkey) {

        // Retrieve all the subkeys for the specified key.
        String [] names = rkey.GetSubKeyNames();

        int icount = 0;

        Console.WriteLine("Subkeys of " + rkey.Name);
        Console.WriteLine("-----------------------------------------------");

        // Print the contents of the array to the console.
        foreach (String s in names) {
            Console.WriteLine(s);

            // The following code puts a limit on the number
            // of keys displayed.  Comment it out to print the
            // complete list.
            icount++;
            if (icount >= 10)
                break;
        }
    }
}
Imports Microsoft.Win32

Class Reg
    
    Public Shared Sub Main()
        
        ' Create a RegistryKey, which will access the HKEY_USERS
        ' key in the registry of this machine.
        Dim rk As RegistryKey = Registry.Users
        
        ' Print out the keys.
        PrintKeys(rk)
    End Sub    
    
    Shared Sub PrintKeys(rkey As RegistryKey)
        
        ' Retrieve all the subkeys for the specified key.
        Dim names As String() = rkey.GetSubKeyNames()
        
        Dim icount As Integer = 0
        
        Console.WriteLine("Subkeys of " & rkey.Name)
        Console.WriteLine("-----------------------------------------------")
        
        ' Print the contents of the array to the console.
        Dim s As String
        For Each s In  names
            Console.WriteLine(s)
            
            ' The following code puts a limit on the number
            ' of keys displayed.  Comment it out to print the
            ' complete list.
            icount += 1            
            If icount >= 10 Then
                Exit For
            End If
        Next s
    End Sub
End Class

Exemple 2Example 2

L’exemple de code suivant stocke des valeurs de plusieurs types de données dans une clé d’exemple, en créant la clé telle quelle, puis récupère et affiche les valeurs.The following code example stores values of several data types in an example key, creating the key as it does so, and then retrieves and displays the values. L’exemple illustre le stockage et la récupération de la paire nom/valeur par défaut (sans nom), et l’utilisation de defaultValue lorsqu’une paire nom/valeur n’existe pas.The example demonstrates storing and retrieving the default (nameless) name/value pair, and the use of defaultValue when a name/value pair does not exist.

using namespace System;
using namespace Microsoft::Win32;

int main()
{   
    // The name of the key must include a valid root.
    String^ userRoot = "HKEY_CURRENT_USER";
    String^ subKey = "RegistrySetValueExample2";
    String^ keyName = String::Concat(userRoot, "\\", subKey);
    
    // An int value can be stored without specifying the
    // registry data type, but Int64 values will be stored
    // as strings unless you specify the type. Note that
    // the int is stored in the default name/value
    // pair.
    Registry::SetValue(keyName, "", 5280);
    Registry::SetValue(keyName, "TestInt64", 12345678901234, 
        RegistryValueKind::QWord);
    
    // Strings with expandable environment variables are
    // stored as ordinary strings unless you specify the
    // data type.
    Registry::SetValue(keyName, "TestExpand", "My path: %path%");
    Registry::SetValue(keyName, "TestExpand2", "My path: %path%", 
        RegistryValueKind::ExpandString);
    
    // Arrays of strings are stored automatically as 
    // MultiString. Similarly, arrays of Byte are stored
    // automatically as Binary.
    array<String^>^ strings  = {"One", "Two", "Three"};
    Registry::SetValue(keyName, "TestArray", strings);
    
    // Your default value is returned if the name/value pair
    // does not exist.
    String^ noSuch = (String^)Registry::GetValue(keyName, 
        "NoSuchName", 
        "Return this default if NoSuchName does not exist.");
    Console::WriteLine("\r\nNoSuchName: {0}", noSuch);
    
    // Retrieve the int and Int64 values, specifying 
    // numeric default values in case the name/value pairs
    // do not exist. The int value is retrieved from the
    // default (nameless) name/value pair for the key.
    int testInteger = (int)Registry::GetValue(keyName, "", -1);
    Console::WriteLine("(Default): {0}", testInteger);
    long long testInt64 = (long long)Registry::GetValue(keyName, 
        "TestInt64", System::Int64::MinValue);
    Console::WriteLine("TestInt64: {0}", testInt64);
    
    // When retrieving a MultiString value, you can specify
    // an array for the default return value. 
    array<String^>^ testArray = (array<String^>^)Registry::GetValue(
        keyName, "TestArray", 
        gcnew array<String^> {"Default if TestArray does not exist."});
    for (int i = 0; i < testArray->Length; i++)
    {
        Console::WriteLine("TestArray({0}): {1}", i, testArray[i]);
    }
    
    // A string with embedded environment variables is not
    // expanded if it was stored as an ordinary string.
    String^ testExpand = (String^)Registry::GetValue(keyName, 
        "TestExpand", "Default if TestExpand does not exist.");
    Console::WriteLine("TestExpand: {0}", testExpand);
    
    // A string stored as ExpandString is expanded.
    String^ testExpand2 = (String^)Registry::GetValue(keyName, 
        "TestExpand2", "Default if TestExpand2 does not exist.");
    Console::WriteLine(
        "TestExpand2: {0}...", testExpand2->Substring(0, 40));
    Console::WriteLine(
        "\r\nUse the registry editor to examine the key.");
    Console::WriteLine("Press the Enter key to delete the key.");
    Console::ReadLine();
    Registry::CurrentUser->DeleteSubKey(subKey);
}
//
// This code example produces output similar to the following:
//
// NoSuchName: Return this default if NoSuchName does not exist.
// (Default): 5280
// TestInt64: 12345678901234
// TestArray(0): One
// TestArray(1): Two
// TestArray(2): Three
// TestExpand: My path: %path%
// TestExpand2: My path: D:\Program Files\Microsoft.NET\...
//
// Use the registry editor to examine the key.
// Press the Enter key to delete the key.
using System;
using Microsoft.Win32;

public class Example
{
    public static void Main()
    {
        // The name of the key must include a valid root.
        const string userRoot = "HKEY_CURRENT_USER";
        const string subkey = "RegistrySetValueExample";
        const string keyName = userRoot + "\\" + subkey;

        // An int value can be stored without specifying the
        // registry data type, but long values will be stored
        // as strings unless you specify the type. Note that
        // the int is stored in the default name/value
        // pair.
        Registry.SetValue(keyName, "", 5280);
        Registry.SetValue(keyName, "TestLong", 12345678901234,
            RegistryValueKind.QWord);

        // Strings with expandable environment variables are
        // stored as ordinary strings unless you specify the
        // data type.
        Registry.SetValue(keyName, "TestExpand", "My path: %path%");
        Registry.SetValue(keyName, "TestExpand2", "My path: %path%",
            RegistryValueKind.ExpandString);

        // Arrays of strings are stored automatically as
        // MultiString. Similarly, arrays of Byte are stored
        // automatically as Binary.
        string[] strings = {"One", "Two", "Three"};
        Registry.SetValue(keyName, "TestArray", strings);

        // Your default value is returned if the name/value pair
        // does not exist.
        string noSuch = (string) Registry.GetValue(keyName,
            "NoSuchName",
            "Return this default if NoSuchName does not exist.");
        Console.WriteLine("\r\nNoSuchName: {0}", noSuch);

        // Retrieve the int and long values, specifying
        // numeric default values in case the name/value pairs
        // do not exist. The int value is retrieved from the
        // default (nameless) name/value pair for the key.
        int tInteger = (int) Registry.GetValue(keyName, "", -1);
        Console.WriteLine("(Default): {0}", tInteger);
        long tLong = (long) Registry.GetValue(keyName, "TestLong",
            long.MinValue);
        Console.WriteLine("TestLong: {0}", tLong);

        // When retrieving a MultiString value, you can specify
        // an array for the default return value.
        string[] tArray = (string[]) Registry.GetValue(keyName,
            "TestArray",
            new string[] {"Default if TestArray does not exist."});
        for(int i=0; i<tArray.Length; i++)
        {
            Console.WriteLine("TestArray({0}): {1}", i, tArray[i]);
        }

        // A string with embedded environment variables is not
        // expanded if it was stored as an ordinary string.
        string tExpand = (string) Registry.GetValue(keyName,
             "TestExpand",
             "Default if TestExpand does not exist.");
        Console.WriteLine("TestExpand: {0}", tExpand);

        // A string stored as ExpandString is expanded.
        string tExpand2 = (string) Registry.GetValue(keyName,
            "TestExpand2",
            "Default if TestExpand2 does not exist.");
        Console.WriteLine("TestExpand2: {0}...",
            tExpand2.Substring(0, 40));

        Console.WriteLine("\r\nUse the registry editor to examine the key.");
        Console.WriteLine("Press the Enter key to delete the key.");
        Console.ReadLine();
        Registry.CurrentUser.DeleteSubKey(subkey);
    }
}
//
// This code example produces output similar to the following:
//
//NoSuchName: Return this default if NoSuchName does not exist.
//(Default): 5280
//TestLong: 12345678901234
//TestArray(0): One
//TestArray(1): Two
//TestArray(2): Three
//TestExpand: My path: %path%
//TestExpand2: My path: D:\Program Files\Microsoft.NET\...
//
//Use the registry editor to examine the key.
//Press the Enter key to delete the key.
Imports Microsoft.Win32

Public Class Example
    Public Shared Sub Main()
        ' The name of the key must include a valid root.
        Const userRoot As String = "HKEY_CURRENT_USER"
        Const subkey As String = "RegistrySetValueExample"
        Const keyName As String = userRoot & "\" & subkey

        ' Integer values can be stored without specifying the
        ' registry data type, but Long values will be stored
        ' as strings unless you specify the type. Note that
        ' the integer is stored in the default name/value
        ' pair.
        Registry.SetValue(keyName, "", 5280)
        Registry.SetValue(keyName, "TestLong", 12345678901234, _
            RegistryValueKind.QWord)

        ' Strings with expandable environment variables are
        ' stored as ordinary strings unless you specify the
        ' data type.
        Registry.SetValue(keyName, "TestExpand", "My path: %path%")
        Registry.SetValue(keyName, "TestExpand2", "My path: %path%", _
            RegistryValueKind.ExpandString)

        ' Arrays of strings are stored automatically as 
        ' MultiString. Similarly, arrays of Byte are stored
        ' automatically as Binary.
        Dim strings() As String = {"One", "Two", "Three"}
        Registry.SetValue(keyName, "TestArray", strings)

        ' Your default value is returned if the name/value pair
        ' does not exist.
        Dim noSuch As String = _
            Registry.GetValue(keyName, "NoSuchName", _
            "Return this default if NoSuchName does not exist.")
        Console.WriteLine(vbCrLf & "NoSuchName: {0}", noSuch)

        ' Retrieve the Integer and Long values, specifying 
        ' numeric default values in case the name/value pairs
        ' do not exist. The Integer value is retrieved from the
        ' default (nameless) name/value pair for the key.
        Dim tInteger As Integer = _
            Registry.GetValue(keyName, "", -1)
        Console.WriteLine("(Default): {0}", tInteger)
        Dim tLong As Long = Registry.GetValue(keyName, _
             "TestLong", Long.MinValue)
        Console.WriteLine("TestLong: {0}", tLong)

        ' When retrieving a MultiString value, you can specify
        ' an array for the default return value. The value is
        ' declared inline, but could also be declared as:
        ' Dim default() As String = {"Default value."}
        '
        Dim tArray() As String = _
            Registry.GetValue(keyName, "TestArray", _
            New String() {"Default if TestArray does not exist."})
        For i As Integer = 0 To tArray.Length - 1
            Console.WriteLine("TestArray({0}): {1}", i, tArray(i))
        Next

        ' A string with embedded environment variables is not
        ' expanded if it was stored as an ordinary string.
        Dim tExpand As String = Registry.GetValue(keyName, _
             "TestExpand", "Default if TestExpand does not exist.")
        Console.WriteLine("TestExpand: {0}", tExpand)

        ' A string stored as ExpandString is expanded.
        Dim tExpand2 As String = Registry.GetValue(keyName, _
             "TestExpand2", "Default if TestExpand2 does not exist.")
        Console.WriteLine("TestExpand2: {0}...", _
            tExpand2.Substring(0, 40))

        Console.WriteLine(vbCrLf & _
            "Use the registry editor to examine the key.")
        Console.WriteLine("Press the Enter key to delete the key.")
        Console.ReadLine()
        Registry.CurrentUser.DeleteSubKey(subkey)
    End Sub
End Class
'
' This code example produces output similar to the following:
'
'NoSuchName: Return this default if NoSuchName does not exist.
'(Default): 5280
'TestLong: 12345678901234
'TestArray(0): One
'TestArray(1): Two
'TestArray(2): Three
'TestExpand: My path: %path%
'TestExpand2: My path: D:\Program Files\Microsoft.NET\...
'
'Use the registry editor to examine the key.
'Press the Enter key to delete the key.

Remarks

Cette classe fournit l’ensemble des clés racines standard trouvées dans le registre sur les ordinateurs exécutant Windows.This class provides the set of standard root keys found in the registry on machines running Windows. Le Registre est une fonctionnalité de stockage pour des informations sur les applications, les utilisateurs et les paramètres système par défaut.The registry is a storage facility for information about applications, users, and default system settings. Par exemple, les applications peuvent utiliser le registre pour stocker des informations qui doivent être conservées après la fermeture de l’application et accéder à ces mêmes informations lorsque l’application est rechargée.For example, applications can use the registry for storing information that needs to be preserved after the application is closed, and access that same information when the application is reloaded. Par exemple, vous pouvez stocker des préférences de couleur, des emplacements d’écran ou la taille de la fenêtre.For instance, you can store color preferences, screen locations, or the size of the window. Vous pouvez contrôler ces données pour chaque utilisateur en stockant les informations à un autre emplacement dans le registre.You can control this data for each user by storing the information in a different location in the registry.

Les instances de base ou de RegistryKey racine qui sont exposées par la classe Registry déposent le mécanisme de stockage de base pour les sous-clés et les valeurs dans le registre.The base, or root RegistryKey instances that are exposed by the Registry class delineate the basic storage mechanism for subkeys and values in the registry. Toutes les clés sont en lecture seule, car le registre dépend de leur existence.All keys are read-only because the registry depends on their existence. Les clés exposées par Registry sont :The keys exposed by Registry are:

CurrentUser
Stocke des informations sur les préférences de l’utilisateur.Stores information about user preferences.

LocalMachine
Stocke les informations de configuration de l’ordinateur local.Stores configuration information for the local machine.

ClassesRoot
Stocke des informations sur les types (et les classes) et leurs propriétés.Stores information about types (and classes) and their properties.

Users
Stocke des informations sur la configuration utilisateur par défaut.Stores information about the default user configuration.

PerformanceData
Stocke les informations de performances des composants logiciels.Stores performance information for software components.

CurrentConfig
Stocke des informations matérielles non spécifiques à l’utilisateur.Stores non-user-specific hardware information.

DynData
Stocke les données dynamiques.Stores dynamic data.

Une fois que vous avez identifié la clé racine dans laquelle vous souhaitez stocker/récupérer des informations dans le registre, vous pouvez utiliser la classe RegistryKey pour ajouter ou supprimer des sous-clés et manipuler les valeurs d’une clé donnée.Once you have identified the root key under which you want to store/retrieve information from the registry, you can use the RegistryKey class to add or remove subkeys, and manipulate the values for a given key.

Les périphériques matériels peuvent placer automatiquement des informations dans le registre à l’aide de l’interface Plug-and-Play.Hardware devices can place information in the registry automatically using the Plug and Play interface. Les logiciels d’installation des pilotes de périphérique peuvent placer des informations dans le registre en écrivant dans des API standard.Software for installing device drivers can place information in the registry by writing to standard APIs.

Méthodes statiques pour obtenir et définir des valeursStatic Methods for Getting and Setting Values

Dans la version 2,0 de .NET Framework, la classe Registry contient également staticméthodes GetValue et SetValue pour définir et récupérer des valeurs à partir de clés de registre.In the .NET Framework version 2.0, the Registry class also contains staticGetValue and SetValue methods for setting and retrieving values from registry keys. Ces méthodes ouvrent et ferment des clés de Registre chaque fois qu’elles sont utilisées. elles ne fonctionnent donc pas aussi bien que les méthodes analogues de la classe RegistryKey, lorsque vous accédez à un grand nombre de valeurs.These methods open and close registry keys each time they are used, so they do not perform as well as analogous methods in the RegistryKey class, when you access a large number of values.

La classe RegistryKey fournit également des méthodes qui vous permettent de définir la sécurité du contrôle d’accès Windows pour les clés de Registre, de tester le type de données d’une valeur avant de la récupérer et de supprimer des clés.The RegistryKey class also provides methods that allow you to set Windows access control security for registry keys, to test the data type of a value before retrieving it, and to delete keys.

Fields

ClassesRoot

Définit les types (ou classes) de documents ainsi que les propriétés associées à ces types.Defines the types (or classes) of documents and the properties associated with those types. Ce champ lit la clé de base HKEY_CLASSES_ROOT du Registre Windows.This field reads the Windows registry base key HKEY_CLASSES_ROOT.

CurrentConfig

Contient des informations de configuration concernant le matériel qui ne sont pas spécifiques à l'utilisateur.Contains configuration information pertaining to the hardware that is not specific to the user. Ce champ lit la clé de base HKEY_CURRENT_CONFIG du Registre Windows.This field reads the Windows registry base key HKEY_CURRENT_CONFIG.

CurrentUser

Contient les informations relatives aux préférences de l'utilisateur en cours.Contains information about the current user preferences. Ce champ lit la clé de base HKEY_CURRENT_USER du Registre Windows.This field reads the Windows registry base key HKEY_CURRENT_USER.

DynData

Contient les données dynamiques du Registre.Contains dynamic registry data. Ce champ lit la clé de base HKEY_DYN_DATA du Registre Windows.This field reads the Windows registry base key HKEY_DYN_DATA.

LocalMachine

Contient les informations de configuration pour l'ordinateur local.Contains the configuration data for the local machine. Ce champ lit la clé de base HKEY_LOCAL_MACHINE du Registre Windows.This field reads the Windows registry base key HKEY_LOCAL_MACHINE.

PerformanceData

Contient des informations sur les performances des composants logiciels.Contains performance information for software components. Ce champ lit la clé de base HKEY_PERFORMANCE_DATA du Registre Windows.This field reads the Windows registry base key HKEY_PERFORMANCE_DATA.

Users

Contient les informations relatives à la configuration utilisateur par défaut.Contains information about the default user configuration. Ce champ lit la clé de base HKEY_USERS du Registre Windows.This field reads the Windows registry base key HKEY_USERS.

Methods

GetValue(String, String, Object)

Récupère la valeur associée au nom spécifié, dans la clé de Registre spécifiée.Retrieves the value associated with the specified name, in the specified registry key. Si le nom est introuvable dans la clé spécifiée, retourne une valeur par défaut que vous fournissez ou la valeur null si la clé spécifiée n'existe pas.If the name is not found in the specified key, returns a default value that you provide, or null if the specified key does not exist.

SetValue(String, String, Object)

Définit la paire nom/valeur spécifiée sur la clé de Registre spécifiée.Sets the specified name/value pair on the specified registry key. Si la clé spécifiée n'existe pas, elle est créée.If the specified key does not exist, it is created.

SetValue(String, String, Object, RegistryValueKind)

Définit la paire nom/valeur sur la clé de Registre spécifiée, à l'aide du type de données de Registre spécifié.Sets the name/value pair on the specified registry key, using the specified registry data type. Si la clé spécifiée n'existe pas, elle est créée.If the specified key does not exist, it is created.

Applies to

See also