RegistryKey.SetValue メソッド

定義

レジストリ キーに名前/値ペアの値を設定します。Sets the value of a name/value pair in the registry key. オーバーロードに応じて、格納するデータの型または指定した RegistryValueKind に基づいてレジストリ データ型が判別されます。Depending on the overload, the registry data type is determined from the type of data being stored or from a specified RegistryValueKind.

オーバーロード

SetValue(String, Object)

指定した名前/値ペアを設定します。Sets the specified name/value pair.

SetValue(String, Object, RegistryValueKind)

指定したレジストリ データ型を使用して、レジストリ キーに名前/値ペアの値を設定します。Sets the value of a name/value pair in the registry key, using the specified registry data type.

SetValue(String, Object)

指定した名前/値ペアを設定します。Sets the specified name/value pair.

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 -> unit
Public Sub SetValue (name As String, value As Object)

パラメーター

name
String

格納する値の名前。The name of the value to store.

value
Object

格納するデータ。The data to be stored.

例外

valuenullです。value is null.

value がサポートされないデータ型です。value is an unsupported data type.

指定された値を格納している RegistryKey が閉じています。閉じられたキーにはアクセスできません。The RegistryKey that contains the specified value is closed (closed keys cannot be accessed).

RegistryKey は読み取り専用なので、書き込みできません。たとえば、キーが書き込みアクセスで開かれていません。The RegistryKey is read-only, and cannot be written to; for example, the key has not been opened with write access.

ユーザーに、レジストリ キーの作成または変更に必要なアクセス許可がありません。The user does not have the permissions required to create or modify registry keys.

RegistryKey オブジェクトがルート レベルのノードを表し、オペレーティング システムが Windows 2000、Windows XP、または Windows Server 2003 です。The RegistryKey object represents a root-level node, and the operating system is Windows 2000, Windows XP, or Windows Server 2003.

次のコード例は、 SetValue 値を設定するときに、メソッドがレジストリデータ型を決定する方法を示しています。The following code example shows how the SetValue method determines the registry data type when it sets values. この例では、テストキーを作成し、異なるデータ型の値をキーに追加します。The example creates a test key and adds values of different data types to the key. 次に、名前と値のペアを読み取ってコンソールに表示し、メソッドを使用して GetValueKind 対応するレジストリデータ型を表示します。The example then reads the name/value pairs and displays them to the console, using the GetValueKind method to display the corresponding registry data types.

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 ます。Because many values can be stored in each key in the registry, you must use the name parameter to specify the particular value you want to set.

注意

レジストリキーには、どの名前にも関連付けられていない1つの値を含めることができます。A registry key can have one value that is not associated with any name. この名前のない値がレジストリエディターに表示されると、名前の代わりに "(既定値)" という文字列が表示されます。When this unnamed value is displayed in the registry editor, the string "(Default)" appears instead of a name. この名前のない値を設定するに null は、にまたは空の文字列 ("") を指定し name ます。To set this unnamed value, specify either null or the empty string ("") for name.

キーの値を設定するには、書き込みアクセス権を持つキーを開く必要があります。In order to set values in a key, you must open the key with write access. 書き込みアクセス権を持つキーを開いた後、そのキーの名前と値のペアを変更できます。After you have opened a key with write access, you can change any of the name/value pairs in that key.

指定したが name キーに存在しない場合は、作成され、関連付けられた値がに設定され value ます。If the specified name does not exist in the key, it is created and the associated value is set to value.

のこのオーバーロードでは SetValue 、64ビット整数が文字列 () として格納さ RegistryValueKind.String れます。This overload of SetValue stores 64-bit integers as strings (RegistryValueKind.String). 64ビットの数値を値として格納するには RegistryValueKind.QWordSetValue(String, Object, RegistryValueKind) を指定するオーバーロードを使用し RegistryValueKind ます。To store 64-bit numbers as RegistryValueKind.QWord values, use the SetValue(String, Object, RegistryValueKind) overload that specifies RegistryValueKind.

SetValue RegistryValueKind.String 環境変数への展開可能な参照が含まれている場合でも、のこのオーバーロードでは、すべての文字列値がとして格納されます。This overload of SetValue stores all string values as RegistryValueKind.String, even if they contain expandable references to environment variables. 文字列値を展開可能な文字列 () として保存するには RegistryValueKind.ExpandStringSetValue(String, Object, RegistryValueKind) を指定するオーバーロードを使用し RegistryValueKind ます。To save string values as expandable strings (RegistryValueKind.ExpandString), use the SetValue(String, Object, RegistryValueKind) overload that specifies RegistryValueKind.

32ビット整数以外の数値型は、このメソッドオーバーロードによって文字列として格納されます。Numeric types other than 32-bit integers are stored as strings by this method overload. 列挙要素は、要素名を含む文字列として格納されます。Enumeration elements are stored as strings containing the element names.

注意事項

RegistryKey悪意のあるプログラムによって何千もの無意味なサブキーまたはキーと値のペアが作成されるような方法でオブジェクトを公開しないでください。Do not expose RegistryKey objects in such a way that a malicious program could create thousands of meaningless subkeys or key/value pairs. たとえば、呼び出し元が任意のキーまたは値を入力することを許可しないでください。For example, do not allow callers to enter arbitrary keys or values.

こちらもご覧ください

適用対象

SetValue(String, Object, RegistryValueKind)

指定したレジストリ データ型を使用して、レジストリ キーに名前/値ペアの値を設定します。Sets the value of a name/value pair in the registry key, using the specified registry data type.

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 -> unit
Public Sub SetValue (name As String, value As Object, valueKind As RegistryValueKind)

パラメーター

name
String

格納される値の名前。The name of the value to be stored.

value
Object

格納するデータ。The data to be stored.

valueKind
RegistryValueKind

データを格納する際に使用するレジストリ データ型。The registry data type to use when storing the data.

属性

例外

valuenullです。value is null.

value の型が valueKind で指定したレジストリ データ型と一致しなかったため、データを適切に変換できませんでした。The type of value did not match the registry data type specified by valueKind, therefore the data could not be converted properly.

指定された値を格納している RegistryKey が閉じています。閉じられたキーにはアクセスできません。The RegistryKey that contains the specified value is closed (closed keys cannot be accessed).

RegistryKey は読み取り専用なので、書き込みできません。たとえば、キーが書き込みアクセスで開かれていません。The RegistryKey is read-only, and cannot be written to; for example, the key has not been opened with write access.

ユーザーに、レジストリ キーの作成または変更に必要なアクセス許可がありません。The user does not have the permissions required to create or modify registry keys.

RegistryKey オブジェクトがルート レベルのノードを表し、オペレーティング システムが Windows 2000、Windows XP、または Windows Server 2003 です。The RegistryKey object represents a root-level node, and the operating system is Windows 2000, Windows XP, or Windows Server 2003.

次のコード例では、テストキーを作成し、メソッドを使用して SetValue 複数の値を格納し、各値のレジストリデータ型を指定します。The following code example creates a test key and uses the SetValue method to store several values, specifying the registry data type for each value. 次に、名前と値のペアを読み取ってコンソールに表示し、メソッドを使用して GetValueKind 対応するレジストリデータ型を表示します。The example then reads the name/value pairs and displays them to the console, using the GetValueKind method to display the corresponding registry data types.

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 ます。Because many values can be stored in each key in the registry, you must use the name parameter to specify the particular value you want to set.

注意

レジストリキーには、どの名前にも関連付けられていない1つの値を含めることができます。A registry key can have one value that is not associated with any name. この名前のない値がレジストリエディターに表示されると、名前の代わりに "(既定値)" という文字列が表示されます。When this unnamed value is displayed in the registry editor, the string "(Default)" appears instead of a name. この名前のない値を設定するに null は、にまたは空の文字列 ("") を指定し name ます。To set this unnamed value, specify either null or the empty string ("") for name.

キーの値を設定するには、書き込みアクセス権を持つキーを開く必要があります。In order to set values in a key, you must open the key with write access. 書き込みアクセス権を持つキーを開いた後、そのキーの名前と値のペアを変更できます。After you have opened a key with write access, you can change any of the name/value pairs in that key.

指定したが name キーに存在しない場合は、作成され、関連付けられている値はに設定され value ます。If the specified name does not exist in the key, it is created, and the associated value is set to value.

注意

レジストリデータ型の指定 Unknown は、オーバーロードを使用する場合と同じです SetValueSpecifying the registry data type Unknown is the same as using the SetValue overload.

指定したの型が指定したと value 一致せず、 valueKind データを変換できない場合 ArgumentException は、がスローされます。If the type of the specified value does not match the specified valueKind, and the data cannot be converted, ArgumentException is thrown. たとえば、を System.Int64 として格納でき RegistryValueKind.DWord ますが、その値がの最大値よりも小さい場合に限られ System.Int32 ます。For example, you can store a System.Int64 as a RegistryValueKind.DWord, but only if its value is less than the maximum value of a System.Int32. 1つの文字列値をとして格納することはできません RegistryValueKind.MultiStringYou cannot store a single string value as a RegistryValueKind.MultiString.

注意

またはに対してボックス化された値が渡された場合 RegistryValueKind.DWord RegistryValueKind.QWord 、変換はインバリアントカルチャを使用して行われます。If boxed values are passed for RegistryValueKind.DWord or RegistryValueKind.QWord, the conversion is done using the invariant culture.

注意事項

RegistryKey悪意のあるプログラムによって何千もの無意味なサブキーまたはキーと値のペアが作成されるような方法でオブジェクトを公開しないでください。Do not expose RegistryKey objects in such a way that a malicious program could create thousands of meaningless subkeys or key/value pairs. たとえば、呼び出し元が任意のキーまたは値を入力することを許可しないでください。For example, do not allow callers to enter arbitrary keys or values.

こちらもご覧ください

適用対象