RegistryKey.GetValue Método

Referencia

Definición

Espacio de nombres:: Microsoft.Win32

Ensamblado:: Microsoft.Win32.Registry.dll

Ensamblado:: mscorlib.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Recupera el valor asociado al nombre especificado.

Sobrecargas

GetValue(String, Object, RegistryValueOptions)	Recupera el valor asociado al nombre y a las opciones de recuperación especificados. Si no se encuentra el nombre, devuelve el valor predeterminado que se proporcione.
GetValue(String)	Recupera el valor asociado al nombre especificado. Devuelve `null` si el par nombre-valor no existe en el Registro.
GetValue(String, Object)	Recupera el valor asociado al nombre especificado. Si no se encuentra el nombre, devuelve el valor predeterminado que se proporcione.

GetValue(String, Object, RegistryValueOptions)

Source:: RegistryKey.cs

Recupera el valor asociado al nombre y a las opciones de recuperación especificados. Si no se encuentra el nombre, devuelve el valor predeterminado que se proporcione.

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

Parámetros

name: String

Nombre del valor que se va a recuperar. Esta cadena no distingue entre mayúsculas y minúsculas.

defaultValue: Object

Valor que se devuelve si name no existe.

options: RegistryValueOptions

Uno de los valores de enumeración que especifica el procesamiento opcional del valor recuperado.

Devoluciones

Object

Valor asociado a name, que se procesa según el valor especificado para options, o defaultValue si no se encuentra name.

Atributos: ComVisibleAttribute

Excepciones

SecurityException

El usuario no tiene los permisos necesarios para leer en la clave del Registro.

ObjectDisposedException

El objeto RegistryKey que contiene el valor especificado está cerrado (no se puede tener acceso a claves cerradas).

IOException

El objeto RegistryKey que contiene el valor especificado se ha marcado para su eliminación.

ArgumentException

options no es un valor RegistryValueOptions válido; por ejemplo, un valor no válido se convierte a RegistryValueOptions.

UnauthorizedAccessException

El usuario no tiene los derechos necesarios en el Registro.

Ejemplos

En el ejemplo de código siguiente se crea una clave de prueba, se agrega un valor con una variable de entorno incrustada y se recupera el valor en formularios expandidos y no expandidos.

#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

Comentarios

Use esta sobrecarga para especificar el procesamiento especial del valor recuperado. Por ejemplo, puede especificar RegistryValueOptions.DoNotExpandEnvironmentNames al recuperar un valor del Registro de tipo RegistryValueKind.ExpandString para recuperar la cadena sin expandir las variables de entorno incrustadas.

Use el defaultValue parámetro para especificar el valor que se va a devolver si name no existe.

Nota

Una clave del Registro puede tener un valor que no esté asociado a ningún nombre. Cuando este valor sin nombre se muestra en el editor del Registro, aparece la cadena "(Default)" en lugar de un nombre. Para recuperar este valor sin nombre, especifique null o la cadena vacía ("") para name.

GetValue no admite la lectura de valores de tipo REG_NONE o REG_LINK. En ambos casos, se devuelve el valor predeterminado (null) en lugar del valor real.

Consulte también

Se aplica a

GetValue(String)

Source:: RegistryKey.cs

Recupera el valor asociado al nombre especificado. Devuelve null si el par nombre-valor no existe en el Registro.

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

Parámetros

name: String

Nombre del valor que se va a recuperar. Esta cadena no distingue entre mayúsculas y minúsculas.

Devoluciones

Object

Valor asociado a name, o null si no se encuentra name.

Excepciones

SecurityException

El usuario no tiene los permisos necesarios para leer en la clave del Registro.

ObjectDisposedException

El objeto RegistryKey que contiene el valor especificado está cerrado (no se puede tener acceso a claves cerradas).

IOException

El objeto RegistryKey que contiene el valor especificado se ha marcado para su eliminación.

UnauthorizedAccessException

El usuario no tiene los derechos necesarios en el Registro.

Ejemplos

En el ejemplo de código siguiente se crea una clave de prueba y se agregan valores de diferentes tipos de datos a la clave. A continuación, en el ejemplo se leen los pares nombre-valor y se muestran en la consola mediante el GetValueKind método para recuperar los tipos de datos del Registro correspondientes.

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

Comentarios

Nota

Cuando el GetValue método recupera valores de cadena expandibles (RegistryValueKind.ExpandString), expande cadenas de entorno mediante datos del entorno local. Para recuperar valores de cadena expandibles del Registro en un equipo remoto, use la sobrecarga del GetValue(String, Object, RegistryValueOptions) método para especificar que no desea expandir las cadenas de entorno.

Nota

Si un valor que contiene referencias expandibles a variables de entorno se ha almacenado como una cadena (RegistryValueKind.String), en lugar de como una cadena expandible (RegistryValueKind.ExpandString), GetValue no la expande. Puede expandir esta cadena después de que se haya recuperado llamando al ExpandEnvironmentVariables método .

Nota

La manera recomendada de recuperar datos de la PerformanceData clave es usar la PerformanceCounter clase en lugar del RegistryKey.GetValue método .

GetValue no admite la lectura de valores de tipo REG_NONE o REG_LINK. En ambos casos, se devuelve el valor predeterminado (null) en lugar del valor real.

Consulte también

Se aplica a

GetValue(String, Object)

Source:: RegistryKey.cs

Recupera el valor asociado al nombre especificado. Si no se encuentra el nombre, devuelve el valor predeterminado que se proporcione.

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

Parámetros

name: String

Nombre del valor que se va a recuperar. Esta cadena no distingue entre mayúsculas y minúsculas.

defaultValue: Object

Valor que se devuelve si name no existe.

Devoluciones

Object

Valor asociado a name, con las variables de entorno incrustadas sin expandir, o defaultValue si no se encuentra name.

Excepciones

SecurityException

El usuario no tiene los permisos necesarios para leer en la clave del Registro.

ObjectDisposedException

El objeto RegistryKey que contiene el valor especificado está cerrado (no se puede tener acceso a claves cerradas).

IOException

El objeto RegistryKey que contiene el valor especificado se ha marcado para su eliminación.

UnauthorizedAccessException

El usuario no tiene los derechos necesarios en el Registro.

Ejemplos

En el ejemplo de código siguiente se crea una clave de prueba con un valor y se recupera ese valor. A continuación, el ejemplo intenta recuperar un valor inexistente de la clave; en este caso, el GetValue método devuelve el valor predeterminado especificado.

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

Comentarios

Use esta sobrecarga de GetValue para controlar el caso en el que todavía no existe un nombre; por ejemplo, la primera vez que se ejecuta la aplicación. Siempre que llame a esta sobrecarga, use el defaultValue parámetro para especificar el valor que se va a devolver si name no existe.

Nota

Cuando el GetValue método recupera valores de cadena expandibles (RegistryValueKind.ExpandString), expande cadenas de entorno mediante datos del entorno local. Para recuperar valores de cadena expandibles del Registro en un equipo remoto, use la GetValue sobrecarga para especificar que no desea expandir las cadenas de entorno.

Nota

Si un valor que contiene referencias expandibles a variables de entorno se ha almacenado como una cadena (RegistryValueKind.String), en lugar de como una cadena expandible (RegistryValueKind.ExpandString), el GetValue método no lo expande. Puede expandir esta cadena después de que se haya recuperado llamando al ExpandEnvironmentVariables método .

Nota

La manera recomendada de recuperar datos de la PerformanceData clave es usar la PerformanceCounter clase en lugar del RegistryKey.GetValue método .

GetValue no admite la lectura de valores de tipo REG_NONE o REG_LINK. En ambos casos, se devuelve el valor predeterminado (null) en lugar del valor real.

Consulte también

Se aplica a

Compartir a través de

RegistryKey.GetValue Método

Definición

Sobrecargas

GetValue(String, Object, RegistryValueOptions)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

GetValue(String)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

GetValue(String, Object)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Recursos adicionales