Registry.GetValue(String, String, Object) Méthode
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Récupère la valeur associée au nom spécifié, dans la clé de Registre spécifiée. 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.
public:
static System::Object ^ GetValue(System::String ^ keyName, System::String ^ valueName, System::Object ^ defaultValue);public static object GetValue (string keyName, string valueName, object defaultValue);public static object? GetValue (string keyName, string? valueName, object? defaultValue);static member GetValue : string * string * obj -> objPublic Shared Function GetValue (keyName As String, valueName As String, defaultValue As Object) As ObjectParamètres
- keyName
- String
Chemin de Registre complet de la clé, commençant avec une racine de Registre valide, comme « HKEY_CURRENT_USER ».
- valueName
- String
Nom de la paire nom/valeur.
- defaultValue
- Object
Valeur à retourner si valueName n'existe pas.
Retours
null si la sous-clé spécifiée par keyName n'existe pas ; autrement, la valeur associée à valueName ou defaultValue si valueName est introuvable.
Exceptions
L'utilisateur n'a pas les autorisations requises pour lire dans la clé de Registre.
RegistryKey qui contient la valeur spécifiée a été marqué pour suppression.
keyName ne commence pas par une racine de Registre valide.
Exemples
L’exemple de code suivant stocke des valeurs de plusieurs types de données dans un exemple de clé, en créant la clé comme il le fait, puis récupère et affiche les valeurs. L’exemple illustre le stockage et la récupération de la paire nom/valeur par défaut (sans nom), ainsi que l’utilisation de defaultValue quand une paire nom/valeur n’existe pas.
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.
Remarques
La chaîne valueName ne respecte pas la casse.
Notes
Une clé de Registre peut contenir une valeur qui n’est associée à aucun nom. Lorsque cette valeur sans nom est affichée dans l’éditeur du Registre, la chaîne « (Par défaut) » s’affiche à la place d’un nom. Pour récupérer cette valeur sans nom, spécifiez null ou la chaîne vide (« ») pour valueName.
Les noms racines valides sont HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE, HKEY_CLASSES_ROOT, HKEY_USERS, HKEY_PERFORMANCE_DATA, HKEY_CURRENT_CONFIG et HKEY_DYN_DATA. Par exemple, dans Visual Basic, la chaîne « HKEY_CURRENT_USER\MyTestKey » accède aux paires clé/valeur pour la sous-clé « MyTestKey » dans la racine HKEY_CURRENT_USER.
Lorsque la GetValue méthode récupère des valeurs de chaîne extensibles (RegistryValueKind.ExpandString), elle développe les chaînes d’environnement à l’aide des données de l’environnement local. Si une valeur contenant des références extensibles à des variables d’environnement a été stockée sous la forme d’une chaîne (RegistryValueKind.String), plutôt que sous forme de chaîne extensible (RegistryValueKind.ExpandString), GetValue ne la développe pas. Vous pouvez développer une telle chaîne une fois qu’elle a été récupérée en appelant la Environment.ExpandEnvironmentVariables méthode .
Notes
La méthode recommandée pour récupérer des données à partir de HKEY_PERFORMANCE_DATA consiste à utiliser la PerformanceCounter classe plutôt que la RegistryKey.GetValue méthode .
Les GetValue méthodes et SetValue ouvrent et ferment les clés de Registre chaque fois qu’elles sont utilisées, de sorte qu’elles ne fonctionnent pas aussi bien que les méthodes de la RegistryKey classe si vous accédez à un grand nombre de valeurs.
RegistryKey fournit également des méthodes qui vous permettent d’ajouter une liste de contrôle d’accès (ACL) à une clé de Registre, de tester le type de données d’une valeur avant de la récupérer et de supprimer des clés.
S’applique à
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour