RegistryKey.SetValue Método
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Define o valor de um par nome-valor na chave do Registro. Dependendo da sobrecarga, o tipo de dados do Registro é determinado com base no tipo dos dados sendo armazenados ou com base em um RegistryValueKind especificado.
Sobrecargas
| SetValue(String, Object) |
Define o par nome-valor especificado. |
| SetValue(String, Object, RegistryValueKind) |
Define o valor de um par nome-valor na chave do Registro, usando o tipo de dados do Registro especificado. |
SetValue(String, Object)
- Origem:
- RegistryKey.cs
Define o par nome-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
O nome do valor a ser armazenado.
- value
- Object
Os dados a serem armazenados.
Exceções
value é null.
O value é um tipo de dados sem suporte.
O RegistryKey que contém o valor especificado é fechado (chaves fechadas não podem ser acessadas).
O RegistryKey é somente leitura e não pode ser usado para gravação, por exemplo, a chave não foi aberta com acesso de gravação.
O usuário não tem as permissões necessárias para criar ou modificar chaves do Registro.
O objeto RegistryKey representa um nó de nível raiz e o sistema operacional é o Windows 2000, Windows XP ou Windows Server 2003.
Exemplos
O exemplo de código a seguir mostra como o SetValue método determina o tipo de dados do Registro quando define valores. O exemplo cria uma chave de teste e adiciona valores de diferentes tipos de dados à chave. Em seguida, o exemplo lê os pares nome/valor e os exibe no console, usando o GetValueKind método para exibir os tipos de dados do Registro correspondentes.
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
Comentários
Como muitos valores podem ser armazenados em cada chave no Registro, você deve usar o name parâmetro para especificar o valor específico que deseja definir.
Observação
Uma chave do Registro pode ter um valor que não está associado a nenhum nome. Quando esse valor sem nome é exibido no Editor do Registro, a cadeia de caracteres "(Default)" é exibida em vez de um nome. Para definir esse valor sem nome, especifique ou null a cadeia de caracteres vazia ("") para name.
Para definir valores em uma chave, você deve abrir a chave com acesso de gravação. Depois de abrir uma chave com acesso de gravação, você pode alterar qualquer um dos pares nome/valor nessa chave.
Se o especificado name não existir na chave, ele será criado e o valor associado será definido valuecomo .
Essa sobrecarga de SetValue armazena inteiros de 64 bits como cadeias de caracteres (RegistryValueKind.String). Para armazenar números de 64 bits como RegistryValueKind.QWord valores, use a SetValue(String, Object, RegistryValueKind) sobrecarga que especifica RegistryValueKind.
Essa sobrecarga de armazena todos os valores de SetValue cadeia de caracteres como RegistryValueKind.String, mesmo que contenham referências expansíveis a variáveis de ambiente. Para salvar valores de cadeia de caracteres como cadeias de caracteres expansíveis (RegistryValueKind.ExpandString), use a SetValue(String, Object, RegistryValueKind) sobrecarga que especifica RegistryValueKind.
Tipos numéricos diferentes de inteiros de 32 bits são armazenados como cadeias de caracteres por essa sobrecarga de método. Os elementos de enumeração são armazenados como cadeias de caracteres que contêm os nomes dos elementos.
Cuidado
Não exponha objetos RegistryKey de maneira que um programa mal-intencionado possa criar milhares de subchaves sem sentido ou os pares de chave/valor. Por exemplo, não permita que chamadores insiram chaves ou valores arbitrários.
Confira também
Aplica-se a
SetValue(String, Object, RegistryValueKind)
- Origem:
- RegistryKey.cs
Define o valor de um par nome-valor na chave do Registro, usando o tipo de dados do 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
O nome do valor a ser armazenado.
- value
- Object
Os dados a serem armazenados.
- valueKind
- RegistryValueKind
O tipo de dados do Registro a ser usado ao armazenar os dados.
- Atributos
Exceções
value é null.
O tipo de value não correspondia ao tipo de dados do Registro especificado pelo valueKind e, portanto, não foi possível converter os dados corretamente.
O RegistryKey que contém o valor especificado é fechado (chaves fechadas não podem ser acessadas).
O RegistryKey é somente leitura e não pode ser usado para gravação, por exemplo, a chave não foi aberta com acesso de gravação.
O usuário não tem as permissões necessárias para criar ou modificar chaves do Registro.
O objeto RegistryKey representa um nó de nível raiz e o sistema operacional é o Windows 2000, Windows XP ou Windows Server 2003.
Exemplos
O exemplo de código a seguir cria uma chave de teste e usa o SetValue método para armazenar vários valores, especificando o tipo de dados do Registro para cada valor. Em seguida, o exemplo lê os pares nome/valor e os exibe no console, usando o GetValueKind método para exibir os tipos de dados do Registro correspondentes.
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.***]
Comentários
Como muitos valores podem ser armazenados em cada chave no Registro, você deve usar o name parâmetro para especificar o valor específico que deseja definir.
Observação
Uma chave do Registro pode ter um valor que não está associado a nenhum nome. Quando esse valor sem nome é exibido no Editor do Registro, a cadeia de caracteres "(Default)" é exibida em vez de um nome. Para definir esse valor sem nome, especifique ou null a cadeia de caracteres vazia ("") para name.
Para definir valores em uma chave, você deve abrir a chave com acesso de gravação. Depois de abrir uma chave com acesso de gravação, você pode alterar qualquer um dos pares nome/valor nessa chave.
Se o especificado name não existir na chave, ele será criado e o valor associado será definido valuecomo .
Observação
Especificar o tipo Unknown de dados do Registro é o mesmo que usar a SetValue sobrecarga.
Se o tipo do especificado value não corresponder ao especificado valueKinde os dados não puderem ser convertidos, ArgumentException será gerado. Por exemplo, você pode armazenar um System.Int64 como um RegistryValueKind.DWord, mas somente se seu valor for menor que o valor máximo de um System.Int32. Não é possível armazenar um único valor de cadeia de caracteres como um RegistryValueKind.MultiString.
Observação
Se os valores em caixa forem passados para RegistryValueKind.DWord ou RegistryValueKind.QWord, a conversão será feita usando a cultura invariável.
Cuidado
Não exponha objetos RegistryKey de maneira que um programa mal-intencionado possa criar milhares de subchaves sem sentido ou os pares de chave/valor. Por exemplo, não permita que chamadores insiram chaves ou valores arbitrários.
Confira também
Aplica-se a
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de