RegistryKey.SetValue Método
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í.
Establece el valor de un par de nombre y valor de la clave del Registro. En función de la sobrecarga, el tipo de datos del Registro se determina a partir del tipo de datos que se almacena o a partir de un RegistryValueKind especificado.
| SetValue(String, Object) |
Establece el par de nombre y valor especificado. |
| SetValue(String, Object, RegistryValueKind) |
Establece el valor de un par de nombre y valor de la clave del Registro, utilizando el tipo de datos del Registro especificado. |
- Source:
- RegistryKey.cs
Establece el par de nombre y valor especificado.
public:
void SetValue(System::String ^ name, System::Object ^ value);public void SetValue (string name, object value);public void SetValue (string? name, object value);member this.SetValue : string * obj -> unitPublic Sub SetValue (name As String, value As Object)Parámetros
- name
- String
Nombre del valor que se va a almacenar.
- value
- Object
Datos que se van a almacenar.
Excepciones
value es null.
value es un tipo de datos no admitido.
El objeto RegistryKey que contiene el valor especificado está cerrado (no se puede tener acceso a claves cerradas).
El objeto RegistryKey es de sólo lectura y no se puede escribir en él; por ejemplo, la clave no se ha abierto con acceso de escritura.
El usuario no tiene los permisos necesarios para crear o modificar claves del Registro.
El objeto RegistryKey representa un nodo de nivel de raíz y el sistema operativo es Windows 2000, Windows XP o Windows Server 2003.
Ejemplos
En el ejemplo de código siguiente se muestra cómo el SetValue método determina el tipo de datos del Registro cuando establece valores. En el ejemplo se crea una clave de prueba y se agregan valores de distintos tipos de datos a la clave. A continuación, en el ejemplo se leen los pares nombre-valor y se muestran en la consola, utilizando el GetValueKind método para mostrar 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( "RegistrySetValueExample", false );
RegistryKey ^ rk = Registry::CurrentUser->CreateSubKey( "RegistrySetValueExample" );
// Create name/value pairs.
// Numeric values that cannot be interpreted as DWord (int) values
// are stored as strings.
rk->SetValue( "LargeNumberValue1", (long)42 );
rk->SetValue( "LargeNumberValue2", 42000000000 );
rk->SetValue( "DWordValue", 42 );
array<String^>^temp0 = {"One","Two","Three"};
rk->SetValue( "MultipleStringValue", temp0 );
array<Byte>^temp1 = {10,43,44,45,14,255};
rk->SetValue( "BinaryValue", temp1 );
// This overload of SetValue does not support expanding strings. Use
// the overload that allows you to specify RegistryValueKind.
rk->SetValue( "StringValue", "The path is %PATH%" );
// 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}) = \"{2}\"", s, rvk, values[ 0 ] );
for ( int i = 1; i < values->Length; i++ )
{
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}) = {2:X2}", s, rvk, bytes[ 0 ] );
for ( int i = 1; 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;
}
}
}
using System;
using Microsoft.Win32;
public class Example
{
public static void Main()
{
// Delete and recreate the test key.
Registry.CurrentUser.DeleteSubKey("RegistrySetValueExample", false);
RegistryKey rk = Registry.CurrentUser.CreateSubKey("RegistrySetValueExample");
// Create name/value pairs.
// Numeric values that cannot be interpreted as DWord (int) values
// are stored as strings.
rk.SetValue("LargeNumberValue1", (long) 42);
rk.SetValue("LargeNumberValue2", 42000000000);
rk.SetValue("DWordValue", 42);
rk.SetValue("MultipleStringValue", new string[] {"One", "Two", "Three"});
rk.SetValue("BinaryValue", new byte[] {10, 43, 44, 45, 14, 255});
// This overload of SetValue does not support expanding strings. Use
// the overload that allows you to specify RegistryValueKind.
rk.SetValue("StringValue", "The path is %PATH%");
// 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}) = \"{2}\"", s, rvk, values[0]);
for (int i = 1; i < values.Length; i++)
{
Console.Write(", \"{0}\"", values[i]);
}
Console.WriteLine();
break;
case RegistryValueKind.Binary :
byte[] bytes = (byte[]) rk.GetValue(s);
Console.Write("\r\n {0} ({1}) = {2:X2}", s, rvk, bytes[0]);
for (int i = 1; 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;
}
}
}
}
Imports Microsoft.Win32
Public Class Example
Public Shared Sub Main()
' Delete and recreate the test key.
Registry.CurrentUser.DeleteSubKey("RegistrySetValueExample", False)
Dim rk As RegistryKey = Registry.CurrentUser.CreateSubKey("RegistrySetValueExample")
' Create name/value pairs.
' Numeric values that cannot be interpreted as DWord (int) values
' are stored as strings.
rk.SetValue("LargeNumberValue1", CType(42, Long))
rk.SetValue("LargeNumberValue2", 42000000000)
rk.SetValue("DWordValue", 42)
rk.SetValue("MultipleStringValue", New String() {"One", "Two", "Three"})
rk.SetValue("BinaryValue", New Byte() {10, 43, 44, 45, 14, 255})
' This overload of SetValue does not support expanding strings. Use
' the overload that allows you to specify RegistryValueKind.
rk.SetValue("StringValue", "The path is %PATH%")
' 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}) = ""{2}""", s, rvk, values(0))
Dim i As Integer
For i = 1 To values.Length - 1
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}) = {2:X2}", s, rvk, bytes(0))
Dim i As Integer
For i = 1 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
Comentarios
Dado que muchos valores se pueden almacenar en cada clave del Registro, debe usar el name parámetro para especificar el valor determinado que desea establecer.
Nota
Una clave del Registro puede tener un valor que no esté asociado a ningún nombre. Cuando se muestra este valor sin nombre en el editor del Registro, aparece la cadena "(Default)" en lugar de un nombre. Para establecer este valor sin nombre, especifique null o la cadena vacía ("") para name.
Para establecer valores en una clave, debe abrir la clave con acceso de escritura. Después de abrir una clave con acceso de escritura, puede cambiar cualquiera de los pares nombre-valor de esa clave.
Si el especificado name no existe en la clave, se crea y el valor asociado se establece valueen .
Esta sobrecarga de almacena enteros de SetValue 64 bits como cadenas (RegistryValueKind.String). Para almacenar números de 64 bits como RegistryValueKind.QWord valores, use la SetValue(String, Object, RegistryValueKind) sobrecarga que especifica RegistryValueKind.
Esta sobrecarga de almacena todos los valores de SetValue cadena como RegistryValueKind.String, incluso si contienen referencias expandibles a variables de entorno. Para guardar los valores de cadena como cadenas expandibles (RegistryValueKind.ExpandString), use la SetValue(String, Object, RegistryValueKind) sobrecarga que especifica RegistryValueKind.
Los tipos numéricos distintos de enteros de 32 bits se almacenan como cadenas mediante esta sobrecarga de método. Los elementos de enumeración se almacenan como cadenas que contienen los nombres de elemento.
Precaución
No exponga RegistryKey objetos de tal manera que un programa malintencionado pueda crear miles de subclaves sin significado ni pares clave-valor. Por ejemplo, no permita que los autores de llamadas escriban claves o valores arbitrarios.
Consulte también
Se aplica a
.NET 9 otras versiones
| Producto | Versiones |
|---|---|
| .NET | Core 1.0, Core 1.1, 6, 7, 8, 9 |
| .NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
| Windows Desktop | 3.0, 3.1, 5 |
- Source:
- RegistryKey.cs
Establece el valor de un par de nombre y valor de la clave del Registro, utilizando el tipo de datos del Registro especificado.
public:
void SetValue(System::String ^ name, System::Object ^ value, Microsoft::Win32::RegistryValueKind valueKind);public void SetValue (string name, object value, Microsoft.Win32.RegistryValueKind valueKind);public void SetValue (string? name, object value, Microsoft.Win32.RegistryValueKind valueKind);[System.Runtime.InteropServices.ComVisible(false)]
public void SetValue (string name, object value, Microsoft.Win32.RegistryValueKind valueKind);member this.SetValue : string * obj * Microsoft.Win32.RegistryValueKind -> unit[<System.Runtime.InteropServices.ComVisible(false)>]
member this.SetValue : string * obj * Microsoft.Win32.RegistryValueKind -> unitPublic Sub SetValue (name As String, value As Object, valueKind As RegistryValueKind)Parámetros
- name
- String
Nombre del valor que se va a almacenar.
- value
- Object
Datos que se van a almacenar.
- valueKind
- RegistryValueKind
Tipo de datos del Registro que se utilizará para almacenar los datos.
- Atributos
Excepciones
value es null.
El tipo de value no coincidió con el tipo de datos del Registro especificado por valueKind; por consiguiente, no se pudieron convertir los datos correctamente.
El objeto RegistryKey que contiene el valor especificado está cerrado (no se puede tener acceso a claves cerradas).
El objeto RegistryKey es de sólo lectura y no se puede escribir en él; por ejemplo, la clave no se ha abierto con acceso de escritura.
El usuario no tiene los permisos necesarios para crear o modificar claves del Registro.
El objeto RegistryKey representa un nodo de nivel de raíz y el sistema operativo es Windows 2000, Windows XP o Windows Server 2003.
Ejemplos
En el ejemplo de código siguiente se crea una clave de prueba y se usa el SetValue método para almacenar varios valores, especificando el tipo de datos del Registro para cada valor. A continuación, en el ejemplo se leen los pares nombre-valor y se muestran en la consola, utilizando el GetValueKind método para mostrar 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
Dado que muchos valores se pueden almacenar en cada clave del Registro, debe usar el name parámetro para especificar el valor determinado que desea establecer.
Nota
Una clave del Registro puede tener un valor que no esté asociado a ningún nombre. Cuando se muestra este valor sin nombre en el editor del Registro, aparece la cadena "(Default)" en lugar de un nombre. Para establecer este valor sin nombre, especifique null o la cadena vacía ("") para name.
Para establecer valores en una clave, debe abrir la clave con acceso de escritura. Después de abrir una clave con acceso de escritura, puede cambiar cualquiera de los pares nombre-valor de esa clave.
Si el especificado name no existe en la clave, se crea y el valor asociado se establece valueen .
Nota
Especificar el tipo Unknown de datos del Registro es el mismo que el uso de la SetValue sobrecarga.
Si el tipo de especificado value no coincide con el especificado valueKindy los datos no se pueden convertir, ArgumentException se produce . Por ejemplo, puede almacenar como System.Int64 , RegistryValueKind.DWordpero solo si su valor es menor que el valor máximo de .System.Int32 No se puede almacenar un valor de cadena único como .RegistryValueKind.MultiString
Nota
Si se pasan valores con conversión boxed para RegistryValueKind.DWord o RegistryValueKind.QWord, la conversión se realiza mediante la referencia cultural invariable.
Precaución
No exponga RegistryKey objetos de tal manera que un programa malintencionado pueda crear miles de subclaves sin significado ni pares clave-valor. Por ejemplo, no permita que los autores de llamadas escriban claves o valores arbitrarios.
Consulte también
Se aplica a
.NET 9 otras versiones
| Producto | Versiones |
|---|---|
| .NET | Core 1.0, Core 1.1, 6, 7, 8, 9 |
| .NET Framework | 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
| Windows Desktop | 3.0, 3.1, 5 |
Comentarios de .NET
.NET es un proyecto de código abierto. Selecciona un vínculo para proporcionar comentarios: