RegistryKey Klasa

Definicja

Reprezentuje węzeł poziomu klucza w rejestrze systemu Windows.Represents a key-level node in the Windows registry. Ta klasa jest hermetyzacją rejestru.This class is a registry encapsulation.

public ref class RegistryKey sealed : MarshalByRefObject, IDisposable
public ref class RegistryKey sealed : IDisposable
public sealed class RegistryKey : MarshalByRefObject, IDisposable
public sealed class RegistryKey : IDisposable
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class RegistryKey : MarshalByRefObject, IDisposable
type RegistryKey = class
    inherit MarshalByRefObject
    interface IDisposable
type RegistryKey = class
    interface IDisposable
[<System.Runtime.InteropServices.ComVisible(true)>]
type RegistryKey = class
    inherit MarshalByRefObject
    interface IDisposable
Public NotInheritable Class RegistryKey
Inherits MarshalByRefObject
Implements IDisposable
Public NotInheritable Class RegistryKey
Implements IDisposable
Dziedziczenie
Dziedziczenie
RegistryKey
Atrybuty
Implementuje

Przykłady

Poniższy przykład kodu pokazuje, jak utworzyć podklucz w obszarze HKEY_CURRENT_USER, manipulować jego zawartością, a następnie usunąć podklucz.The following code example shows how to create a subkey under HKEY_CURRENT_USER, manipulate its contents, and then delete the subkey.

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 elementu RegistryKey , użyj jednego z statycznych elementów członkowskich Registry klasy.To get an instance of RegistryKey, use one of the static members of the Registry class.

Rejestr działa jako centralne repozytorium informacji dla systemu operacyjnego i aplikacji na komputerze.The registry acts as a central repository of information for the operating system and the applications on a computer. Rejestr jest zorganizowany w formacie hierarchicznym na podstawie logicznej kolejności elementów przechowywanych w nim (Sprawdź Registry elementy na poziomie podstawowym w tej hierarchii).The registry is organized in a hierarchical format, based on a logical ordering of the elements stored within it (please see Registry for the base-level items in this hierarchy). Podczas zapisywania informacji w rejestrze wybierz odpowiednią lokalizację na podstawie typu przechowywanych informacji.When storing information in the registry, select the appropriate location based on the type of information being stored. Pamiętaj, aby uniknąć niszczenia informacji utworzonych przez inne aplikacje, ponieważ może to spowodować nieoczekiwane zachowanie tych aplikacji, a także mieć niekorzystny wpływ na swoją aplikację.Be sure to avoid destroying information created by other applications, because this can cause those applications to exhibit unexpected behavior, and can also have an adverse effect upon your own application.

Ważne

