RegistryKey Klasa

Definicja

Przestrzeń nazw:

Microsoft.Win32

Zestaw:

Microsoft.Win32.Registry.dll

Reprezentuje węzeł na poziomie klucza w rejestrze systemu Windows. Ta klasa jest hermetyzacją rejestru.

public ref class RegistryKey sealed : MarshalByRefObject, IDisposable

public sealed class RegistryKey : MarshalByRefObject, IDisposable

type RegistryKey = class
    inherit MarshalByRefObject
    interface IDisposable

Public NotInheritable Class RegistryKey
Inherits MarshalByRefObject
Implements IDisposable

Dziedziczenie

Object

MarshalByRefObject

RegistryKey

Implementuje

IDisposable

Przykłady

Poniższy przykład kodu pokazuje, jak utworzyć podklucz w HKEY_CURRENT_USER, manipulować jego zawartością, a następnie usunąć podklucz.

using namespace System;
using namespace System::Security::Permissions;
using namespace Microsoft::Win32;

int main()
{
   // Create a subkey named Test9999 under HKEY_CURRENT_USER.
   RegistryKey ^ test9999 = Registry::CurrentUser->CreateSubKey( "Test9999" );

   // Create two subkeys under HKEY_CURRENT_USER\Test9999.
   test9999->CreateSubKey( "TestName" )->Close();
   RegistryKey ^ testSettings = test9999->CreateSubKey( "TestSettings" );

   // Create data for the TestSettings subkey.
   testSettings->SetValue( "Language", "French" );
   testSettings->SetValue( "Level", "Intermediate" );
   testSettings->SetValue( "ID", 123 );
   testSettings->Close();

   // Print the information from the Test9999 subkey.
   Console::WriteLine( "There are {0} subkeys under Test9999.", test9999->SubKeyCount.ToString() );
   array<String^>^subKeyNames = test9999->GetSubKeyNames();
   for ( int i = 0; i < subKeyNames->Length; i++ )
   {
      RegistryKey ^ tempKey = test9999->OpenSubKey( subKeyNames[ i ] );
      Console::WriteLine( "\nThere are {0} values for {1}.", tempKey->ValueCount.ToString(), tempKey->Name );
      array<String^>^valueNames = tempKey->GetValueNames();
      for ( int j = 0; j < valueNames->Length; j++ )
      {
         Console::WriteLine( "{0,-8}: {1}", valueNames[ j ], tempKey->GetValue( valueNames[ j ] )->ToString() );

      }
   }
   
   // Delete the ID value.
   testSettings = test9999->OpenSubKey( "TestSettings", true );
   testSettings->DeleteValue( "id" );

   // Verify the deletion.
   Console::WriteLine( dynamic_cast<String^>(testSettings->GetValue(  "id", "ID not found." )) );
   testSettings->Close();

   // Delete or close the new subkey.
   Console::Write( "\nDelete newly created registry key? (Y/N) " );
   if ( Char::ToUpper( Convert::ToChar( Console::Read() ) ) == 'Y' )
   {
      Registry::CurrentUser->DeleteSubKeyTree( "Test9999" );
      Console::WriteLine( "\nRegistry key {0} deleted.", test9999->Name );
   }
   else
   {
      Console::WriteLine( "\nRegistry key {0} closed.", test9999->ToString() );
      test9999->Close();
   }
}

using System;
using System.Security.Permissions;
using Microsoft.Win32;

class RegKey
{
    static void Main()
    {
        // Create a subkey named Test9999 under HKEY_CURRENT_USER.
        RegistryKey test9999 =
            Registry.CurrentUser.CreateSubKey("Test9999");
        // Create two subkeys under HKEY_CURRENT_USER\Test9999. The
        // keys are disposed when execution exits the using statement.
        using(RegistryKey
            testName = test9999.CreateSubKey("TestName"),
            testSettings = test9999.CreateSubKey("TestSettings"))
        {
            // Create data for the TestSettings subkey.
            testSettings.SetValue("Language", "French");
            testSettings.SetValue("Level", "Intermediate");
            testSettings.SetValue("ID", 123);
        }

        // Print the information from the Test9999 subkey.
        Console.WriteLine("There are {0} subkeys under {1}.",
            test9999.SubKeyCount.ToString(), test9999.Name);
        foreach(string subKeyName in test9999.GetSubKeyNames())
        {
            using(RegistryKey
                tempKey = test9999.OpenSubKey(subKeyName))
            {
                Console.WriteLine("\nThere are {0} values for {1}.",
                    tempKey.ValueCount.ToString(), tempKey.Name);
                foreach(string valueName in tempKey.GetValueNames())
                {
                    Console.WriteLine("{0,-8}: {1}", valueName,
                        tempKey.GetValue(valueName).ToString());
                }
            }
        }

        using(RegistryKey
            testSettings = test9999.OpenSubKey("TestSettings", true))
        {
            // Delete the ID value.
            testSettings.DeleteValue("id");

            // Verify the deletion.
            Console.WriteLine((string)testSettings.GetValue(
                "id", "ID not found."));
        }

        // Delete or close the new subkey.
        Console.Write("\nDelete newly created registry key? (Y/N) ");
        if(Char.ToUpper(Convert.ToChar(Console.Read())) == 'Y')
        {
            Registry.CurrentUser.DeleteSubKeyTree("Test9999");
            Console.WriteLine("\nRegistry key {0} deleted.",
                test9999.Name);
        }
        else
        {
            Console.WriteLine("\nRegistry key {0} closed.",
                test9999.ToString());
            test9999.Close();
        }
    }
}

Imports System.Security.Permissions
Imports Microsoft.Win32

Public Class RegKey
    Shared Sub Main()

        ' Create a subkey named Test9999 under HKEY_CURRENT_USER.
        Dim test9999 As RegistryKey = _
            Registry.CurrentUser.CreateSubKey("Test9999")

        ' Create two subkeys under HKEY_CURRENT_USER\Test9999.
        test9999.CreateSubKey("TestName").Close()
        Dim testSettings As RegistryKey = _
            test9999.CreateSubKey("TestSettings")

        ' Create data for the TestSettings subkey.
        testSettings.SetValue("Language", "French")
        testSettings.SetValue("Level", "Intermediate")
        testSettings.SetValue("ID", 123)
        testSettings.Close()

        ' Print the information from the Test9999 subkey.
        Console.WriteLine("There are {0} subkeys under Test9999.", _
            test9999.SubKeyCount.ToString())
        For Each subKeyName As String In test9999.GetSubKeyNames()
            Dim tempKey As RegistryKey = _
                test9999.OpenSubKey(subKeyName)
            Console.WriteLine(vbCrLf & "There are {0} values for " & _
                "{1}.", tempKey.ValueCount.ToString(), tempKey.Name)
            For Each valueName As String In tempKey.GetValueNames()
                Console.WriteLine("{0,-8}: {1}", valueName, _
                    tempKey.GetValue(valueName).ToString())
            Next
        Next

        ' Delete the ID value.
        testSettings = test9999.OpenSubKey("TestSettings", True)
        testSettings.DeleteValue("id")

        ' Verify the deletion.
        Console.WriteLine(CType(testSettings.GetValue( _
            "id", "ID not found."), String))
        testSettings.Close()

        ' Delete or close the new subkey.
        Console.Write(vbCrLf & "Delete newly created " & _
            "registry key? (Y/N) ")
        If Char.ToUpper(Convert.ToChar(Console.Read())) = "Y"C Then
            Registry.CurrentUser.DeleteSubKeyTree("Test9999")
            Console.WriteLine(vbCrLf & "Registry key {0} deleted.", _
                test9999.Name)
        Else
            Console.WriteLine(vbCrLf & "Registry key {0} closed.", _
                test9999.ToString())
            test9999.Close()
        End If
   
    End Sub
End Class

Uwagi

Aby uzyskać wystąpienie klasy RegistryKey, użyj jednego ze statycznych Registry elementów członkowskich klasy .

Rejestr działa jako centralne repozytorium informacji dla systemu operacyjnego i aplikacji na komputerze. Rejestr jest zorganizowany w formacie hierarchicznym na podstawie logicznej kolejności elementów przechowywanych w niej (zobacz Registry elementy na poziomie podstawowym w tej hierarchii). Podczas przechowywania informacji w rejestrze wybierz odpowiednią lokalizację na podstawie typu przechowywanych informacji. Pamiętaj, aby uniknąć niszczenia informacji utworzonych przez inne aplikacje, ponieważ może to spowodować, że te aplikacje wykazują nieoczekiwane zachowanie, a także mogą mieć negatywny wpływ na własną aplikację.

Ważne

Ten typ implementuje IDisposable interfejs. Po zakończeniu korzystania z typu należy go usunąć bezpośrednio lub pośrednio. Aby usunąć typ bezpośrednio, wywołaj metodę Disposetry/catch w bloku. Aby usunąć go pośrednio, użyj konstrukcji językowej, takiej jak using (w języku C#) lub Using (w Visual Basic). Aby uzyskać więcej informacji, zobacz sekcję "Using an Object that Implements IDisposable" (Używanie obiektu implementujące protokół IDisposable) w temacie interfejsu IDisposable .

Klucze rejestru są podstawową jednostką organizacji w rejestrze i mogą być porównywane z folderami w Eksplorator plików. Określony klucz może mieć podklucze, tak jak folder może mieć podfoldery. Każdy klucz można usunąć, o ile użytkownik ma odpowiednie uprawnienia, a klucz nie jest kluczem podstawowym lub na poziomie bezpośrednio pod kluczem podstawowym. Każdy klucz może mieć również wiele wartości skojarzonych z nim (wartość można porównać do pliku), które są używane do przechowywania informacji — na przykład informacji o aplikacji zainstalowanej na komputerze. Każda wartość zawiera jedną konkretną informację, którą można pobrać lub zaktualizować w razie potrzeby. Możesz na przykład utworzyć dla firmy element RegistryKey pod kluczem HKEY_LOCAL_MACHINE\Software, a następnie podklucz dla każdej aplikacji tworzonej przez firmę. Każdy podklucz zawiera informacje specyficzne dla tej aplikacji, takie jak ustawienia kolorów, lokalizacja ekranu i rozmiar lub rozpoznane rozszerzenia plików.

Należy pamiętać, że informacje przechowywane w rejestrze są dostępne dla innych aplikacji i użytkowników, dlatego nie powinny być używane do przechowywania danych zabezpieczeń ani krytycznych informacji o aplikacji.

Przestroga

Nie ujawniaj RegistryKey obiektów w taki sposób, że złośliwy program może tworzyć tysiące bezsensownych podkluczów lub par klucz/wartość. Na przykład nie wolno pozwalać obiektom wywołującym na wprowadzanie umownych kluczy ani wartości.

Począwszy od .NET Framework 4, długość klucza rejestru nie jest już ograniczona do 255 znaków.

Właściwości

Handle	SafeRegistryHandle Pobiera obiekt reprezentujący klucz rejestru, który jest hermetyzowany przez bieżący RegistryKey obiekt.
Name	Pobiera nazwę klucza.
SubKeyCount	Pobiera liczbę podkluczów bieżącego klucza.
ValueCount	Pobiera liczbę wartości w kluczu.
View	Pobiera widok użyty do utworzenia klucza rejestru.

Metody

Close()	Zamyka klucz i opróżnia go na dysk, jeśli jego zawartość została zmodyfikowana.
CreateObjRef(Type)	Tworzy obiekt zawierający wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikowania się z obiektem zdalnym. (Odziedziczone po MarshalByRefObject)
CreateSubKey(String)	Tworzy nowy podklucz lub otwiera istniejący podklucz na potrzeby dostępu do zapisu.
CreateSubKey(String, Boolean)	Tworzy nowy podklucz lub otwiera istniejący podklucz z określonym dostępem. Dostępne od .NET Framework 4.6.
CreateSubKey(String, Boolean, RegistryOptions)	Tworzy nowy podklucz lub otwiera istniejący podklucz z określonym dostępem. Dostępne od .NET Framework 4.6.
CreateSubKey(String, RegistryKeyPermissionCheck)	Tworzy nowy podklucz lub otwiera istniejący podklucz dostępu do zapisu przy użyciu określonej opcji sprawdzania uprawnień.
CreateSubKey(String, RegistryKeyPermissionCheck, RegistryOptions)	Tworzy podklucz lub otwiera podklucz dostępu do zapisu przy użyciu określonych opcji sprawdzania uprawnień i rejestru.
CreateSubKey(String, RegistryKeyPermissionCheck, RegistryOptions, RegistrySecurity)	Tworzy podklucz lub otwiera podklucz dostępu do zapisu przy użyciu określonej opcji sprawdzania uprawnień, opcji rejestru i zabezpieczeń rejestru.
CreateSubKey(String, RegistryKeyPermissionCheck, RegistrySecurity)	Tworzy nowy podklucz lub otwiera istniejący podklucz dostępu do zapisu przy użyciu określonej opcji sprawdzania uprawnień i zabezpieczeń rejestru.
DeleteSubKey(String)	Usuwa określony podklucz.
DeleteSubKey(String, Boolean)	Usuwa określony podklucz i określa, czy wyjątek jest zgłaszany, jeśli podklucz nie zostanie znaleziony.
DeleteSubKeyTree(String)	Usuwa podklucz i wszystkie podrzędne podklucze cyklicznie.
DeleteSubKeyTree(String, Boolean)	Usuwa określony podklucz i wszystkie podrzędne podklucze rekursywnie i określa, czy wyjątek jest zgłaszany, jeśli podklucz nie zostanie znaleziony.
DeleteValue(String)	Usuwa określoną wartość z tego klucza.
DeleteValue(String, Boolean)	Usuwa określoną wartość z tego klucza i określa, czy jest zgłaszany wyjątek, jeśli wartość nie zostanie znaleziona.
Dispose()	Zwalnia wszystkie zasoby używane przez bieżące wystąpienie klasy RegistryKey.
Equals(Object)	Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object)
Flush()	Zapisuje wszystkie atrybuty określonego otwartego klucza rejestru w rejestrze.
FromHandle(SafeRegistryHandle)	Tworzy klucz rejestru z określonego uchwytu.
FromHandle(SafeRegistryHandle, RegistryView)	Tworzy klucz rejestru na podstawie określonego ustawienia uchwytu i widoku rejestru.
GetAccessControl()	Zwraca zabezpieczenia kontroli dostępu dla bieżącego klucza rejestru.
GetAccessControl(AccessControlSections)	Zwraca określone sekcje zabezpieczeń kontroli dostępu dla bieżącego klucza rejestru.
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetLifetimeService()	Przestarzałe. Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia. (Odziedziczone po MarshalByRefObject)
GetSubKeyNames()	Pobiera tablicę ciągów zawierających wszystkie nazwy podklucza.
GetType()	Type Pobiera bieżące wystąpienie. (Odziedziczone po Object)
GetValue(String)	Pobiera wartość skojarzoną z podaną nazwą. Zwraca wartość null , jeśli para nazwa/wartość nie istnieje w rejestrze.
GetValue(String, Object)	Pobiera wartość skojarzoną z podaną nazwą. Jeśli nazwa nie zostanie znaleziona, zwraca podaną wartość domyślną.
GetValue(String, Object, RegistryValueOptions)	Pobiera wartość skojarzona z określoną nazwą i opcjami pobierania. Jeśli nazwa nie zostanie znaleziona, zwraca podaną wartość domyślną.
GetValueKind(String)	Pobiera typ danych rejestru wartości skojarzonej z określoną nazwą.
GetValueNames()	Pobiera tablicę ciągów zawierających wszystkie nazwy wartości skojarzone z tym kluczem.
InitializeLifetimeService()	Przestarzałe. Uzyskuje obiekt usługi okresu istnienia, aby kontrolować zasady okresu istnienia dla tego wystąpienia. (Odziedziczone po MarshalByRefObject)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
MemberwiseClone(Boolean)	Tworzy płytkią kopię bieżącego MarshalByRefObject obiektu. (Odziedziczone po MarshalByRefObject)
OpenBaseKey(RegistryHive, RegistryView)	Otwiera nowy RegistryKey , który reprezentuje żądany klucz na maszynie lokalnej z określonym widokiem.
OpenRemoteBaseKey(RegistryHive, String)	Otwiera nowy RegistryKey , który reprezentuje żądany klucz na maszynie zdalnej.
OpenRemoteBaseKey(RegistryHive, String, RegistryView)	Otwiera nowy klucz rejestru reprezentujący żądany klucz na maszynie zdalnej z określonym widokiem.
OpenSubKey(String)	Pobiera podklucz jako tylko do odczytu.
OpenSubKey(String, Boolean)	Pobiera określony podklucz i określa, czy dostęp do zapisu ma być stosowany do klucza.
OpenSubKey(String, RegistryKeyPermissionCheck)	Pobiera określony podklucz na potrzeby dostępu do odczytu lub odczytu/zapisu.
OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights)	Pobiera określony podklucz dostępu do odczytu lub odczytu/zapisu, żądając określonych praw dostępu.
OpenSubKey(String, RegistryRights)	Pobiera podklucz z określoną nazwą i prawami dostępu. Dostępne od .NET Framework 4.6.
SetAccessControl(RegistrySecurity)	Stosuje zabezpieczenia kontroli dostępu systemu Windows do istniejącego klucza rejestru.
SetValue(String, Object)	Ustawia określoną parę nazw/wartości.
SetValue(String, Object, RegistryValueKind)	Ustawia wartość pary nazw/wartości w kluczu rejestru przy użyciu określonego typu danych rejestru.
ToString()	Pobiera reprezentację ciągu tego klucza.

Metody rozszerzania

Zobacz też

• Registry
• RegistryHive