RegistryKey::GetValue Method (String^)
Retrieves the value associated with the specified name. Returns null if the name/value pair does not exist in the registry.
Assembly: mscorlib (in mscorlib.dll)
Parameters
- name
-
Type:
System::String^
The name of the value to retrieve. This string is not case-sensitive.
| Exception | Condition |
|---|---|
| SecurityException | The user does not have the permissions required to read from the registry key. |
| ObjectDisposedException | The RegistryKey that contains the specified value is closed (closed keys cannot be accessed). |
| IOException | The RegistryKey that contains the specified value has been marked for deletion. |
| UnauthorizedAccessException | The user does not have the necessary registry rights. |
Note |
|---|
A registry key can have one value that is not associated with any name. When this unnamed value is displayed in the registry editor, the string "(Default)" appears instead of a name. To retrieve this unnamed value, specify either null or the empty string ("") for name. |
When the GetValue method retrieves expandable string values (RegistryValueKind::ExpandString), it expands environment strings using data from the local environment. To retrieve expandable string values from the registry on a remote computer, use the GetValue(String^, Object^, RegistryValueOptions) method overload to specify that you do not want environment strings expanded.
Note |
|---|
If a value containing expandable references to environment variables has been stored as a string (RegistryValueKind::String), rather than as an expandable string (RegistryValueKind::ExpandString), GetValue does not expand it. You can expand such a string after it has been retrieved by calling the ExpandEnvironmentVariables method. |
Note |
|---|
The recommended way to retrieve data from the PerformanceData key is to use the PerformanceCounter class rather than the RegistryKey::GetValue method. GetValue does not support reading values of type REG_NONE or REG_LINK. In both cases, the default value (null) is returned instead of the actual value. |
The following code example creates a test key and adds values of different data types to the key. The example then reads the name/value pairs and displays them to the console, using the GetValueKind method to retrieve the corresponding registry data types.
using namespace System; using namespace Microsoft::Win32; int main() { // Delete and recreate the test key. Registry::CurrentUser->DeleteSubKey( "RegistryValueKindExample", false ); RegistryKey ^ rk = Registry::CurrentUser->CreateSubKey( "RegistryValueKindExample" ); // Create name/value pairs. // This overload supports QWord (long) values. rk->SetValue( "QuadWordValue", 42, RegistryValueKind::QWord ); // The following SetValue calls have the same effect as using the // SetValue overload that does not specify RegistryValueKind. // rk->SetValue( "DWordValue", 42, RegistryValueKind::DWord ); rk->SetValue( "MultipleStringValue", gcnew array<String^>{ "One","Two","Three" }, RegistryValueKind::MultiString ); rk->SetValue( "BinaryValue", gcnew array<Byte>{ 10,43,44,45,14,255 }, RegistryValueKind::Binary ); rk->SetValue( "StringValue", "The path is %PATH%", RegistryValueKind::String ); // This overload supports setting expandable string values. Compare // the output from this value with the previous string value. rk->SetValue( "ExpandedStringValue", "The path is %PATH%", RegistryValueKind::ExpandString ); // Display all the name/value pairs stored in the test key, with the // registry data type in parentheses. // array<String^>^valueNames = rk->GetValueNames(); System::Collections::IEnumerator^ myEnum = valueNames->GetEnumerator(); while ( myEnum->MoveNext() ) { String^ s = safe_cast<String^>(myEnum->Current); RegistryValueKind rvk = rk->GetValueKind( s ); switch ( rvk ) { case RegistryValueKind::MultiString: { array<String^>^values = (array<String^>^)rk->GetValue( s ); Console::Write( "\r\n {0} ({1}) =", s, rvk ); for ( int i = 0; i < values->Length; i++ ) { if (i != 0) Console::Write(","); Console::Write( " \"{0}\"", values[ i ] ); } Console::WriteLine(); break; } case RegistryValueKind::Binary: { array<Byte>^bytes = (array<Byte>^)rk->GetValue( s ); Console::Write( "\r\n {0} ({1}) =", s, rvk ); for ( int i = 0; i < bytes->Length; i++ ) { // Display each byte as two hexadecimal digits. Console::Write( " {0:X2}", bytes[ i ] ); } Console::WriteLine(); break; } default: Console::WriteLine( "\r\n {0} ({1}) = {2}", s, rvk, rk->GetValue( s ) ); break; } } } /* This code example produces the following output: QuadWordValue (QWord) = 42 DWordValue (DWord) = 42 MultipleStringValue (MultiString) =, "One", "Two", "Three" BinaryValue (Binary) = 0A 2B 2C 2D 0E FF StringValue (String) = The path is %PATH% ExpandedStringValue (ExpandString) = The path is C:\Program Files\Microsoft.NET\SDK\v2.0\Bin; [***The remainder of this output is omitted.***] */
to read from the registry. Associated enumeration: RegistryPermissionAccess::Read
to read a registry key of type REG_EXPAND_SZ. Associated enumeration: PermissionState::Unrestricted
Available since 1.1
