RegistryKey.GetValue Methode

Referenz

Definition

Namespace:: Microsoft.Win32

Assembly:: Microsoft.Win32.Registry.dll

Assembly:: mscorlib.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Ruft den Wert ab, der dem angegebenen Namen zugeordnet ist.

Überlädt

GetValue(String, Object, RegistryValueOptions)	Ruft den Wert ab, der dem angegebenen Namen und den Abrufoptionen zugeordnet ist. Wenn der Name nicht gefunden wird, wird der von Ihnen bereitgestellte Standardwert zurückgegeben.
GetValue(String)	Ruft den Wert ab, der dem angegebenen Namen zugeordnet ist. Gibt `null` zurück, wenn das Name-Wert-Paar in der Registrierung nicht vorhanden ist.
GetValue(String, Object)	Ruft den Wert ab, der dem angegebenen Namen zugeordnet ist. Wenn der Name nicht gefunden wird, wird der von Ihnen bereitgestellte Standardwert zurückgegeben.

GetValue(String, Object, RegistryValueOptions)

Quelle:: RegistryKey.cs

Ruft den Wert ab, der dem angegebenen Namen und den Abrufoptionen zugeordnet ist. Wenn der Name nicht gefunden wird, wird der von Ihnen bereitgestellte Standardwert zurückgegeben.

public:
 System::Object ^ GetValue(System::String ^ name, System::Object ^ defaultValue, Microsoft::Win32::RegistryValueOptions options);

public object GetValue (string name, object defaultValue, Microsoft.Win32.RegistryValueOptions options);

public object? GetValue (string? name, object? defaultValue, Microsoft.Win32.RegistryValueOptions options);

[System.Runtime.InteropServices.ComVisible(false)]
public object GetValue (string name, object defaultValue, Microsoft.Win32.RegistryValueOptions options);

member this.GetValue : string * obj * Microsoft.Win32.RegistryValueOptions -> obj

[<System.Runtime.InteropServices.ComVisible(false)>]
member this.GetValue : string * obj * Microsoft.Win32.RegistryValueOptions -> obj

Public Function GetValue (name As String, defaultValue As Object, options As RegistryValueOptions) As Object

Parameter

name: String

Der Name des abzurufenden Werts. Bei dieser Zeichenfolge wird die Groß-/Kleinschreibung nicht berücksichtigt.

defaultValue: Object

Der zurückzugebende Wert, wenn name nicht vorhanden ist.

options: RegistryValueOptions

Einer der Enumerationswerte, die eine optionale Verarbeitung des abgerufenen Werts angeben.

Gibt zurück

Object

Der name zugeordnete Wert, der entsprechend den options verarbeitet wurde, oder defaultValue, wenn name nicht gefunden wird.

Attribute: ComVisibleAttribute

Ausnahmen

SecurityException

Der Benutzer verfügt nicht über die erforderlichen Berechtigungen, um aus dem Registrierungsschlüssel zu lesen.

ObjectDisposedException

Der RegistryKey, der den angegebenen Wert enthält, ist geschlossen (auf geschlossene Schlüssel kann nicht zugegriffen werden).

IOException

Der RegistryKey, der den angegebenen Wert enthält, wurde zum Löschen markiert.

ArgumentException

options ist kein gültiger RegistryValueOptions-Wert; ein ungültiger Wert wird z. B. in RegistryValueOptions umgewandelt.

UnauthorizedAccessException

Der Benutzer verfügt nicht über die notwendigen Registrierungsrechte.

Beispiele

Im folgenden Codebeispiel wird ein Testschlüssel erstellt, ein Wert mit einer eingebetteten Umgebungsvariablen hinzugefügt und der Wert in erweiterter und nicht erweiterter Form abgerufen.

#using <Microsoft.VisualBasic.dll>

using namespace System;
using namespace Microsoft::Win32;
using namespace Microsoft::VisualBasic;

int main()
{
    // Delete and recreate the test key.
    Registry::CurrentUser->DeleteSubKey( L"RegistryValueOptionsExample", false );
    RegistryKey ^ rk = 
        Registry::CurrentUser->CreateSubKey( L"RegistryValueOptionsExample" );
   
    // Add a value that contains an environment variable.
    rk->SetValue( L"ExpandValue", L"The path is %PATH%", 
        RegistryValueKind::ExpandString );
   
    // Retrieve the value, first without expanding the environment
    // variable and then expanding it.
    Console::WriteLine( L"Unexpanded: \"{0}\"", 
                        rk->GetValue( L"ExpandValue", 
                        L"No Value", 
                        RegistryValueOptions::DoNotExpandEnvironmentNames ) );
    Console::WriteLine( L"Expanded: \"{0}\"", rk->GetValue( L"ExpandValue" ) );
 
    return 0;
} //Main

using System;
using Microsoft.Win32;
using Microsoft.VisualBasic;

public class Example
{
    public static void Main()
    {
        // Delete and recreate the test key.
        Registry.CurrentUser.DeleteSubKey("RegistryValueOptionsExample", false);
        RegistryKey rk =
            Registry.CurrentUser.CreateSubKey("RegistryValueOptionsExample");

        // Add a value that contains an environment variable.
        rk.SetValue("ExpandValue", "The path is %PATH%", RegistryValueKind.ExpandString);

        // Retrieve the value, first without expanding the environment
        // variable and then expanding it.
        Console.WriteLine("Unexpanded: \"{0}\"",
            rk.GetValue("ExpandValue", "No Value",
            RegistryValueOptions.DoNotExpandEnvironmentNames));
        Console.WriteLine("Expanded: \"{0}\"", rk.GetValue("ExpandValue"));
    } //Main
} //Example

Imports Microsoft.Win32

Public Class Example
    Public Shared Sub Main()
        ' Delete and recreate the test key.
        Registry.CurrentUser.DeleteSubKey("RegistryValueOptionsExample", False)
        Dim rk As RegistryKey = _
            Registry.CurrentUser.CreateSubKey("RegistryValueOptionsExample")

        ' Add a value that contains an environment variable.
        rk.SetValue("ExpandValue", "The path is %PATH%", _
            RegistryValueKind.ExpandString)

        ' Retrieve the value, first without expanding the environment 
        ' variable and then expanding it.
        Console.WriteLine("Unexpanded: ""{0}""", _
            rk.GetValue("ExpandValue", "No Value", _
            RegistryValueOptions.DoNotExpandEnvironmentNames))
        Console.WriteLine("Expanded: ""{0}""", rk.GetValue("ExpandValue"))
    End Sub
End Class

Hinweise

Verwenden Sie diese Überladung, um eine spezielle Verarbeitung des abgerufenen Werts anzugeben. Beispielsweise können Sie beim Abrufen eines Registrierungswerts vom Typ RegistryValueKind.ExpandString angebenRegistryValueOptions.DoNotExpandEnvironmentNames, um die Zeichenfolge abzurufen, ohne eingebettete Umgebungsvariablen zu erweitern.

Verwenden Sie den defaultValue Parameter, um den Wert anzugeben, der zurückgegeben werden soll, wenn name nicht vorhanden ist.

Hinweis

Ein Registrierungsschlüssel kann einen Wert aufweisen, der keinem Namen zugeordnet ist. Wenn dieser unbenannte Wert im Registrierungs-Editor angezeigt wird, wird anstelle eines Namens die Zeichenfolge "(Standard)" angezeigt. Um diesen unbenannten Wert abzurufen, geben Sie entweder null oder die leere Zeichenfolge ("") für namean.

GetValue unterstützt das Lesen von Werten vom Typ REG_NONE oder REG_LINK nicht. In beiden Fällen wird der Standardwert (null) anstelle des tatsächlichen Werts zurückgegeben.

Weitere Informationen

Gilt für:

GetValue(String)

Quelle:: RegistryKey.cs

Ruft den Wert ab, der dem angegebenen Namen zugeordnet ist. Gibt null zurück, wenn das Name-Wert-Paar in der Registrierung nicht vorhanden ist.

public:
 System::Object ^ GetValue(System::String ^ name);

public object GetValue (string name);

public object? GetValue (string? name);

member this.GetValue : string -> obj

Public Function GetValue (name As String) As Object

Parameter

name: String

Der Name des abzurufenden Werts. Bei dieser Zeichenfolge wird die Groß-/Kleinschreibung nicht berücksichtigt.

Gibt zurück

Object

Der name zugeordnete Wert oder null, wenn name nicht gefunden wurde.

Ausnahmen

SecurityException

Der Benutzer verfügt nicht über die erforderlichen Berechtigungen, um aus dem Registrierungsschlüssel zu lesen.

ObjectDisposedException

Der RegistryKey, der den angegebenen Wert enthält, ist geschlossen (auf geschlossene Schlüssel kann nicht zugegriffen werden).

IOException

Der RegistryKey, der den angegebenen Wert enthält, wurde zum Löschen markiert.

UnauthorizedAccessException

Der Benutzer verfügt nicht über die notwendigen Registrierungsrechte.

Beispiele

Im folgenden Codebeispiel wird ein Testschlüssel erstellt und dem Schlüssel Werte verschiedener Datentypen hinzugefügt. Das Beispiel liest dann die Namen-Wert-Paare und zeigt sie in der Konsole an, wobei die GetValueKind -Methode verwendet wird, um die entsprechenden Registrierungsdatentypen abzurufen.

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.***]

*/

using System;
using Microsoft.Win32;

