RegistryKey.GetValue Yöntem

Başvuru

Tanım

Ad Alanı:: Microsoft.Win32

Bütünleştirilmiş Kod:: Microsoft.Win32.Registry.dll

Bütünleştirilmiş Kod:: mscorlib.dll

Paket:: Microsoft.Win32.Registry v5.0.0

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

Belirtilen adla ilişkili değeri alır.

Aşırı Yüklemeler

GetValue(String, Object, RegistryValueOptions)	Belirtilen ad ve alma seçenekleriyle ilişkili değeri alır. Ad bulunamazsa, sağladığınız varsayılan değeri döndürür.
GetValue(String)	Belirtilen adla ilişkili değeri alır. Kayıt defterinde ad/değer çifti yoksa `null` döndürür.
GetValue(String, Object)	Belirtilen adla ilişkili değeri alır. Ad bulunamazsa, sağladığınız varsayılan değeri döndürür.

GetValue(String, Object, RegistryValueOptions)

Kaynak:: RegistryKey.cs

Belirtilen ad ve alma seçenekleriyle ilişkili değeri alır. Ad bulunamazsa, sağladığınız varsayılan değeri döndürür.

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

Parametreler

name: String

Alınacak değerin adı. Bu dize büyük/küçük harfe duyarlı değildir.

defaultValue: Object

name yoksa döndürülecek değer.

options: RegistryValueOptions

Alınan değerin isteğe bağlı olarak işlenmesini belirten numaralandırma değerlerinden biri.

Döndürülenler

Object

belirtilen optionsgöre işlenen veya name bulunamazsa defaultValuenameile ilişkili değer.

Öznitelikler: ComVisibleAttribute

Özel durumlar

SecurityException

Kullanıcının kayıt defteri anahtarından okumak için gereken izinleri yok.

ObjectDisposedException

Belirtilen değeri içeren RegistryKey kapatılır (kapalı anahtarlara erişilemez).

IOException

Belirtilen değeri içeren RegistryKey silinmek üzere işaretlendi.

ArgumentException

options geçerli bir RegistryValueOptions değeri değildir; örneğin, geçersiz bir değer RegistryValueOptions'e yayınlanır.

UnauthorizedAccessException

Kullanıcı gerekli kayıt defteri haklarına sahip değil.

Örnekler

Aşağıdaki kod örneği bir test anahtarı oluşturur, katıştırılmış ortam değişkeniyle bir değer ekler ve hem genişletilmiş hem de genişletilmemiş formlardaki değeri alır.

#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

Açıklamalar

Alınan değerin özel işlenmesini belirtmek için bu aşırı yüklemeyi kullanın. Örneğin, eklenmiş ortam değişkenlerini genişletmeden dizeyi almak için RegistryValueKind.ExpandString türünde bir kayıt defteri değeri alırken RegistryValueOptions.DoNotExpandEnvironmentNames belirtebilirsiniz.

name yoksa döndürülecek değeri belirtmek için defaultValue parametresini kullanın.

Not

Kayıt defteri anahtarının herhangi bir adla ilişkilendirilmemiş bir değeri olabilir. Bu adsız değer kayıt defteri düzenleyicisinde görüntülendiğinde, ad yerine "(Varsayılan)" dizesi görüntülenir. Bu adlandırılmamış değeri almak için nameiçin null veya boş dizeyi ("") belirtin.

GetValue, REG_NONE veya REG_LINK türü okuma değerlerini desteklemez. Her iki durumda da, gerçek değer yerine varsayılan değer (null) döndürülür.

Ayrıca bkz.

Şunlara uygulanır

GetValue(String)

Kaynak:: RegistryKey.cs

Belirtilen adla ilişkili değeri alır. Kayıt defterinde ad/değer çifti yoksa null döndürür.

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

Parametreler

name: String

Alınacak değerin adı. Bu dize büyük/küçük harfe duyarlı değildir.

Döndürülenler

Object

nameveya name bulunamazsa null ile ilişkili değer.

Özel durumlar

SecurityException

Kullanıcının kayıt defteri anahtarından okumak için gereken izinleri yok.

ObjectDisposedException

Belirtilen değeri içeren RegistryKey kapatılır (kapalı anahtarlara erişilemez).

IOException

Belirtilen değeri içeren RegistryKey silinmek üzere işaretlendi.

UnauthorizedAccessException

Kullanıcı gerekli kayıt defteri haklarına sahip değil.

Örnekler

