RegistryKey.GetValue Metoda

Reference

Definice

Obor názvů:: Microsoft.Win32

Sestavení:: Microsoft.Win32.Registry.dll

Sestavení:: mscorlib.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Načítá hodnotu přidruženou k zadanému názvu.

Přetížení

GetValue(String, Object, RegistryValueOptions)	Načte hodnotu přidruženou k zadanému názvu a možnostem načtení. Pokud se název nenajde, vrátí výchozí hodnotu, kterou zadáte.
GetValue(String)	Načítá hodnotu přidruženou k zadanému názvu. Vrátí hodnotu `null` , pokud dvojice název/hodnota v registru neexistuje.
GetValue(String, Object)	Načítá hodnotu přidruženou k zadanému názvu. Pokud se název nenajde, vrátí výchozí hodnotu, kterou zadáte.

GetValue(String, Object, RegistryValueOptions)

Zdroj:: RegistryKey.cs

Načte hodnotu přidruženou k zadanému názvu a možnostem načtení. Pokud se název nenajde, vrátí výchozí hodnotu, kterou zadáte.

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

Název hodnoty, která se má načíst. Tento řetězec neodlišuje velká a malá písmena.

defaultValue: Object

Hodnota, která se má vrátit, pokud name neexistuje.

options: RegistryValueOptions

Jedna z hodnot výčtu, která určuje volitelné zpracování načtené hodnoty.

Návraty

Object

Hodnota přidružená k name, zpracována podle zadané optionshodnoty nebo defaultValue pokud name nebyla nalezena.

Atributy: ComVisibleAttribute

Výjimky

SecurityException

Uživatel nemá oprávnění potřebné ke čtení z klíče registru.

ObjectDisposedException

Objekt RegistryKey , který obsahuje zadanou hodnotu, je uzavřen (uzavřené klíče nelze získat přístup).

IOException

Objekt RegistryKey , který obsahuje zadanou hodnotu, byl označen k odstranění.

ArgumentException

options není platná RegistryValueOptions hodnota, například se neplatná hodnota přetypuje na RegistryValueOptions.

UnauthorizedAccessException

Uživatel nemá nezbytná oprávnění pro registr.

Příklady

Následující ukázka kódu vytvoří testovací klíč, přidá hodnotu s vloženou proměnnou prostředí a načte hodnotu v rozšířené i nerozbalené podobě.

#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

Poznámky

Toto přetížení slouží k určení speciálního zpracování načtené hodnoty. Můžete například zadat RegistryValueOptions.DoNotExpandEnvironmentNames při načítání hodnoty registru typu RegistryValueKind.ExpandString k načtení řetězce bez rozbalení vložených proměnných prostředí.

Pomocí parametru defaultValue zadejte hodnotu, která se má vrátit, pokud name neexistuje.

Poznámka

Klíč registru může mít jednu hodnotu, která není spojena s názvem. Pokud se tato nepojmenovaná hodnota zobrazuje v editoru registru, zobrazuje se místo názvu řetězec "(výchozí)". Pokud chcete načíst tuto nepojmenovanou hodnotu, zadejte null prázdný řetězec nebo ("") pro name.

GetValue nepodporuje čtení hodnot typu REG_NONE nebo REG_LINK. V obou případech se místo skutečné hodnoty vrátí výchozí hodnota (null).

Viz také

Platí pro

GetValue(String)

Zdroj:: RegistryKey.cs

Načítá hodnotu přidruženou k zadanému názvu. Vrátí hodnotu null , pokud dvojice název/hodnota v registru neexistuje.

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

Název hodnoty, která se má načíst. Tento řetězec neodlišuje velká a malá písmena.

Návraty

Object

Hodnota přidružená k namenebo null , pokud name nebyla nalezena.

Výjimky

SecurityException

Uživatel nemá oprávnění potřebné ke čtení z klíče registru.

ObjectDisposedException

Objekt RegistryKey , který obsahuje zadanou hodnotu, je uzavřen (uzavřené klíče nelze získat přístup).

IOException

Objekt RegistryKey , který obsahuje zadanou hodnotu, byl označen k odstranění.

UnauthorizedAccessException

Uživatel nemá nezbytná oprávnění pro registr.

Příklady

