RegistryKey Klasa

Definicja

Przestrzeń nazw:

Microsoft.Win32

Zestaw:

Microsoft.Win32.Registry.dll

Reprezentuje węzeł na poziomie klucza w rejestrze 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 RegistryKeyklasy , użyj jednego ze statycznych elementów członkowskich Registry 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żna

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

Klucze rejestru są podstawową jednostką organizacji w rejestrze i można je porównać z folderami w Eksploratorze plików. Określony klucz może mieć podklucze, podobnie jak folder może mieć podfoldery. Każdy klucz można usunąć, o ile użytkownik ma odpowiednie uprawnienia do tego celu, a klucz nie jest kluczem podstawowym ani na poziomie bezpośrednio pod kluczem podstawowym. Każdy klucz może również mieć wiele skojarzonych z nim wartości (wartość można porównać z plikiem), które są używane do przechowywania informacji — na przykład informacje 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 swojej firmy pod RegistryKey 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.

Caution

Nie ujawniaj RegistryKey obiektów w taki sposób, że złośliwy program może utworzyć tysiące bez znaczenia podklucze lub pary klucz/wartość. Na przykład nie zezwalaj obiektom wywołującym na wprowadzanie dowolnych kluczy lub wartości.

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

Właściwości

Nazwa	Opis
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

Nazwa	Opis
Close()	Zamyka klucz i opróżnia go na dysk, jeśli jego zawartość została zmodyfikowana.
CreateSubKey(String, Boolean, RegistryOptions)	Tworzy nowy podklucz lub otwiera istniejący podklucz z określonym dostępem. Dostępne począwszy od platformy .NET Framework 4.6.
CreateSubKey(String, Boolean)	Tworzy nowy podklucz lub otwiera istniejący podklucz z określonym dostępem. Dostępne począwszy od platformy .NET Framework 4.6.
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, RegistryOptions)	Tworzy podklucz lub otwiera podklucz na potrzeby dostępu do zapisu przy użyciu określonych opcji sprawdzania uprawnień i 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.
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)	Tworzy nowy podklucz lub otwiera istniejący podklucz na potrzeby dostępu do zapisu.
DeleteSubKey(String, Boolean)	Usuwa określony podklucz i określa, czy wyjątek jest zgłaszany, jeśli podklucz nie zostanie znaleziony.
DeleteSubKey(String)	Usuwa określony podklucz.
DeleteSubKeyTree(String, Boolean)	Usuwa określony podklucz i wszystkie podrzędne podklucze cyklicznie 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.
DeleteValue(String, Boolean)	Usuwa określoną wartość z tego klucza i określa, czy wyjątek jest zgłaszany, jeśli wartość nie zostanie znaleziona.
DeleteValue(String)	Usuwa określoną wartość z tego klucza.
Dispose()	Zwalnia wszystkie zasoby używane przez bieżące wystąpienie RegistryKey klasy.
Equals(Object)	Określa, czy określony obiekt jest równy bieżącemu obiektowi. (Odziedziczone po Object)
Flush()	Zapisuje wszystkie atrybuty określonego otwartego klucza rejestru w rejestrze.
FromHandle(SafeRegistryHandle, RegistryView)	Tworzy klucz rejestru na podstawie określonego ustawienia dojścia i widoku rejestru.
FromHandle(SafeRegistryHandle)	Tworzy klucz rejestru na podstawie określonego dojścia.
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, która zawiera wszystkie nazwy podklucza.
GetType()	Pobiera Type bieżącego wystąpienia. (Odziedziczone po Object)
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ą.
GetValue(String, Object)	Pobiera wartość skojarzona z określoną nazwą. Jeśli nazwa nie zostanie znaleziona, zwraca podaną wartość domyślną.
GetValue(String)	Pobiera wartość skojarzona z określoną nazwą. Zwraca wartość null , jeśli para nazwa/wartość nie istnieje w rejestrze.
GetValueKind(String)	Pobiera typ danych rejestru wartości skojarzonej z określoną nazwą.
GetValueNames()	Pobiera tablicę ciągów, która zawiera wszystkie nazwy wartości skojarzone z tym kluczem.
InitializeLifetimeService()	Przestarzałe. Uzyskuje obiekt usługi okresu istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia. (Odziedziczone po MarshalByRefObject)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Object. (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 komputerze lokalnym z określonym widokiem.
OpenRemoteBaseKey(RegistryHive, String, RegistryView)	Otwiera nowy klucz rejestru reprezentujący żądany klucz na maszynie zdalnej z określonym widokiem.
OpenRemoteBaseKey(RegistryHive, String)	Otwiera nowy RegistryKey , który reprezentuje żądany klucz na maszynie zdalnej.
OpenSubKey(String, Boolean)	Pobiera określony podklucz i określa, czy dostęp do zapisu ma być stosowany do klucza.
OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights)	Pobiera określony podklucz dostępu do odczytu lub odczytu/zapisu, żądając określonych praw dostępu.
OpenSubKey(String, RegistryKeyPermissionCheck)	Pobiera określony podklucz na potrzeby dostępu do odczytu lub odczytu/zapisu.
OpenSubKey(String, RegistryRights)	Pobiera podklucz z określoną nazwą i prawami dostępu. Dostępne począwszy od platformy .NET Framework 4.6.
OpenSubKey(String)	Pobiera podklucz jako tylko do odczytu.
SetAccessControl(RegistrySecurity)	Stosuje Windows zabezpieczenia kontroli dostępu do istniejącego klucza rejestru.
SetValue(String, Object, RegistryValueKind)	Ustawia wartość pary nazwa/wartość w kluczu rejestru przy użyciu określonego typu danych rejestru.
SetValue(String, Object)	Ustawia określoną parę nazw/wartości.
ToString()	Pobiera reprezentację ciągu tego klucza.

Zobacz też

• Registry
• RegistryHive