Aşağıdaki kod örneği bir test anahtarı oluşturur ve anahtara farklı veri türlerinin değerlerini ekler. Örnek daha sonra ad/değer çiftlerini okur ve karşılık gelen kayıt defteri veri türlerini almak için GetValueKind yöntemini kullanarak bunları konsolda görüntüler.

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

Açıklamalar

Not

GetValue yöntemi genişletilebilir dize değerlerini (RegistryValueKind.ExpandString) aldığında, yerel ortamdaki verileri kullanarak ortam dizelerini genişletir. Uzak bilgisayardaki kayıt defterinden genişletilebilir dize değerlerini almak için GetValue(String, Object, RegistryValueOptions) yöntemi aşırı yüklemesini kullanarak ortam dizelerinin genişletılmasını istemediğinizi belirtin.

Not

Ortam değişkenlerine genişletilebilir başvurular içeren bir değer, genişletilebilir bir dize (RegistryValueKind.ExpandString) yerine bir dize (RegistryValueKind.String) olarak depolanmışsa GetValue bunu genişletmez. Bu tür bir dize alındıktan sonra ExpandEnvironmentVariables yöntemini çağırarak genişletebilirsiniz.

Not

PerformanceData anahtarından veri almak için önerilen yol, RegistryKey.GetValue yöntemi yerine PerformanceCounter sınıfını kullanmaktır.

GetValue, REG_NONE veya REG_LINK türü okuma değerlerini desteklemez. Her iki durumda da, gerçek değer yerine varsayılan değer (null) döndürülür.

Ayrıca bkz.

Şunlara uygulanır

GetValue(String, Object)

Kaynak:: RegistryKey.cs

Belirtilen adla ilişkili değeri alır. Ad bulunamazsa, sağladığınız varsayılan değeri döndürür.

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

Parametreler

name: String

Alınacak değerin adı. Bu dize büyük/küçük harfe duyarlı değildir.

defaultValue: Object

name yoksa döndürülecek değer.

Döndürülenler

Object

nameile ilişkili değer, eklenmiş ortam değişkenleriyle birlikte süresiz bırakılır veya name bulunamazsa defaultValue.

Özel durumlar

SecurityException

Kullanıcının kayıt defteri anahtarından okumak için gereken izinleri yok.

ObjectDisposedException

Belirtilen değeri içeren RegistryKey kapatılır (kapalı anahtarlara erişilemez).

IOException

Belirtilen değeri içeren RegistryKey silinmek üzere işaretlendi.

UnauthorizedAccessException

Kullanıcı gerekli kayıt defteri haklarına sahip değil.

Örnekler

Aşağıdaki kod örneği, değeri olan bir test anahtarı oluşturur ve bu değeri alır. Örnek daha sonra anahtardan var olmayan bir değeri almayı dener; bu durumda GetValue yöntemi belirtilen varsayılan değeri döndürür.

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

Açıklamalar

Bu GetValue aşırı yüklemesini kullanarak bir adın henüz mevcut olmadığı durumu işleyin ( örneğin, uygulamanız ilk kez çalıştırıldığında). Bu aşırı yüklemeyi her çağırdığınızda, name yoksa döndürülecek değeri belirtmek için defaultValue parametresini kullanın.

Not

GetValue yöntemi genişletilebilir dize değerlerini (RegistryValueKind.ExpandString) aldığında, yerel ortamdaki verileri kullanarak ortam dizelerini genişletir. Uzak bilgisayardaki kayıt defterinden genişletilebilir dize değerlerini almak için GetValue aşırı yüklemesini kullanarak ortam dizelerinin genişletılmasını istemediğinizi belirtin.

Not

Ortam değişkenlerine genişletilebilir başvurular içeren bir değer, genişletilebilir bir dize (RegistryValueKind.ExpandString) olarak değil dize (RegistryValueKind.String) olarak depolanmışsa, GetValue yöntemi bunu genişletmez. Bu tür bir dize alındıktan sonra ExpandEnvironmentVariables yöntemini çağırarak genişletebilirsiniz.

Not

PerformanceData anahtarından veri almak için önerilen yol, RegistryKey.GetValue yöntemi yerine PerformanceCounter sınıfını kullanmaktır.

GetValue, REG_NONE veya REG_LINK türü okuma değerlerini desteklemez. Her iki durumda da, gerçek değer yerine varsayılan değer (null) döndürülür.

Ayrıca bkz.

Şunlara uygulanır

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Aracılığıyla paylaş

RegistryKey.GetValue Yöntem

Tanım

Aşırı Yüklemeler

GetValue(String, Object, RegistryValueOptions)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

GetValue(String)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

GetValue(String, Object)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

Geri Bildirim