Následující příklad kódu vytvoří testovací klíč a přidá do klíče hodnoty různých datových typů. Příklad pak přečte páry název/hodnota a zobrazí je v konzole pomocí GetValueKind metody k načtení odpovídajících datových typů registru.

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

Poznámky

Poznámka

GetValue Když metoda načte rozbalitelné řetězcové hodnoty (RegistryValueKind.ExpandString), rozšíří řetězce prostředí pomocí dat z místního prostředí. Chcete-li načíst rozbalitelné řetězcové hodnoty z registru ve vzdáleném počítači, pomocí GetValue(String, Object, RegistryValueOptions) přetížení metody určete, že nechcete rozbalit řetězce prostředí.

Poznámka

Pokud je hodnota obsahující rozbalitelné odkazy na proměnné prostředí uložena jako řetězec (RegistryValueKind.String), nikoli jako rozbalitelný řetězec (RegistryValueKind.ExpandString), GetValue nerozbalí ji. Takový řetězec můžete po načtení rozbalit voláním ExpandEnvironmentVariables metody .

Poznámka

Doporučeným způsobem, jak načíst data z PerformanceData klíče, je použít PerformanceCounter místo metody třídu RegistryKey.GetValue .

GetValue nepodporuje čtení hodnot typu REG_NONE nebo REG_LINK. V obou případech se místo skutečné hodnoty vrátí výchozí hodnota (null).

Viz také

Platí pro

GetValue(String, Object)

Zdroj:: RegistryKey.cs

Načítá hodnotu přidruženou k zadanému názvu. Pokud se název nenajde, vrátí výchozí hodnotu, kterou zadáte.

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

Název hodnoty, která se má načíst. Tento řetězec neodlišuje velká a malá písmena.

defaultValue: Object

Hodnota, která se má vrátit, pokud name neexistuje.

Návraty

Object

Hodnota přidružená k name, přičemž všechny vložené proměnné prostředí zůstaly nerozbalené nebo defaultValue pokud name se nenašly.

Výjimky

SecurityException

Uživatel nemá oprávnění potřebné ke čtení z klíče registru.

ObjectDisposedException

Objekt RegistryKey , který obsahuje zadanou hodnotu, je uzavřen (uzavřené klíče nelze získat přístup).

IOException

Objekt RegistryKey , který obsahuje zadanou hodnotu, byl označen k odstranění.

UnauthorizedAccessException

Uživatel nemá nezbytná oprávnění pro registr.

Příklady

Následující příklad kódu vytvoří testovací klíč s hodnotou a načte ji. Příklad se pak pokusí načíst neexistující hodnotu z klíče; v tomto případě GetValue metoda vrátí zadanou výchozí hodnotu.

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

Poznámky

Toto přetížení GetValue použijte k řešení případu, kdy název ještě neexistuje – například při prvním spuštění aplikace. Při každém volání tohoto přetížení použijte defaultValue parametr k určení hodnoty, která se má vrátit, pokud name neexistuje.

Poznámka

GetValue Když metoda načte rozbalitelné řetězcové hodnoty (RegistryValueKind.ExpandString), rozšíří řetězce prostředí pomocí dat z místního prostředí. Chcete-li načíst rozbalitelné řetězcové hodnoty z registru ve vzdáleném počítači, použijte GetValue přetížení a určete, že nechcete rozbalovat řetězce prostředí.

Poznámka

Pokud je hodnota obsahující rozšiřitelné odkazy na proměnné prostředí uložena jako řetězec (RegistryValueKind.String), nikoli jako rozbalitelný řetězec (RegistryValueKind.ExpandString), GetValue metoda ji nerozbalí. Takový řetězec můžete po načtení rozbalit voláním ExpandEnvironmentVariables metody .

Poznámka

Doporučeným způsobem, jak načíst data z PerformanceData klíče, je použít PerformanceCounter místo metody třídu RegistryKey.GetValue .

GetValue nepodporuje čtení hodnot typu REG_NONE nebo REG_LINK. V obou případech se místo skutečné hodnoty vrátí výchozí hodnota (null).

Viz také

Platí pro

Sdílet prostřednictvím

RegistryKey.GetValue Metoda

Definice

Přetížení

GetValue(String, Object, RegistryValueOptions)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

GetValue(String)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

GetValue(String, Object)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

Váš názor

Další materiály