Registry Osztály
Definíció
Fontos
Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.
RegistryKey objektumokat biztosít, amelyek a Windows beállításjegyzék gyökérkulcsait jelölik, és static metódusokat a kulcs/érték párok eléréséhez.
public ref class Registry abstract sealedpublic ref class Registry sealedpublic static class Registrypublic sealed class Registry[System.Runtime.InteropServices.ComVisible(true)]
public static class Registrytype Registry = class[<System.Runtime.InteropServices.ComVisible(true)>]
type Registry = classPublic Class RegistryPublic NotInheritable Class Registry- Öröklődés
-
Registry
- Attribútumok
Megjegyzések
Az Registry osztály a Windows rendszert futtató gépeken a beállításjegyzékben található standard gyökérkulcsok készletét biztosítja. A beállításjegyzék egy tárolóhely az alkalmazásokról, a felhasználókról és az alapértelmezett rendszerbeállításokról. Az alkalmazások a beállításjegyzék használatával tárolhatják azokat az adatokat, amelyeket az alkalmazás bezárása után meg kell őrizni, és ugyanazokat az információkat érhetik el az alkalmazás újratöltésekor. Tárolhat például színbeállításokat, képernyőhelyeket vagy egy ablak méretét. Ezeket az adatokat az egyes felhasználók számára úgy szabályozhatja, hogy az adatokat egy másik helyen tárolja a beállításjegyzékben.
Azok az alappéldányok vagy gyökérpéldányok, amelyeket a RegistryKey osztály közzétesz, a beállításjegyzékben található alkulcsok és értékek alapvető tárolási mechanizmusát határozzák meg. Minden kulcs csak olvasható, mert létezésük szükséges a beállításjegyzékhez. A közzétett Registry kulcsok a következők:
| Key | Description |
|---|---|
| CurrentUser | A felhasználói beállításokra vonatkozó információkat tárolja. |
| LocalMachine | A helyi gép konfigurációs adatait tárolja. |
| ClassesRoot | A típusokkal (és osztályokkal) és azok tulajdonságaival kapcsolatos információkat tárolja. |
| Users | Az alapértelmezett felhasználói konfigurációval kapcsolatos információkat tárolja. |
| PerformanceData | A szoftverösszetevők teljesítményadatait tárolja. |
| CurrentConfig | Nem felhasználóspecifikus hardverinformációkat tárol. |
| DynData | Dinamikus adatokat tárol. |
Miután azonosította azt a gyökérkulcsot, amely alatt adatokat szeretne tárolni/lekérni a beállításjegyzékből, az RegistryKey osztály segítségével hozzáadhat vagy eltávolíthat alkulcsokat, és módosíthatja az adott kulcs értékeit.
A hardvereszközök a Plug and Play felület használatával automatikusan elhelyezhetnek információkat a beállításjegyzékben. Az eszközillesztők telepítésére szolgáló szoftverek a szabványos API-kba írva adatokat helyezhetnek el a beállításjegyzékben.
Statikus metódusok az értékek lekéréséhez és beállításához
Az Registry osztály emellett a beállításkulcsok értékeinek beállítására és beolvasására szolgáló módszereket is tartalmaz staticGetValueSetValue. Ezek a metódusok minden használatukkor megnyitják és bezárják a beállításkulcsokat. Így amikor nagy számú értéket ér el, azok nem végeznek olyan jól, mint a hasonló metódusok az RegistryKey osztályban.
Az RegistryKey osztály olyan metódusokat is biztosít, amelyek lehetővé teszik a következőket:
- Állítsa be a Windows hozzáférés-szabályozási biztonságát a rendszerleíró kulcsokhoz.
- A beolvasás előtt tesztelje egy érték adattípusát.
- Kulcsok törlése.
Az alábbi példakód bemutatja, hogyan kérdezheti le a kulcs alkulcsait HKEY_USERS , és hogyan nyomtathatja ki a nevüket a képernyőn. A metódus használatával OpenSubKey hozza létre az adott alkulcs egy példányát. Ezután más műveleteket is használhat a RegistryKey kulcs módosításához.
using namespace System;
using namespace Microsoft::Win32;
void PrintKeys( RegistryKey ^ rkey )
{
// Retrieve all the subkeys for the specified key.
array<String^>^names = rkey->GetSubKeyNames();
int icount = 0;
Console::WriteLine( "Subkeys of {0}", rkey->Name );
Console::WriteLine( "-----------------------------------------------" );
// Print the contents of the array to the console.
System::Collections::IEnumerator^ enum0 = names->GetEnumerator();
while ( enum0->MoveNext() )
{
String^ s = safe_cast<String^>(enum0->Current);
Console::WriteLine( s );
// The following code puts a limit on the number
// of keys displayed. Comment it out to print the
// complete list.
icount++;
if ( icount >= 10 )
break;
}
}
int main()
{
// Create a RegistryKey, which will access the HKEY_USERS
// key in the registry of this machine.
RegistryKey ^ rk = Registry::Users;
// Print out the keys.
PrintKeys( rk );
}
using System;
using Microsoft.Win32;
class Reg {
public static void Main() {
// Create a RegistryKey, which will access the HKEY_USERS
// key in the registry of this machine.
RegistryKey rk = Registry.Users;
// Print out the keys.
PrintKeys(rk);
}
static void PrintKeys(RegistryKey rkey) {
// Retrieve all the subkeys for the specified key.
string [] names = rkey.GetSubKeyNames();
int icount = 0;
Console.WriteLine("Subkeys of " + rkey.Name);
Console.WriteLine("-----------------------------------------------");
// Print the contents of the array to the console.
foreach (string s in names) {
Console.WriteLine(s);
// The following code puts a limit on the number
// of keys displayed. Comment it out to print the
// complete list.
icount++;
if (icount >= 10)
break;
}
}
}
Imports Microsoft.Win32
Class Reg
Public Shared Sub Main()
' Create a RegistryKey, which will access the HKEY_USERS
' key in the registry of this machine.
Dim rk As RegistryKey = Registry.Users
' Print out the keys.
PrintKeys(rk)
End Sub
Shared Sub PrintKeys(rkey As RegistryKey)
' Retrieve all the subkeys for the specified key.
Dim names As String() = rkey.GetSubKeyNames()
Dim icount As Integer = 0
Console.WriteLine("Subkeys of " & rkey.Name)
Console.WriteLine("-----------------------------------------------")
' Print the contents of the array to the console.
Dim s As String
For Each s In names
Console.WriteLine(s)
' The following code puts a limit on the number
' of keys displayed. Comment it out to print the
' complete list.
icount += 1
If icount >= 10 Then
Exit For
End If
Next s
End Sub
End Class
Az alábbi példakód több adattípus értékeit tárolja egy példakulcsban, és létrehozza a kulcsot, ahogy teszi, majd lekéri és megjeleníti az értékeket. A példa bemutatja az alapértelmezett (név nélküli) név/érték pár tárolását és beolvasását defaultValue , valamint azt, hogy mikor nem létezik név-érték pár.
using namespace System;
using namespace Microsoft::Win32;
int main()
{
// The name of the key must include a valid root.
String^ userRoot = "HKEY_CURRENT_USER";
String^ subKey = "RegistrySetValueExample2";
String^ keyName = String::Concat(userRoot, "\\", subKey);
// An int value can be stored without specifying the
// registry data type, but Int64 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, "TestInt64", 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.
array<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 Int64 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 testInteger = (int)Registry::GetValue(keyName, "", -1);
Console::WriteLine("(Default): {0}", testInteger);
long long testInt64 = (long long)Registry::GetValue(keyName,
"TestInt64", System::Int64::MinValue);
Console::WriteLine("TestInt64: {0}", testInt64);
// When retrieving a MultiString value, you can specify
// an array for the default return value.
array<String^>^ testArray = (array<String^>^)Registry::GetValue(
keyName, "TestArray",
gcnew array<String^> {"Default if TestArray does not exist."});
for (int i = 0; i < testArray->Length; i++)
{
Console::WriteLine("TestArray({0}): {1}", i, testArray[i]);
}
// A string with embedded environment variables is not
// expanded if it was stored as an ordinary string.
String^ testExpand = (String^)Registry::GetValue(keyName,
"TestExpand", "Default if TestExpand does not exist.");
Console::WriteLine("TestExpand: {0}", testExpand);
// A string stored as ExpandString is expanded.
String^ testExpand2 = (String^)Registry::GetValue(keyName,
"TestExpand2", "Default if TestExpand2 does not exist.");
Console::WriteLine(
"TestExpand2: {0}...", testExpand2->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
// TestInt64: 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.
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.
Imports Microsoft.Win32
Public Class Example
Public Shared Sub Main()
' The name of the key must include a valid root.
Const userRoot As String = "HKEY_CURRENT_USER"
Const subkey As String = "RegistrySetValueExample"
Const keyName As String = userRoot & "\" & subkey
' Integer values 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 integer 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.
Dim strings() As String = {"One", "Two", "Three"}
Registry.SetValue(keyName, "TestArray", strings)
' Your default value is returned if the name/value pair
' does not exist.
Dim noSuch As String = _
Registry.GetValue(keyName, "NoSuchName", _
"Return this default if NoSuchName does not exist.")
Console.WriteLine(vbCrLf & "NoSuchName: {0}", noSuch)
' Retrieve the Integer and Long values, specifying
' numeric default values in case the name/value pairs
' do not exist. The Integer value is retrieved from the
' default (nameless) name/value pair for the key.
Dim tInteger As Integer = _
Registry.GetValue(keyName, "", -1)
Console.WriteLine("(Default): {0}", tInteger)
Dim tLong As 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. The value is
' declared inline, but could also be declared as:
' Dim default() As String = {"Default value."}
'
Dim tArray() As String = _
Registry.GetValue(keyName, "TestArray", _
New String() {"Default if TestArray does not exist."})
For i As Integer = 0 To tArray.Length - 1
Console.WriteLine("TestArray({0}): {1}", i, tArray(i))
Next
' A string with embedded environment variables is not
' expanded if it was stored as an ordinary string.
Dim tExpand As String = Registry.GetValue(keyName, _
"TestExpand", "Default if TestExpand does not exist.")
Console.WriteLine("TestExpand: {0}", tExpand)
' A string stored as ExpandString is expanded.
Dim tExpand2 As String = Registry.GetValue(keyName, _
"TestExpand2", "Default if TestExpand2 does not exist.")
Console.WriteLine("TestExpand2: {0}...", _
tExpand2.Substring(0, 40))
Console.WriteLine(vbCrLf & _
"Use the registry editor to examine the key.")
Console.WriteLine("Press the Enter key to delete the key.")
Console.ReadLine()
Registry.CurrentUser.DeleteSubKey(subkey)
End Sub
End Class
'
' 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.
Mezők
| Name | Description |
|---|---|
| ClassesRoot |
Meghatározza a dokumentumok típusait (vagy osztályait) és az ezekhez a típusokhoz társított tulajdonságokat. Ez a mező beolvassa a Windows beállításjegyzék alapkulcsát HKEY_CLASSES_ROOT. |
| CurrentConfig |
A felhasználóra nem jellemző hardverre vonatkozó konfigurációs információkat tartalmaz. Ez a mező beolvassa a Windows beállításjegyzék alapkulcsát HKEY_CURRENT_CONFIG. |
| CurrentUser |
Az aktuális felhasználói beállításokra vonatkozó információkat tartalmaz. Ez a mező beolvassa a Windows beállításjegyzék alapkulcsát HKEY_CURRENT_USER. |
| DynData |
Elavult.
Dinamikus beállításjegyzék-adatokat tartalmaz. Ez a mező beolvassa a Windows beállításkulcs HKEY_DYN_DATA. |
| LocalMachine |
A helyi gép konfigurációs adatait tartalmazza. Ez a mező beolvassa a Windows beállításjegyzék alapkulcsát HKEY_LOCAL_MACHINE. |
| PerformanceData |
A szoftverösszetevők teljesítményadatait tartalmazza. Ez a mező beolvassa a Windows beállításjegyzék alapkulcsát HKEY_PERFORMANCE_DATA. |
| Users |
Az alapértelmezett felhasználói konfigurációval kapcsolatos információkat tartalmaz. Ez a mező beolvassa a Windows beállításjegyzék alapkulcsát HKEY_USERS. |
Metódusok
| Name | Description |
|---|---|
| GetValue(String, String, Object) |
Lekéri a megadott névhez társított értéket a megadott beállításkulcsban. Ha a név nem található a megadott kulcsban, a megadott alapértelmezett értéket adja vissza, vagy |
| SetValue(String, String, Object, RegistryValueKind) |
A megadott beállításkulcs név-érték párjának beállítása a megadott beállításjegyzék-adattípus használatával. Ha a megadott kulcs nem létezik, létrejön. |
| SetValue(String, String, Object) |
A megadott név-érték pár beállítása a megadott beállításkulcson. Ha a megadott kulcs nem létezik, létrejön. |
