Condividi tramite


RegistryKey.GetValue Metodo

Definizione

Recupera il valore associato al nome specificato.

Overload

GetValue(String, Object, RegistryValueOptions)

Recupera il valore associato al nome specificato e le opzioni di recupero. Se il nome non viene trovato, restituisce il valore predefinito fornito dall'utente.

GetValue(String)

Recupera il valore associato al nome specificato. Restituisce null se la coppia nome/valore non esiste nel Registro di sistema.

GetValue(String, Object)

Recupera il valore associato al nome specificato. Se il nome non viene trovato, restituisce il valore predefinito fornito dall'utente.

GetValue(String, Object, RegistryValueOptions)

Source:
RegistryKey.cs

Recupera il valore associato al nome specificato e le opzioni di recupero. Se il nome non viene trovato, restituisce il valore predefinito fornito dall'utente.

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

Parametri

name
String

Nome del valore da recuperare. Stringa senza distinzione tra maiuscole e minuscole.

defaultValue
Object

Valore da restituire se name non esiste.

options
RegistryValueOptions

Uno dei valori di enumerazione che specifica l'elaborazione facoltativa del valore recuperato.

Restituisce

Valore associato a name, elaborato in base alle options specificate, oppure defaultValue se name non viene trovato.

Attributi

Eccezioni

L'utente non dispone dell'autorizzazione richiesta per la lettura dalla chiave del Registro di sistema.

La chiave RegistryKey contenente il valore specificato è chiusa, pertanto non è possibile accedere ad essa.

L'oggetto RegistryKey che contiene il valore specificato è stato contrassegnato per l'eliminazione.

options non è un valore RegistryValueOptions valido; ad esempio viene eseguito il cast di un valore non valido sull'oggetto RegistryValueOptions.

L'utente non dispone dei necessari diritti relativi al Registro di sistema.

Esempio

L'esempio di codice seguente crea una chiave di test, aggiunge un valore con una variabile di ambiente incorporata e recupera il valore in moduli espansi e non estesi.

#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

Commenti

Usare questo overload per specificare un'elaborazione speciale del valore recuperato. Ad esempio, è possibile specificare RegistryValueOptions.DoNotExpandEnvironmentNames quando si recupera un valore del Registro di sistema di tipo RegistryValueKind.ExpandString per recuperare la stringa senza espandere le variabili di ambiente incorporate.

Utilizzare il parametro per specificare il defaultValue valore da restituire se name non esiste.

Nota

Una chiave del Registro di sistema può avere un valore che non è associato a alcun nome. Quando questo valore senza nome viene visualizzato nell'editor del Registro di sistema, la stringa "(Default)" viene visualizzata anziché un nome. Per recuperare questo valore senza nome, specificare null o la stringa vuota ("") per name.

GetValue non supporta la lettura dei valori di tipo REG_NONE o REG_LINK. In entrambi i casi, il valore predefinito (null) viene restituito anziché il valore effettivo.

Vedi anche

Si applica a

GetValue(String)

Source:
RegistryKey.cs

Recupera il valore associato al nome specificato. Restituisce null se la coppia nome/valore non esiste nel Registro di sistema.

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

Parametri

name
String

Nome del valore da recuperare. Stringa senza distinzione tra maiuscole e minuscole.

Restituisce

Valore associato a name oppure null se name non viene trovato.

Eccezioni

L'utente non dispone dell'autorizzazione richiesta per la lettura dalla chiave del Registro di sistema.

La chiave RegistryKey contenente il valore specificato è chiusa, pertanto non è possibile accedere ad essa.

L'oggetto RegistryKey che contiene il valore specificato è stato contrassegnato per l'eliminazione.

L'utente non dispone dei necessari diritti relativi al Registro di sistema.

Esempio

Nell'esempio di codice seguente viene creata una chiave di test e vengono aggiunti valori di tipi di dati diversi alla chiave. L'esempio legge quindi le coppie nome/valore e le visualizza nella console usando il GetValueKind metodo per recuperare i tipi di dati del Registro di sistema corrispondenti.

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

Commenti

Nota

Una chiave del Registro di sistema può avere un valore che non è associato a alcun nome. Quando questo valore senza nome viene visualizzato nell'editor del Registro di sistema, la stringa "(Default)" viene visualizzata anziché un nome. Per recuperare questo valore senza nome, specificare null o la stringa vuota ("") per name.

Quando il GetValue metodo recupera valori stringa espandibili (RegistryValueKind.ExpandString), espande le stringhe di ambiente usando i dati dall'ambiente locale. Per recuperare i valori stringa espandibili dal Registro di sistema in un computer remoto, usare l'overload del GetValue(String, Object, RegistryValueOptions) metodo per specificare che non si vogliono espandere stringhe di ambiente.

Nota

Se un valore contenente riferimenti espandibili alle variabili di ambiente è stato archiviato come stringa (), anziché come stringa espandibile (RegistryValueKind.StringRegistryValueKind.ExpandString), GetValue non lo espande. È possibile espandere tale stringa dopo che è stata recuperata chiamando il ExpandEnvironmentVariables metodo .

Nota

Il modo consigliato per recuperare i dati dalla chiave consiste nell'usare PerformanceData la PerformanceCounter classe anziché il RegistryKey.GetValue metodo .

GetValue non supporta la lettura dei valori di tipo REG_NONE o REG_LINK. In entrambi i casi, il valore predefinito (null) viene restituito anziché il valore effettivo.

Vedi anche

Si applica a

GetValue(String, Object)

Source:
RegistryKey.cs

Recupera il valore associato al nome specificato. Se il nome non viene trovato, restituisce il valore predefinito fornito dall'utente.

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

Parametri

name
String

Nome del valore da recuperare. Stringa senza distinzione tra maiuscole e minuscole.

defaultValue
Object

Valore da restituire se name non esiste.

Restituisce

Valore associato a name, con le eventuali variabili di ambiente incorporate non espanse oppure defaultValue se name non viene trovato.

Eccezioni

L'utente non dispone dell'autorizzazione richiesta per la lettura dalla chiave del Registro di sistema.

La chiave RegistryKey contenente il valore specificato è chiusa, pertanto non è possibile accedere ad essa.

L'oggetto RegistryKey che contiene il valore specificato è stato contrassegnato per l'eliminazione.

L'utente non dispone dei necessari diritti relativi al Registro di sistema.

Esempio

L'esempio di codice seguente crea una chiave di test con un valore e recupera tale valore. L'esempio tenta quindi di recuperare un valore non esistente dalla chiave; in questo caso il metodo restituisce il GetValue valore predefinito specificato.

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

Commenti

Usare questo overload di GetValue per gestire il caso in cui un nome non esiste ancora, ad esempio la prima volta che viene eseguita l'applicazione. Ogni volta che si chiama questo overload, usare il parametro per specificare il defaultValue valore da restituire se name non esiste.

Nota

Una chiave del Registro di sistema può avere un valore che non è associato a alcun nome. Quando questo valore senza nome viene visualizzato nell'editor del Registro di sistema, la stringa "(Default)" viene visualizzata anziché un nome. Per recuperare questo valore senza nome, specificare null o la stringa vuota ("") per name.

Quando il GetValue metodo recupera valori stringa espandibili (RegistryValueKind.ExpandString), espande le stringhe di ambiente usando i dati dall'ambiente locale. Per recuperare i valori stringa espandibili dal Registro di sistema in un computer remoto, usare l'overload GetValue per specificare che non si vogliono espandere stringhe di ambiente.

Nota

Se un valore contenente riferimenti espandibili alle variabili di ambiente è stato archiviato come stringa (), anziché come stringa espandibile (RegistryValueKind.StringRegistryValueKind.ExpandString), il GetValue metodo non lo espande. È possibile espandere tale stringa dopo che è stata recuperata chiamando il ExpandEnvironmentVariables metodo .

Nota

Il modo consigliato per recuperare i dati dalla chiave consiste nell'usare PerformanceData la PerformanceCounter classe anziché il RegistryKey.GetValue metodo .

GetValue non supporta la lettura dei valori di tipo REG_NONE o REG_LINK. In entrambi i casi, il valore predefinito (null) viene restituito anziché il valore effettivo.

Vedi anche

Si applica a