RegistryKey.GetValue Metoda

Odwołanie

Definicja

Przestrzeń nazw:: Microsoft.Win32

Zestaw:: Microsoft.Win32.Registry.dll

Zestaw:: mscorlib.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Pobiera wartość skojarzoną z podaną nazwą.

Przeciążenia

GetValue(String, Object, RegistryValueOptions)	Pobiera wartość skojarzona z określoną nazwą i opcjami pobierania. Jeśli nazwa nie zostanie znaleziona, zwraca podaną wartość domyślną.
GetValue(String)	Pobiera wartość skojarzoną z podaną nazwą. Zwraca wartość `null` , jeśli para nazwa/wartość nie istnieje w rejestrze.
GetValue(String, Object)	Pobiera wartość skojarzoną z podaną nazwą. Jeśli nazwa nie zostanie znaleziona, zwraca podaną wartość domyślną.

GetValue(String, Object, RegistryValueOptions)

Źródło:: RegistryKey.cs

Pobiera wartość skojarzona z określoną nazwą i opcjami pobierania. Jeśli nazwa nie zostanie znaleziona, zwraca podaną wartość domyślną.

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

Parametry

name: String

Nazwa wartości do pobrania. W tym ciągu nie jest rozróżniana wielkość liter.

defaultValue: Object

Wartość, która ma być zwracana, jeśli name nie istnieje.

options: RegistryValueOptions

Jedna z wartości wyliczenia, która określa opcjonalne przetwarzanie pobranej wartości.

Zwraca

Object

Wartość skojarzona z elementem , przetworzona zgodnie z określoną wartością nameoptionslub defaultValue jeśli name nie zostanie znaleziona.

Atrybuty: ComVisibleAttribute

Wyjątki

SecurityException

Użytkownik nie posiada uprawnień niezbędnych do czytania treści klucza rejestru.

ObjectDisposedException

Element RegistryKey zawierający określoną wartość jest zamknięty (nie można uzyskać dostępu do kluczy zamkniętych).

IOException

Element RegistryKey zawierający określoną wartość został oznaczony do usunięcia.

ArgumentException

options nie jest prawidłową RegistryValueOptions wartością, na przykład jest rzutowanie nieprawidłowej wartości na RegistryValueOptionswartość .

UnauthorizedAccessException

Użytkownik nie posiada niezbędnych praw wobec rejestru.

Przykłady

Poniższy przykładowy kod tworzy klucz testowy, dodaje wartość z osadzoną zmienną środowiskową i pobiera wartość zarówno w formularzach rozwiniętych, jak i nieoznakowanych.

#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

Uwagi

Użyj tego przeciążenia, aby określić specjalne przetwarzanie pobranej wartości. Można na przykład określić RegistryValueOptions.DoNotExpandEnvironmentNames podczas pobierania wartości rejestru typu RegistryValueKind.ExpandString w celu pobrania ciągu bez rozszerzania osadzonych zmiennych środowiskowych.

Użyj parametru , defaultValue aby określić wartość, która ma być zwracana, jeśli name nie istnieje.

Uwaga

Klucz rejestru może mieć jedną wartość, która nie jest skojarzona z żadną nazwą. Gdy ta nienazwana wartość jest wyświetlana w Edytorze rejestru, zamiast nazwy pojawia się ciąg „(Domyślna)”. Aby pobrać tę nienazwaną wartość, określ ciąg null pusty ("") dla parametru name.

GetValue nie obsługuje odczytywania wartości typu REG_NONE lub REG_LINK. W obu przypadkach wartość domyślna (null) jest zwracana zamiast rzeczywistej wartości.

Zobacz też

Dotyczy

GetValue(String)

Źródło:: RegistryKey.cs

Pobiera wartość skojarzoną z podaną nazwą. Zwraca wartość null , jeśli para nazwa/wartość nie istnieje w rejestrze.

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

Parametry

name: String

Nazwa wartości do pobrania. W tym ciągu nie jest rozróżniana wielkość liter.

Zwraca

Object

Wartość skojarzona z elementem namelub null , jeśli name nie zostanie znaleziona.

Wyjątki

SecurityException

Użytkownik nie posiada uprawnień niezbędnych do czytania treści klucza rejestru.

ObjectDisposedException

Element RegistryKey zawierający określoną wartość jest zamknięty (nie można uzyskać dostępu do kluczy zamkniętych).

IOException

Element RegistryKey zawierający określoną wartość został oznaczony do usunięcia.

UnauthorizedAccessException

Użytkownik nie posiada niezbędnych praw wobec rejestru.

Przykłady

Poniższy przykład kodu tworzy klucz testowy i dodaje wartości różnych typów danych do klucza. Następnie przykład odczytuje pary nazw/wartości i wyświetla je w konsoli przy użyciu GetValueKind metody w celu pobrania odpowiednich typów danych rejestru.

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

Uwagi

Uwaga

GetValue Gdy metoda pobiera rozszerzalne wartości ciągów (RegistryValueKind.ExpandString), rozszerza ciągi środowiska przy użyciu danych ze środowiska lokalnego. Aby pobrać rozszerzalne wartości ciągów z rejestru na komputerze zdalnym, użyj GetValue(String, Object, RegistryValueOptions) przeciążenia metody, aby określić, że ciągi środowiskowe nie mają być rozwinięte.

Uwaga

Jeśli wartość zawierająca odwołania rozszerzalne do zmiennych środowiskowych została zapisana jako ciąg (RegistryValueKind.String), a nie jako ciąg rozszerzalny (RegistryValueKind.ExpandString), GetValue nie rozszerza go. Możesz rozwinąć taki ciąg po jego pobraniu, wywołując metodę ExpandEnvironmentVariables .

Uwaga

Zalecanym sposobem pobierania danych z PerformanceData klucza jest użycie PerformanceCounter klasy, a nie RegistryKey.GetValue metody.

GetValue nie obsługuje odczytywania wartości typu REG_NONE lub REG_LINK. W obu przypadkach wartość domyślna (null) jest zwracana zamiast rzeczywistej wartości.

Zobacz też

Dotyczy

GetValue(String, Object)

Źródło:: RegistryKey.cs

Pobiera wartość skojarzoną z podaną nazwą. Jeśli nazwa nie zostanie znaleziona, zwraca podaną wartość domyślną.

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

Parametry

name: String

Nazwa wartości do pobrania. W tym ciągu nie jest rozróżniana wielkość liter.

defaultValue: Object

Wartość, która ma być zwracana, jeśli name nie istnieje.

Zwraca

Object

Wartość skojarzona z elementem namez dowolnymi osadzonymi zmiennymi środowiskowymi pozostawiona bez rozpiętego lub defaultValue jeśli name nie zostanie znaleziona.

Wyjątki

SecurityException

Użytkownik nie posiada uprawnień niezbędnych do czytania treści klucza rejestru.

ObjectDisposedException

Element RegistryKey zawierający określoną wartość jest zamknięty (nie można uzyskać dostępu do kluczy zamkniętych).

IOException

Element RegistryKey zawierający określoną wartość został oznaczony do usunięcia.

UnauthorizedAccessException

Użytkownik nie posiada niezbędnych praw wobec rejestru.

Przykłady

Poniższy przykład kodu tworzy klucz testowy z wartością i pobiera ją. Następnie przykład próbuje pobrać nieistnieną wartość z klucza; w tym przypadku GetValue metoda zwraca określoną wartość domyślną.

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

Uwagi

Użyj tego przeciążenia GetValue , aby obsłużyć przypadek, w którym nazwa jeszcze nie istnieje — na przykład przy pierwszym uruchomieniu aplikacji. Za każdym razem, gdy wywołasz to przeciążenie, użyj parametru defaultValue , aby określić wartość, która ma być zwracana, jeśli name nie istnieje.

Uwaga

GetValue Gdy metoda pobiera rozszerzalne wartości ciągów (RegistryValueKind.ExpandString), rozszerza ciągi środowiska przy użyciu danych ze środowiska lokalnego. Aby pobrać rozszerzalne wartości ciągów z rejestru na komputerze zdalnym, użyj GetValue przeciążenia, aby określić, że ciągi środowiskowe nie mają być rozwinięte.

Uwaga

Jeśli wartość zawierająca odwołania rozszerzalne do zmiennych środowiskowych została zapisana jako ciąg (RegistryValueKind.String), a nie jako ciąg rozszerzalny (RegistryValueKind.ExpandString), GetValue metoda nie rozwija go. Możesz rozwinąć taki ciąg po jego pobraniu, wywołując metodę ExpandEnvironmentVariables .

Uwaga

Zalecanym sposobem pobierania danych z PerformanceData klucza jest użycie PerformanceCounter klasy, a nie RegistryKey.GetValue metody.

GetValue nie obsługuje odczytywania wartości typu REG_NONE lub REG_LINK. W obu przypadkach wartość domyślna (null) jest zwracana zamiast rzeczywistej wartości.

Zobacz też

Dotyczy

Udostępnij za pośrednictwem

RegistryKey.GetValue Metoda

Definicja

Przeciążenia

GetValue(String, Object, RegistryValueOptions)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

GetValue(String)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

GetValue(String, Object)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Dodatkowe zasoby