public class Example
{
    public static void 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", new string[] {"One", "Two", "Three"}, RegistryValueKind.MultiString);
        rk.SetValue("BinaryValue", new 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 name/value pairs stored in the test key, with each
        // registry data type in parentheses.
        //
        string[] valueNames = rk.GetValueNames();
        foreach (string s in valueNames)
        {
            RegistryValueKind rvk = rk.GetValueKind(s);
            switch (rvk)
            {
                case RegistryValueKind.MultiString :
                    string[] values = (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 :
                    byte[] bytes = (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.***]

*/

Imports Microsoft.Win32

Public Class Example
    Public Shared Sub Main()
        ' Delete and recreate the test key.
        Registry.CurrentUser.DeleteSubKey("RegistryValueKindExample", False)
        Dim rk As RegistryKey = 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", New String() {"One", "Two", "Three"}, RegistryValueKind.MultiString)
        rk.SetValue("BinaryValue", New 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 name/value pairs stored in the test key, with each
        ' registry data type in parentheses.
        '
        Dim valueNames As String() = rk.GetValueNames()
        Dim s As String
        For Each s In  valueNames
            Dim rvk As RegistryValueKind = rk.GetValueKind(s)
            Select Case rvk
                Case RegistryValueKind.MultiString
                    Dim values As String() = CType(rk.GetValue(s), String())
                    Console.Write(vbCrLf & " {0} ({1}) =", s, rvk)
                    For i As Integer = 0 To values.Length - 1
                        If i <> 0 Then Console.Write(",")
                        Console.Write(" ""{0}""", values(i))
                    Next i
                    Console.WriteLine()
                
                Case RegistryValueKind.Binary
                    Dim bytes As Byte() = CType(rk.GetValue(s), Byte())
                    Console.Write(vbCrLf & " {0} ({1}) =", s, rvk)
                    For i As Integer = 0 To bytes.Length - 1
                        ' Display each byte as two hexadecimal digits.
                        Console.Write(" {0:X2}", bytes(i))
                    Next i
                    Console.WriteLine()
                
                Case Else
                    Console.WriteLine(vbCrLf & " {0} ({1}) = {2}", s, rvk, rk.GetValue(s))
            End Select
        Next s
    End Sub
End Class

'
'This code example produces the following output (some output is omitted):
'
' 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.***]

Hinweise

Hinweis

Wenn die GetValue -Methode erweiterbare Zeichenfolgenwerte (RegistryValueKind.ExpandString) abruft, erweitert sie Umgebungszeichenfolgen mithilfe von Daten aus der lokalen Umgebung. Um erweiterbare Zeichenfolgenwerte aus der Registrierung auf einem Remotecomputer abzurufen, verwenden Sie die GetValue(String, Object, RegistryValueOptions) Methodenüberladung, um anzugeben, dass Umgebungszeichenfolgen nicht erweitert werden sollen.

Hinweis

Wenn ein Wert, der erweiterbare Verweise auf Umgebungsvariablen enthält, als Zeichenfolge (RegistryValueKind.String) und nicht als erweiterbare Zeichenfolge (RegistryValueKind.ExpandString) gespeichert wurde, GetValue wird er nicht erweitert. Sie können eine solche Zeichenfolge erweitern, nachdem sie abgerufen wurde, indem Sie die ExpandEnvironmentVariables -Methode aufrufen.

Hinweis

Die empfohlene Methode zum Abrufen von Daten aus dem PerformanceData Schlüssel besteht darin, die PerformanceCounter -Klasse anstelle der RegistryKey.GetValue -Methode zu verwenden.

GetValue unterstützt das Lesen von Werten vom Typ REG_NONE oder REG_LINK nicht. In beiden Fällen wird der Standardwert (null) anstelle des tatsächlichen Werts zurückgegeben.

Weitere Informationen

Gilt für:

GetValue(String, Object)

Quelle:: RegistryKey.cs

Ruft den Wert ab, der dem angegebenen Namen zugeordnet ist. Wenn der Name nicht gefunden wird, wird der von Ihnen bereitgestellte Standardwert zurückgegeben.

public:
 System::Object ^ GetValue(System::String ^ name, System::Object ^ defaultValue);

public object GetValue (string name, object defaultValue);

public object? GetValue (string? name, object? defaultValue);

member this.GetValue : string * obj -> obj

Public Function GetValue (name As String, defaultValue As Object) As Object

Parameter

name: String

Der Name des abzurufenden Werts. Bei dieser Zeichenfolge wird die Groß-/Kleinschreibung nicht berücksichtigt.

defaultValue: Object

Der zurückzugebende Wert, wenn name nicht vorhanden ist.

Gibt zurück

Object

Der name zugeordnete Wert mit allen eingebetteten Umgebungsvariablen, die nicht erweitert wurden, oder defaultValue, wenn name nicht gefunden wurde.

Ausnahmen

SecurityException

Der Benutzer verfügt nicht über die erforderlichen Berechtigungen, um aus dem Registrierungsschlüssel zu lesen.

ObjectDisposedException

Der RegistryKey, der den angegebenen Wert enthält, ist geschlossen (auf geschlossene Schlüssel kann nicht zugegriffen werden).

IOException

Der RegistryKey, der den angegebenen Wert enthält, wurde zum Löschen markiert.

UnauthorizedAccessException

Der Benutzer verfügt nicht über die notwendigen Registrierungsrechte.

Beispiele

Im folgenden Codebeispiel wird ein Testschlüssel mit einem Wert erstellt und dieser Wert abgerufen. Im Beispiel wird dann versucht, einen nicht vorhandenen Wert aus dem Schlüssel abzurufen. In diesem Fall gibt die GetValue -Methode den angegebenen Standardwert zurück.

using namespace System;
using namespace Microsoft::Win32;

public ref class RegGetDef
{
public:
    static void Main()
    {
        // Create a reference to a valid key.  In order for this code to
        // work, the indicated key must have been created previously.
        // The key name is not case-sensitive.
        RegistryKey^ rk = Registry::LocalMachine->OpenSubKey("Software\\myTestKey", false);
        // Get the value from the specified name/value pair in the key.
        String^ valueName = "myTestValue";

        Console::WriteLine("Retrieving registry value ...");
        Console::WriteLine();
        Object^ o = rk->GetValue(valueName);
        Console::WriteLine("Object Type = " + o->GetType()->FullName);
        Console::WriteLine();
        switch (rk->GetValueKind(valueName))
        {
            case RegistryValueKind::String:
            case RegistryValueKind::ExpandString:
                Console::WriteLine("Value = " + o);
                break;
            case RegistryValueKind::Binary:
                for each (Byte^ b in (array<Byte^>^)o)
                {
                    Console::Write("{0:x2} ", b);
                }
                Console::WriteLine();
                break;
            case RegistryValueKind::DWord:
                Console::WriteLine("Value = " + Convert::ToString((Int32^)o));
                break;
            case RegistryValueKind::QWord:
                Console::WriteLine("Value = " + Convert::ToString((Int64^)o));
                break;
            case RegistryValueKind::MultiString:
                for each (String^ s in (array<String^>^)o)
                {
                    Console::Write("[{0:s}], ", s);
                }
                Console::WriteLine();
                break;
            default:
                Console::WriteLine("Value = (Unknown)");
                break;
        }

        // Attempt to retrieve a value that does not exist; the specified
        // default value is returned.
        String^ def = (String^)rk->GetValue("notavalue", "The default to return");
        Console::WriteLine();
        Console::WriteLine(def);
        
        rk->Close();
    }
};

int main()
{
    RegGetDef::Main();
}
/*
Output:
Retrieving registry value ...

Object Type = System.String

Value = testData

The default to return
*/

using System;
using Microsoft.Win32;

class RegGetDef
{
    public static void Main()
    {
        // Create a reference to a valid key.  In order for this code to
        // work, the indicated key must have been created previously.
        // The key name is not case-sensitive.
        RegistryKey rk = Registry.LocalMachine.OpenSubKey("Software\\myTestKey", false);
        // Get the value from the specified name/value pair in the key.

        string valueName = "myTestValue";

        Console.WriteLine("Retrieving registry value ...");
        Console.WriteLine();
        object o = rk.GetValue(valueName);
        Console.WriteLine("Object Type = " + o.GetType().FullName);
        Console.WriteLine();
        switch (rk.GetValueKind(valueName))
        {
            case RegistryValueKind.String:
            case RegistryValueKind.ExpandString:
                Console.WriteLine("Value = " + o);
                break;
            case RegistryValueKind.Binary:
                foreach (byte b in (byte[])o)
                {
                    Console.Write("{0:x2} ", b);
                }
                Console.WriteLine();
                break;
            case RegistryValueKind.DWord:
                Console.WriteLine("Value = " + Convert.ToString((int)o));
                break;
            case RegistryValueKind.QWord:
                Console.WriteLine("Value = " + Convert.ToString((Int64)o));
                break;
            case RegistryValueKind.MultiString:
                foreach (string s in (string[])o)
                {
                    Console.Write("[{0:s}], ", s);
                }
                Console.WriteLine();
                break;
            default:
                Console.WriteLine("Value = (Unknown)");
                break;
        }

        // Attempt to retrieve a value that does not exist; the specified
        // default value is returned.
        string def = (string)rk.GetValue("notavalue", "The default to return");
        Console.WriteLine();
        Console.WriteLine(def);

        rk.Close();
    }
}
/*
Output:
Retrieving registry value ...

Object Type = System.String

Value = testData

The default to return
*/

Imports Microsoft.Win32

Public Class RegGetDef
    Public Shared Sub Main()
        ' Create a reference to a valid key.  In order for this code to
        ' work, the indicated key must have been created previously.
        ' The key name is not case-sensitive.
        Dim rk As RegistryKey = Registry.LocalMachine.OpenSubKey("Software\myTestKey", false)

        ' Get the value from the specified name/value pair in the key.
        Dim valueName As String = "myTestValue"

        Console.WriteLine("Retrieving registry value ...")
        Console.WriteLine()
        Dim o As Object = rk.GetValue(valueName)
        Console.WriteLine("Object Type = " + o.GetType().FullName)
        Console.WriteLine()
        Select Case rk.GetValueKind(valueName)
            Case RegistryValueKind.String
            Case RegistryValueKind.ExpandString
                Console.WriteLine("Value = " + o)
            Case RegistryValueKind.Binary
                For Each b As Byte In CType(o,Byte())
                    Console.Write("{0:x2} ", b)
                Next b
                Console.WriteLine()
            Case RegistryValueKind.DWord
                Console.WriteLine("Value = " + Convert.ToString(CType(o,Int32)))
            Case RegistryValueKind.QWord
                Console.WriteLine("Value = " + Convert.ToString(CType(o,Int64)))
            Case RegistryValueKind.MultiString
                For Each s As String In CType(o,String())
                    Console.Write("[{0:s}], ", s)
                Next s
                Console.WriteLine()
            Case Else
                Console.WriteLine("Value = (Unknown)")
        End Select

        ' Attempt to retrieve a value that does not exist; the specified
        ' default value is returned.
        Dim Def As String = rk.GetValue("notavalue", "The default to return")
        Console.WriteLine()
        Console.WriteLine(def)
        
        rk.Close()
    End Sub
End Class
'
' Output:
' Retrieving registry value ...
'
' Object Type = System.String
'
' Value = testData
'
'The default to return

Hinweise

Verwenden Sie diese Überladung von GetValue , um den Fall zu behandeln, in dem noch kein Name vorhanden ist, z. B. bei der ersten Ausführung ihrer Anwendung. Wenn Sie diese Überladung aufrufen, verwenden Sie den defaultValue -Parameter, um den Wert anzugeben, der zurückgegeben werden soll, wenn name nicht vorhanden ist.

Hinweis

Wenn die GetValue -Methode erweiterbare Zeichenfolgenwerte (RegistryValueKind.ExpandString) abruft, erweitert sie Umgebungszeichenfolgen mithilfe von Daten aus der lokalen Umgebung. Um erweiterbare Zeichenfolgenwerte aus der Registrierung auf einem Remotecomputer abzurufen, verwenden Sie die GetValue Überladung, um anzugeben, dass Umgebungszeichenfolgen nicht erweitert werden sollen.

Hinweis

Wenn ein Wert, der erweiterbare Verweise auf Umgebungsvariablen enthält, als Zeichenfolge (RegistryValueKind.String) und nicht als erweiterbare Zeichenfolge (RegistryValueKind.ExpandString) gespeichert wurde, wird er von der GetValue -Methode nicht erweitert. Sie können eine solche Zeichenfolge erweitern, nachdem sie abgerufen wurde, indem Sie die ExpandEnvironmentVariables -Methode aufrufen.

Hinweis

Die empfohlene Methode zum Abrufen von Daten aus dem PerformanceData Schlüssel besteht darin, die PerformanceCounter -Klasse anstelle der RegistryKey.GetValue -Methode zu verwenden.

GetValue unterstützt das Lesen von Werten vom Typ REG_NONE oder REG_LINK nicht. In beiden Fällen wird der Standardwert (null) anstelle des tatsächlichen Werts zurückgegeben.

Weitere Informationen

Gilt für:

RegistryKey.GetValue Methode

Definition

Überlädt

GetValue(String, Object, RegistryValueOptions)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

GetValue(String)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

GetValue(String, Object)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Feedback

Zusätzliche Ressourcen