Metodo Registry.SetValue (String, String, Object, RegistryValueKind)

 

Data di pubblicazione: ottobre 2016

Imposta la coppia nome/valore nella chiave del Registro di sistema, utilizzando il tipo di dati del Registro di sistema. Se la chiave specificata non esiste, viene creato.

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

public static void SetValue(
	string keyName,
	string valueName,
	object value,
	RegistryValueKind valueKind
)

Parametri

keyName
Type: System.String

Il percorso completo della chiave, a partire da una radice del Registro di sistema valido, ad esempio "HKEY_CURRENT_USER".

valueName
Type: System.String

Il nome della coppia nome/valore.

value
Type: System.Object

Il valore da archiviare.

valueKind
Type: Microsoft.Win32.RegistryValueKind

Tipo di dati del Registro di sistema da usare per l'archiviazione dei dati.

Exception Condition
ArgumentNullException

value è null.

ArgumentException

keyName non inizia con una radice del Registro di sistema valido.

-oppure-

keyName è maggiore della lunghezza massima consentita (255 caratteri).

-oppure-

Il tipo di value non corrisponde il tipo di dati del Registro di sistema specificato da valueKind, pertanto non è stato possibile convertire i dati in modo corretto.

UnauthorizedAccessException

Il RegistryKey è di sola lettura e pertanto non è possibile scrivere; ad esempio, è un nodo di primo livello o la chiave non è stato aperto con accesso in scrittura.

SecurityException

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

A partire dal .NET Framework 4,  valueName parametro non è più limitato a un massimo di 255 caratteri; tuttavia, il keyName parametro ancora la restrizione di 255 caratteri.

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

System_CAPS_noteNota

Una chiave del Registro di sistema può contenere 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 valueName.

Se valueName non esiste nella chiave, viene creato e il valore associato viene impostato su value.

Se keyName Specifica una sottochiave che non esiste, viene creata la sottochiave nella radice specificata. In Visual Basic, ad esempio, la stringa "HKEY_CURRENT_USER\MyTestKey" crea la sottochiave "MyTestKey" nella radice HKEY_CURRENT_USER. La stringa "HKEY_CURRENT_USER\MyTestKey\Key2\Key3" Crea le sottochiavi annidate "MyTestKey", "MyTestKey\Key2" e "MyTestKey\Key2\Key3".

I nomi di primo livello valido includono HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE, HKEY_CLASSES_ROOT, HKEY_USERS, HKEY_PERFORMANCE_DATA, HKEY_CURRENT_CONFIG e HKEY_DYN_DATA.

System_CAPS_noteNota

Il SetValue metodo apre una chiave del Registro di sistema, imposta il valore e chiude la chiave ogni volta che viene chiamato. Se è necessario modificare un numero elevato di valori, il RegistryKey.SetValue metodo può fornire prestazioni migliori. La RegistryKey classe fornisce inoltre metodi che consentono di aggiungere un elenco di controllo di accesso (ACL) a una chiave del Registro di sistema, verificare il tipo di dati di un valore prima del suo recupero ed eliminare le chiavi.

Se il tipo dell'oggetto specificato value non corrispondono alla stringa valueKind, e i dati non possono essere convertito, ArgumentException viene generata un'eccezione. Ad esempio, è possibile archiviare un System.Int64 come un RegistryValueKind.DWord, ma solo se il valore è minore del valore massimo di un System.Int32. Non è possibile archiviare un valore stringa singolo come un RegistryValueKind.MultiString.

System_CAPS_noteNota

Se vengono passati valori boxed RegistryValueKind.DWord o RegistryValueKind.QWord, la conversione viene eseguita utilizzando le impostazioni cultura invarianti.

System_CAPS_noteNota

In Windows 98 e Windows Millennium Edition (Me), il Registro di sistema non è in formato 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.

Esempio di codice seguente archivia i valori dei diversi tipi di dati in una chiave di esempio, la creazione della chiave come esegue tale operazione, quindi recupera e visualizza i valori. Nell'esempio di seguito viene illustrato come archiviare e recuperare la coppia nome/valore (senza nome) predefinita e l'utilizzo di defaultValue Se non esiste una coppia nome/valore.

using System;
using Microsoft.Win32;

public class Example
{
    public static void Main()
    {
        // The name of the key must include a valid root.
        const string userRoot = "HKEY_CURRENT_USER";
        const string subkey = "RegistrySetValueExample";
        const string keyName = userRoot + "\\" + subkey;

        // An int value can be stored without specifying the
        // registry data type, but long values will be stored
        // as strings unless you specify the type. Note that
        // the int is stored in the default name/value
        // pair.
        Registry.SetValue(keyName, "", 5280);
        Registry.SetValue(keyName, "TestLong", 12345678901234,
            RegistryValueKind.QWord);

        // Strings with expandable environment variables are
        // stored as ordinary strings unless you specify the
        // data type.
        Registry.SetValue(keyName, "TestExpand", "My path: %path%");
        Registry.SetValue(keyName, "TestExpand2", "My path: %path%",
            RegistryValueKind.ExpandString);

        // Arrays of strings are stored automatically as 
        // MultiString. Similarly, arrays of Byte are stored
        // automatically as Binary.
        string[] strings = {"One", "Two", "Three"};
        Registry.SetValue(keyName, "TestArray", strings);

        // Your default value is returned if the name/value pair
        // does not exist.
        string noSuch = (string) Registry.GetValue(keyName, 
            "NoSuchName",
            "Return this default if NoSuchName does not exist.");
        Console.WriteLine("\r\nNoSuchName: {0}", noSuch);

        // Retrieve the int and long values, specifying 
        // numeric default values in case the name/value pairs
        // do not exist. The int value is retrieved from the
        // default (nameless) name/value pair for the key.
        int tInteger = (int) Registry.GetValue(keyName, "", -1);
        Console.WriteLine("(Default): {0}", tInteger);
        long tLong = (long) Registry.GetValue(keyName, "TestLong",
            long.MinValue);
        Console.WriteLine("TestLong: {0}", tLong);

        // When retrieving a MultiString value, you can specify
        // an array for the default return value. 
        string[] tArray = (string[]) Registry.GetValue(keyName,
            "TestArray",
            new string[] {"Default if TestArray does not exist."});
        for(int i=0; i<tArray.Length; i++)
        {
            Console.WriteLine("TestArray({0}): {1}", i, tArray[i]);
        }

        // A string with embedded environment variables is not
        // expanded if it was stored as an ordinary string.
        string tExpand = (string) Registry.GetValue(keyName,
             "TestExpand", 
             "Default if TestExpand does not exist.");
        Console.WriteLine("TestExpand: {0}", tExpand);

        // A string stored as ExpandString is expanded.
        string tExpand2 = (string) Registry.GetValue(keyName,
            "TestExpand2",
            "Default if TestExpand2 does not exist.");
        Console.WriteLine("TestExpand2: {0}...",
            tExpand2.Substring(0, 40));

        Console.WriteLine("\r\nUse the registry editor to examine the key.");
        Console.WriteLine("Press the Enter key to delete the key.");
        Console.ReadLine();
        Registry.CurrentUser.DeleteSubKey(subkey);
    }
}
//
// This code example produces output similar to the following:
//
//NoSuchName: Return this default if NoSuchName does not exist.
//(Default): 5280
//TestLong: 12345678901234
//TestArray(0): One
//TestArray(1): Two
//TestArray(2): Three
//TestExpand: My path: %path%
//TestExpand2: My path: D:\Program Files\Microsoft.NET\...
//
//Use the registry editor to examine the key.
//Press the Enter key to delete the key.

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

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