RegistryKey.SetValue 메서드
정의
중요
일부 정보는 릴리스되기 전에 상당 부분 수정될 수 있는 시험판 제품과 관련이 있습니다. Microsoft는 여기에 제공된 정보에 대해 어떠한 명시적이거나 묵시적인 보증도 하지 않습니다.
레지스트리 키에서 이름/값 쌍의 값을 설정합니다. 오버로드에 따라 레지스트리 데이터 형식은 저장되는 데이터 형식이나 지정된 RegistryValueKind에서 확인됩니다.
오버로드
| SetValue(String, Object) |
지정된 이름/값 쌍을 설정합니다. |
| SetValue(String, Object, RegistryValueKind) |
지정된 레지스트리 데이터 형식을 사용하여 레지스트리 키에서 이름/값 쌍의 값을 설정합니다. |
SetValue(String, Object)
지정된 이름/값 쌍을 설정합니다.
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)매개 변수
- name
- String
저장할 값의 이름입니다.
- value
- Object
저장할 데이터입니다.
예외
value이(가) null인 경우
value가 지원되지 않는 데이터 형식인 경우
지정된 값이 포함된 RegistryKey가 닫힌 경우. 닫힌 키는 액세스할 수 없습니다.
RegistryKey가 읽기 전용이고 쓸 수 없는 경우. 예를 들어, 키가 쓰기 권한으로 열리지 않았습니다.
사용자가 레지스트리 키를 만들거나 수정하는 데 필요한 사용 권한이 없는 경우
RegistryKey 개체가 루트 수준 노드를 나타내고 운영 체제가 Windows 2000, Windows XP 또는 Windows Server 2003인 경우
예제
다음 코드 예제에서는 메서드가 SetValue 값을 설정 하는 경우 레지스트리 데이터 형식을 결정 하는 방법을 보여 줍니다. 이 예제에서는 테스트 키를 만들고 다른 데이터 형식의 값을 키에 추가합니다. 그런 다음 이 예제에서는 이름/값 쌍을 읽고 해당 레지스트리 데이터 형식을 표시하는 방법을 사용하여 GetValueKind 콘솔에 표시합니다.
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
설명
레지스트리의 각 키에 많은 값을 저장할 수 있으므로 매개 변수를 name 사용하여 설정하려는 특정 값을 지정해야 합니다.
참고
레지스트리 키에는 이름과 연결되지 않은 값이 하나 있을 수 있습니다. 레지스트리 편집기에서 명명 되지 않은 값이 표시 되 면 "(기본값)" 문자열 이름 대신 표시 됩니다. 이 명명되지 않은 값을 설정하려면 빈 문자열("")을 name지정 null 합니다.
키의 값을 설정하려면 쓰기 권한이 있는 키를 열어야 합니다. 쓰기 액세스 권한이 있는 키를 연 후에는 해당 키의 이름/값 쌍을 변경할 수 있습니다.
지정된 name 키가 없는 경우 키는 만들어지고 연결된 값은 .로 value설정됩니다.
이 오버로드는 SetValue 64비트 정수를 문자열(RegistryValueKind.String)로 저장합니다. 64비트 숫자를 값으로 RegistryValueKind.QWord 저장하려면 지정RegistryValueKind하는 오버로드를 SetValue(String, Object, RegistryValueKind) 사용합니다.
이 오버로드는 환경 변수에 SetValue 대한 확장 가능한 참조를 포함하는 경우에도 모든 문자열 값을 로 RegistryValueKind.String저장합니다. 문자열 값을 확장 가능한 문자열(RegistryValueKind.ExpandString)로 저장하려면 지정RegistryValueKind하는 오버로드를 SetValue(String, Object, RegistryValueKind) 사용합니다.
32비트 정수 이외의 숫자 형식은 이 메서드 오버로드에 의해 문자열로 저장됩니다. 열거형 요소는 요소 이름을 포함하는 문자열로 저장됩니다.
주의
악의적인 프로그램에서 수천 개의 의미 없는 하위 키 또는 키/값 쌍을 만들 수 있는 방식으로 개체를 노출 RegistryKey 하지 마세요. 예를 들어 호출자가 임의의 키 또는 값을 입력하도록 허용하지 않습니다.
추가 정보
적용 대상
SetValue(String, Object, RegistryValueKind)
지정된 레지스트리 데이터 형식을 사용하여 레지스트리 키에서 이름/값 쌍의 값을 설정합니다.
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)매개 변수
- name
- String
저장할 값의 이름입니다.
- value
- Object
저장할 데이터입니다.
- valueKind
- RegistryValueKind
데이터를 저장할 때 사용할 레지스트리 데이터 형식입니다.
- 특성
예외
value이(가) null인 경우
value의 형식이 valueKind에 지정된 레지스트리 데이터 형식과 일치하지 않아 데이터가 올바르게 변환되지 않은 경우
지정된 값이 포함된 RegistryKey가 닫힌 경우. 닫힌 키는 액세스할 수 없습니다.
RegistryKey가 읽기 전용이고 쓸 수 없는 경우. 예를 들어, 키가 쓰기 권한으로 열리지 않았습니다.
사용자가 레지스트리 키를 만들거나 수정하는 데 필요한 사용 권한이 없는 경우
RegistryKey 개체가 루트 수준 노드를 나타내고 운영 체제가 Windows 2000, Windows XP 또는 Windows Server 2003인 경우
예제
다음 코드 예제에서는 테스트 키를 만들고 메서드를 SetValue 사용하여 각 값에 대한 레지스트리 데이터 형식을 지정하여 여러 값을 저장합니다. 그런 다음 이 예제에서는 이름/값 쌍을 읽고 해당 레지스트리 데이터 형식을 표시하는 방법을 사용하여 GetValueKind 콘솔에 표시합니다.
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.***]
설명
레지스트리의 각 키에 많은 값을 저장할 수 있으므로 매개 변수를 name 사용하여 설정하려는 특정 값을 지정해야 합니다.
참고
레지스트리 키에는 이름과 연결되지 않은 값이 하나 있을 수 있습니다. 레지스트리 편집기에서 명명 되지 않은 값이 표시 되 면 "(기본값)" 문자열 이름 대신 표시 됩니다. 이 명명되지 않은 값을 설정하려면 빈 문자열("")을 name지정 null 합니다.
키의 값을 설정하려면 쓰기 권한이 있는 키를 열어야 합니다. 쓰기 액세스 권한이 있는 키를 연 후에는 해당 키의 이름/값 쌍을 변경할 수 있습니다.
지정된 name 키가 없는 경우 키는 만들어지고 연결된 값은 .로 value설정됩니다.
지정된 형식이 지정된 value 형식과 일치하지 valueKind않고 데이터를 변환 ArgumentException 할 수 없는 경우 throw됩니다. 예를 들어 값을 최대값System.Int32보다 작은 경우에만 aRegistryValueKind.DWord로 저장할 System.Int64 수 있습니다. 단일 문자열 값을 으로 RegistryValueKind.MultiString저장할 수 없습니다.
참고
boxed 값이 전달 RegistryValueKind.DWord 되거나 RegistryValueKind.QWord전달되면 고정 문화권을 사용하여 변환이 수행됩니다.
주의
악의적인 프로그램에서 수천 개의 의미 없는 하위 키 또는 키/값 쌍을 만들 수 있는 방식으로 개체를 노출 RegistryKey 하지 마세요. 예를 들어 호출자가 임의의 키 또는 값을 입력하도록 허용하지 않습니다.