Metodo RegistryKey.SetValue (String, Object)

 

Data di pubblicazione: ottobre 2016

Imposta la coppia nome/valore specificata.

Spazio dei nomi:   Microsoft.Win32
Assembly:  mscorlib (in mscorlib.dll)

public void SetValue(
	string name,
	object value
)

Parametri

name
Type: System.String

Nome del valore da archiviare.

value
Type: System.Object

Dati da archiviare.

Exception Condition
ArgumentNullException

value è null.

ArgumentException

value è un tipo di dati non supportati.

ObjectDisposedException

Il RegistryKey che contiene il valore è chiuso (chiusa e non è possibile accedervi).

UnauthorizedAccessException

Il RegistryKey è di sola lettura e non può essere scritto; ad esempio, la chiave non è stato aperto con accesso in scrittura.

-oppure-

Il RegistryKey oggetto rappresenta un nodo di primo livello e il sistema operativo è Windows Millennium Edition o Windows 98.

SecurityException

L'utente non dispone delle autorizzazioni necessarie per creare o modificare le chiavi del Registro di sistema.

IOException

Il RegistryKey oggetto rappresenta un nodo di primo livello e il sistema operativo è Windows 2000, Windows XP o Windows Server 2003.

Poiché molti valori possono essere archiviati in ogni chiave del Registro di sistema, è necessario utilizzare il name parametro per specificare il valore da impostare.

System_CAPS_noteNota

Una chiave del Registro di sistema può essere un valore che non è associato ad alcun nome. Quando il valore senza nome viene visualizzato nell'editor del Registro di sistema, la stringa "(impostazione predefinita)" viene visualizzato invece un nome. Per impostare il valore senza nome, specificare null o una stringa vuota ("") per name.

Per impostare i valori in una chiave, è necessario aprire la chiave con accesso in scrittura. Dopo avere aperto una chiave con accesso in scrittura, è possibile modificare le coppie nome/valore in tale chiave.

Se l'oggetto specificato name non esiste nella chiave, viene creato e il valore associato viene impostato su value.

Questo overload del metodo SetValue archivia valori integer a 64 bit come stringhe (RegistryValueKind.String). Per archiviare numeri a 64 bit come RegistryValueKind.QWord usare valori di SetValue(String, Object, RegistryValueKind) overload che specifichi RegistryValueKind.

Questo overload del metodo SetValue Archivia tutti i valori stringa come RegistryValueKind.String, anche se contengono riferimenti espandibili a variabili di ambiente. Per salvare i valori stringa come stringhe espandibili (RegistryValueKind.ExpandString), utilizzare il SetValue(String, Object, RegistryValueKind) overload che specifichi RegistryValueKind.

Mediante questo overload del metodo, i tipi numerici diversi da valori integer a 32 bit vengono archiviati come stringhe. Enumerazione elementi vengono archiviati sotto forma di stringhe contenente i nomi di elemento.

System_CAPS_cautionAttenzione

Non esporre RegistryKey oggetti in modo che un programma dannoso crei migliaia di sottochiavi privo di significato o coppie chiave/valore. Ad esempio, si consente ai chiamanti di immettere valori o chiavi arbitrarie.

System_CAPS_noteNota

In Windows 98 e Windows Millennium Edition il Registro di sistema non è Unicode, e non tutti i caratteri Unicode sono validi per tutte le tabelle codici. Un carattere Unicode non valido per la tabella codici corrente viene sostituito dalla migliore corrispondenza disponibile. Non viene generata alcuna eccezione.

Nell'esempio di codice riportato di seguito viene illustrato come il SetValue metodo determina il tipo di dati del Registro di sistema quando vengono impostati i valori. L'esempio crea una chiave di prova e aggiunge i valori di diversi tipi di dati della chiave. Nell'esempio viene quindi legge le coppie nome/valore e li visualizza nella console, utilizzando il GetValueKind metodo per visualizzare i tipi di dati del Registro di sistema corrispondenti.

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;
            }
        }
    }
}

RegistryPermission

to modify the specified registry key if it exists, or to create the registry key if it does not already exist. Associated enumerations: F:System.Security.Permissions.RegistryPermissionAccess.Write, F:System.Security.Permissions.RegistryPermissionAccess.Create

SecurityPermission

for the ability to access the specified registry key if it is a remote key. Associated enumeration: F:System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode

.NET Framework
Disponibile da 1.1
Torna all'inizio
Mostra: