Registry Sınıf

Tanım

RegistryKey Windows kayıt defterindeki kök anahtarları temsil eden nesneler ve static anahtar/değer çiftlerine erişme yöntemleri sağlar.

public ref class Registry abstract sealed
public ref class Registry sealed
public static class Registry
public sealed class Registry
[System.Runtime.InteropServices.ComVisible(true)]
public static class Registry
type Registry = class
[<System.Runtime.InteropServices.ComVisible(true)>]
type Registry = class
Public Class Registry
Public NotInheritable Class Registry
Devralma
Registry
Öznitelikler

Örnekler

Bu bölüm iki kod örneği içerir. İlk örnekte kök anahtarlar, ikinci örnekte ise ve SetValue yöntemleri gösterilmektedir.staticGetValue

Örnek 1

Aşağıdaki kod örneği, HKEY_USERS anahtarının alt anahtarlarının nasıl alınıp adlarının ekrana yazdırılacağını gösterir. OpenSubKey yöntemini kullanarak ilgilendiğiniz alt anahtarın bir örneğini oluşturun. Daha sonra bu anahtarı işlemek için içindeki RegistryKey diğer işlemleri kullanabilirsiniz.

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

Örnek 2

Aşağıdaki kod örneği, birkaç veri türünün değerlerini bir örnek anahtarda depolar, anahtarı böyle oluşturur ve ardından değerleri alır ve görüntüler. Örnekte, varsayılan (adsız) ad/değer çiftinin depolanması ve alınması ve bir ad/değer çifti olmadığında kullanılması defaultValue gösterilmektedir.

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.

Açıklamalar

Bu sınıf, Windows çalıştıran makinelerde kayıt defterinde bulunan standart kök anahtar kümesini sağlar. Kayıt defteri uygulamalar, kullanıcılar ve varsayılan sistem ayarları hakkında bilgi için bir depolama tesisidir. Örneğin, uygulamalar uygulama kapatıldıktan sonra korunması gereken bilgileri depolamak ve uygulama yeniden yüklendiğinde aynı bilgilere erişmek için kayıt defterini kullanabilir. Örneğin, renk tercihlerini, ekran konumlarını veya pencerenin boyutunu depolayabilirsiniz. Bilgileri kayıt defterinde farklı bir konumda depolayarak her kullanıcı için bu verileri denetleyebilirsiniz.

sınıfı tarafından kullanıma sunulan temel veya kök RegistryKey örnekler, kayıt defterindeki Registry alt anahtarlar ve değerler için temel depolama mekanizmasını belirtir. Kayıt defteri varlığına bağlı olduğundan tüm anahtarlar salt okunur durumdadır. Tarafından kullanıma sunulan Registry anahtarlar şunlardır:

CurrentUser Kullanıcı tercihleri hakkındaki bilgileri depolar.

LocalMachine Yerel makine için yapılandırma bilgilerini depolar.

ClassesRoot Türler (ve sınıflar) ve özellikleri hakkındaki bilgileri depolar.

Users Varsayılan kullanıcı yapılandırması hakkındaki bilgileri depolar.

PerformanceData Yazılım bileşenleri için performans bilgilerini depolar.

CurrentConfig Kullanıcıya özgü olmayan donanım bilgilerini depolar.

DynData Dinamik verileri depolar.

Kayıt defterinde bilgileri depolamak/almak istediğiniz kök anahtarı belirledikten sonra, alt anahtar eklemek veya kaldırmak ve belirli bir anahtarın değerlerini işlemek için sınıfını kullanabilirsiniz RegistryKey .

Donanım cihazları, Tak ve Kullan arabirimini kullanarak bilgileri kayıt defterine otomatik olarak yerleştirebilir. Cihaz sürücülerini yüklemeye yönelik yazılım, standart API'lere yazarak kayıt defterine bilgi yerleştirebilir.

Değerleri Alma ve Ayarlama için Statik Yöntemler

sınıfı Registry ayrıca kayıt defteri anahtarlarından değerleri ayarlamak ve almak için ve SetValue yöntemleri içerirstaticGetValue. Bu yöntemler, her kullanıldıklarında kayıt defteri anahtarlarını açar ve kapatır, bu nedenle çok sayıda değere eriştiğinizde sınıftaki benzer yöntemleri RegistryKey gerçekleştirmez.

sınıfı RegistryKey ayrıca kayıt defteri anahtarları için Windows erişim denetimi güvenliğini ayarlamanıza, bir değeri almadan önce veri türünü test etmeye ve anahtarları silmenize olanak sağlayan yöntemler sağlar.

Alanlar

ClassesRoot

Belgelerin türlerini (veya sınıflarını) ve bu türlerle ilişkili özellikleri tanımlar. Bu alan, Windows kayıt defteri temel anahtarını HKEY_CLASSES_ROOT okur.

CurrentConfig

Kullanıcıya özgü olmayan donanımla ilgili yapılandırma bilgilerini içerir. Bu alan, Windows kayıt defteri temel anahtarını HKEY_CURRENT_CONFIG okur.

CurrentUser

Geçerli kullanıcı tercihleri hakkında bilgi içerir. Bu alan, Windows kayıt defteri temel anahtarı HKEY_CURRENT_USER okur.

DynData
Kullanımdan kalktı.
Kullanımdan kalktı.

Dinamik kayıt defteri verilerini içerir. Bu alan, Windows kayıt defteri temel anahtarını HKEY_DYN_DATA okur.

LocalMachine

Yerel makinenin yapılandırma verilerini içerir. Bu alan, Windows kayıt defteri temel anahtarını HKEY_LOCAL_MACHINE okur.

PerformanceData

Yazılım bileşenleri için performans bilgilerini içerir. Bu alan, Windows kayıt defteri temel anahtarını HKEY_PERFORMANCE_DATA okur.

Users

Varsayılan kullanıcı yapılandırması hakkında bilgi içerir. Bu alan, Windows kayıt defteri temel anahtarını HKEY_USERS okur.

Yöntemler

GetValue(String, String, Object)

Belirtilen kayıt defteri anahtarında belirtilen adla ilişkili değeri alır. Ad belirtilen anahtarda bulunamazsa, sağladığınız null veya belirtilen anahtar yoksa varsayılan bir değer döndürür.

SetValue(String, String, Object)

Belirtilen kayıt defteri anahtarında belirtilen ad/değer çiftini ayarlar. Belirtilen anahtar yoksa oluşturulur.

SetValue(String, String, Object, RegistryValueKind)

Belirtilen kayıt defteri veri türünü kullanarak belirtilen kayıt defteri anahtarındaki ad/değer çiftini ayarlar. Belirtilen anahtar yoksa oluşturulur.

Şunlara uygulanır

Ayrıca bkz.