Ten typ implementuje IDisposable interfejs.This type implements the IDisposable interface. Po zakończeniu korzystania z typu należy usunąć jego wartość bezpośrednio lub pośrednio.When you have finished using the type, you should dispose of it either directly or indirectly. Aby usunąć typ bezpośrednio, wywołaj jego Dispose metodę w try / catch bloku.To dispose of the type directly, call its Dispose method in a try/catch block. Aby usunąć go pośrednio, użyj konstrukcji języka, takiej jak using (w języku C#) lub Using (w Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Aby uzyskać więcej informacji, zobacz sekcję "Używanie obiektu implementującego interfejs IDisposable" w temacie dotyczącym IDisposable interfejsu.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Klucze rejestru są podstawową jednostką organizacji w rejestrze i można je porównać z folderami w Eksploratorze plików.Registry keys are the base unit of organization in the registry, and can be compared to folders in File Explorer. Określony klucz może mieć podklucze, podobnie jak folder może mieć podfoldery.A particular key can have subkeys, just as a folder can have subfolders. Każdy klucz może zostać usunięty, o ile użytkownik ma odpowiednie uprawnienia, a klucz nie jest kluczem podstawowym lub na poziomie bezpośrednio w kluczach podstawowych.Each key can be deleted, as long as the user has the appropriate permissions to do so, and the key is not a base key or at the level directly under the base keys. Dla każdego klucza można także skojarzyć wiele 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.Each key can also have multiple values associated with it (a value can be compared to a file), which are used to store the information - for example, information about an application installed on the computer. Każda wartość zawiera jedną konkretną informację, którą można pobrać lub zaktualizować, gdy jest to wymagane.Each value holds one particular piece of information, which can be retrieved or updated when required. Na przykład możesz utworzyć RegistryKey dla swojej firmy w kluczu HKEY_LOCAL_MACHINE\Software, a następnie podklucz dla każdej aplikacji tworzonego przez firmę.For instance, you can create a RegistryKey for your company, under the key HKEY_LOCAL_MACHINE\Software, and then a subkey for each application that your company creates. Każdy podklucz zawiera informacje specyficzne dla tej aplikacji, takie jak ustawienia koloru, położenie i rozmiar ekranu lub rozpoznawane rozszerzenia plików.Each subkey holds the information specific to that application, such as color settings, screen location and size, or recognized file extensions.

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 informacji o krytycznych aplikacjach.Note that information stored in the registry is available to other applications and users, and therefore should not be used to store security data or critical application information.

Przestroga

Nie ujawniaj RegistryKey obiektów w taki sposób, aby złośliwy program mógł utworzyć tysiące podkluczy i par klucz/wartość.Do not expose RegistryKey objects in such a way that a malicious program could create thousands of meaningless subkeys or key/value pairs. Na przykład nie wolno pozwalać obiektom wywołującym na wprowadzanie umownych kluczy ani wartości.For example, do not allow callers to enter arbitrary keys or values.

Począwszy od .NET Framework 4, Długość klucza rejestru nie jest już ograniczona do 255 znaków.Starting in the .NET Framework 4, the length of a registry key is no longer limited to 255 characters.

Właściwości

Handle

Pobiera SafeRegistryHandle obiekt reprezentujący klucz rejestru, który jest obecnie hermetyzowany z bieżącego RegistryKey obiektu.Gets a SafeRegistryHandle object that represents the registry key that the current RegistryKey object encapsulates.

Name

Pobiera nazwę klucza.Retrieves the name of the key.

SubKeyCount

Pobiera liczbę podkluczy bieżącego klucza.Retrieves the count of subkeys of the current key.

ValueCount

Pobiera liczbę wartości w kluczu.Retrieves the count of values in the key.

View

Pobiera widok, który został użyty do utworzenia klucza rejestru.Gets the view that was used to create the registry key.

Metody

Close()

Zamyka klucz i opróżnia go na dysk, jeśli jego zawartość została zmodyfikowana.Closes the key and flushes it to disk if its contents have been modified.

CreateObjRef(Type)

Tworzy obiekt, który zawiera wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikacji z obiektem zdalnym.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Odziedziczone po MarshalByRefObject)
CreateSubKey(String)

Tworzy nowy podklucz lub otwiera istniejący podklucz dostępu do zapisu.Creates a new subkey or opens an existing subkey for write access.

CreateSubKey(String, Boolean)

Tworzy nowy podklucz lub otwiera istniejący podklucz o określonym dostępie.Creates a new subkey or opens an existing subkey with the specified access. Dostępne począwszy od .NET Framework 4,6.Available starting with .NET Framework 4.6.

CreateSubKey(String, Boolean, RegistryOptions)

Tworzy nowy podklucz lub otwiera istniejący podklucz o określonym dostępie.Creates a new subkey or opens an existing subkey with the specified access. Dostępne począwszy od .NET Framework 4,6.Available starting with .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ń.Creates a new subkey or opens an existing subkey for write access, using the specified permission check option.

CreateSubKey(String, RegistryKeyPermissionCheck, RegistryOptions)

Tworzy podklucz lub otwiera podklucz dostępu do zapisu przy użyciu określonych opcji sprawdzania uprawnień i rejestru.Creates a subkey or opens a subkey for write access, using the specified permission check and registry options.

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.Creates a subkey or opens a subkey for write access, using the specified permission check option, registry option, and registry security.

CreateSubKey(String, RegistryKeyPermissionCheck, RegistrySecurity)

Tworzy nowy podklucz lub otwiera istniejący podklucz dla dostępu do zapisu, przy użyciu określonej opcji sprawdzania uprawnień i zabezpieczeń rejestru.Creates a new subkey or opens an existing subkey for write access, using the specified permission check option and registry security.

DeleteSubKey(String)

Usuwa określony podklucz.Deletes the specified subkey.

DeleteSubKey(String, Boolean)

Usuwa określony podklucz i określa, czy wyjątek jest zgłaszany, jeśli nie można odnaleźć podklucza.Deletes the specified subkey, and specifies whether an exception is raised if the subkey is not found.

DeleteSubKeyTree(String)

Usuwa podkluczy i wszystkie podrzędne podklucze podrzędny.Deletes a subkey and any child subkeys recursively.

DeleteSubKeyTree(String, Boolean)

Usuwa określony podklucz i wszystkie podrzędne podklucze podrzędny i określa, czy wyjątek jest zgłaszany, jeśli nie można odnaleźć podklucza.Deletes the specified subkey and any child subkeys recursively, and specifies whether an exception is raised if the subkey is not found.

DeleteValue(String)

Usuwa określoną wartość z tego klucza.Deletes the specified value from this key.

DeleteValue(String, Boolean)

Usuwa określoną wartość z tego klucza i określa, czy wyjątek jest wywoływany, jeśli wartość nie zostanie znaleziona.Deletes the specified value from this key, and specifies whether an exception is raised if the value is not found.

Dispose()

Zwalnia wszystkie zasoby używane przez bieżące wystąpienie klasy RegistryKey.Releases all resources used by the current instance of the RegistryKey class.

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
Finalize()

Zamyka klucz i opróżnia go na dysk, jeśli zawartość została zmodyfikowana.Closes the key and flushes it to disk if the contents have been modified.

Flush()

Zapisuje wszystkie atrybuty określonego otwartego klucza rejestru w rejestrze.Writes all the attributes of the specified open registry key into the registry.

FromHandle(SafeRegistryHandle)

Tworzy klucz rejestru z określonego dojścia.Creates a registry key from a specified handle.

FromHandle(SafeRegistryHandle, RegistryView)

Tworzy klucz rejestru z określonego dojścia i ustawienia widoku rejestru.Creates a registry key from a specified handle and registry view setting.

GetAccessControl()

Zwraca zabezpieczenia kontroli dostępu dla bieżącego klucza rejestru.Returns the access control security for the current registry key.

GetAccessControl(AccessControlSections)

Zwraca określone sekcje zabezpieczeń kontroli dostępu dla bieżącego klucza rejestru.Returns the specified sections of the access control security for the current registry key.

GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetLifetimeService()
Nieaktualne.

Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
GetSubKeyNames()

Pobiera tablicę ciągów, która zawiera wszystkie nazwy podkluczy.Retrieves an array of strings that contains all the subkey names.

GetType()

Pobiera Type bieżące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
GetValue(String)

Pobiera wartość skojarzoną z podaną nazwą.Retrieves the value associated with the specified name. Zwraca wartość null , jeśli para nazwa/wartość nie istnieje w rejestrze.Returns null if the name/value pair does not exist in the registry.

GetValue(String, Object)

Pobiera wartość skojarzoną z podaną nazwą.Retrieves the value associated with the specified name. Jeśli nazwa nie zostanie znaleziona, zwraca wartość domyślną, którą zapewniasz.If the name is not found, returns the default value that you provide.

GetValue(String, Object, RegistryValueOptions)

Pobiera wartość skojarzoną z określoną nazwą i opcjami pobierania.Retrieves the value associated with the specified name and retrieval options. Jeśli nazwa nie zostanie znaleziona, zwraca wartość domyślną, którą zapewniasz.If the name is not found, returns the default value that you provide.

GetValueKind(String)

Pobiera typ danych rejestru z wartości skojarzonej z określoną nazwą.Retrieves the registry data type of the value associated with the specified name.

GetValueNames()

Pobiera tablicę ciągów, która zawiera wszystkie nazwy wartości skojarzone z tym kluczem.Retrieves an array of strings that contains all the value names associated with this key.

InitializeLifetimeService()
Nieaktualne.

Uzyskuje obiekt usługi istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia.Obtains a lifetime service object to control the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
MemberwiseClone()

Tworzy skróconą kopię bieżącego elementu Object .Creates a shallow copy of the current Object.

(Odziedziczone po Object)
MemberwiseClone(Boolean)

Tworzy skróconą kopię bieżącego MarshalByRefObject obiektu.Creates a shallow copy of the current MarshalByRefObject object.

(Odziedziczone po MarshalByRefObject)
OpenBaseKey(RegistryHive, RegistryView)

Otwiera nowy RegistryKey , który reprezentuje żądany klucz na komputerze lokalnym z określonym widokiem.Opens a new RegistryKey that represents the requested key on the local machine with the specified view.

OpenRemoteBaseKey(RegistryHive, String)

Otwiera nowy RegistryKey , który reprezentuje żądany klucz na komputerze zdalnym.Opens a new RegistryKey that represents the requested key on a remote machine.

OpenRemoteBaseKey(RegistryHive, String, RegistryView)

Otwiera nowy klucz rejestru reprezentujący żądany klucz na maszynie zdalnej z określonym widokiem.Opens a new registry key that represents the requested key on a remote machine with the specified view.

OpenSubKey(String)

Pobiera podklucz jako tylko do odczytu.Retrieves a subkey as read-only.

OpenSubKey(String, Boolean)

Pobiera określony podklucz i określa, czy dostęp do zapisu ma być stosowany do klucza.Retrieves a specified subkey, and specifies whether write access is to be applied to the key.

OpenSubKey(String, RegistryKeyPermissionCheck)

Pobiera określony podklucz dla dostępu do odczytu lub odczytu i zapisu.Retrieves the specified subkey for read or read/write access.

OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights)

Pobiera określony podklucz dla dostępu do odczytu lub odczytu/zapisu, żądając określonych praw dostępu.Retrieves the specified subkey for read or read/write access, requesting the specified access rights.

OpenSubKey(String, RegistryRights)

Pobiera podklucz z określoną nazwą i prawami dostępu.Retrieves a subkey with the specified name and access rights. Dostępne począwszy od .NET Framework 4,6.Available starting with .NET Framework 4.6.

SetAccessControl(RegistrySecurity)

Stosuje zabezpieczenia kontroli dostępu systemu Windows do istniejącego klucza rejestru.Applies Windows access control security to an existing registry key.

SetValue(String, Object)

Ustawia określoną parę nazwa/wartość.Sets the specified name/value pair.

SetValue(String, Object, RegistryValueKind)

Ustawia wartość pary nazwa/wartość w kluczu rejestru przy użyciu określonego typu danych rejestru.Sets the value of a name/value pair in the registry key, using the specified registry data type.

ToString()

Pobiera ciąg reprezentujący ten klucz.Retrieves a string representation of this key.

ToString()

Zwraca ciąg reprezentujący bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)

Jawne implementacje interfejsu

IDisposable.Dispose()

Ten interfejs API obsługuje infrastrukturę produktu i nie jest przeznaczony do użycia bezpośrednio z poziomu kodu.

Wykonuje Close() dla bieżącego klucza.Performs a Close() on the current key.

Metody rozszerzania

GetAccessControl(RegistryKey)

Zwraca informacje o zabezpieczeniach klucza rejestru.Returns the security information of a registry key.

GetAccessControl(RegistryKey, AccessControlSections)

Zwraca informacje o zabezpieczeniach klucza rejestru.Returns the security information of a registry key.

SetAccessControl(RegistryKey, RegistrySecurity)

Zmienia atrybuty zabezpieczeń istniejącego klucza rejestru.Changes the security attributes of an existing registry key.

Dotyczy

Zobacz też