RegistryKey Klasse

Definition

Namespace:

Microsoft.Win32

Assembly:

Microsoft.Win32.Registry.dll

Stellt einen Knoten auf Schlüsselebene in der Windows-Registrierung dar. Diese Klasse ist eine Kapselung der Registrierung.

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

Vererbung

Object

MarshalByRefObject

RegistryKey

Implementiert

IDisposable

Beispiele

Das folgende Codebeispiel zeigt, wie Sie einen Unterschlüssel unter HKEY_CURRENT_USER erstellen, dessen Inhalt bearbeiten und dann den Unterschlüssel löschen.

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

Hinweise

Um eine instance von RegistryKeyabzurufen, verwenden Sie eines der statischen Member der Registry -Klasse.

Die Registrierung fungiert als zentrales Informationsrepository für das Betriebssystem und die Anwendungen auf einem Computer. Die Registrierung ist in einem hierarchischen Format organisiert, basierend auf einer logischen Reihenfolge der darin gespeicherten Elemente (siehe Registry Elemente auf Basisebene in dieser Hierarchie). Wählen Sie beim Speichern von Informationen in der Registrierung den entsprechenden Speicherort basierend auf dem Typ der gespeicherten Informationen aus. Vermeiden Sie die Zerstörung von Informationen, die von anderen Anwendungen erstellt wurden, da dies dazu führen kann, dass diese Anwendungen unerwartetes Verhalten aufweisen und sich auch negativ auf Ihre eigene Anwendung auswirken können.

Wichtig

Dieser Typ implementiert die IDisposable-Schnittstelle. Nach Abschluss der Verwendung sollten Sie den Typ entweder direkt oder indirekt löschen. Zum direkten Löschen des Typs rufen Sie seine Dispose-Methode in einem try/catch-Block auf. Zum indirekten Löschen verwenden Sie ein Sprachkonstrukt wie using (in C#) oder Using (in Visual Basic). Weitere Informationen finden Sie im Abschnitt „Verwenden eines Objekts, das IDisposable implementiert“ des Themas „Die IDisposable-Schnittstelle“.

Registrierungsschlüssel sind die Basiseinheit von organization in der Registrierung und können mit Ordnern in Explorer verglichen werden. Ein bestimmter Schlüssel kann Unterschlüssel aufweisen, genau wie ein Ordner Unterordner enthalten kann. Jeder Schlüssel kann gelöscht werden, solange der Benutzer über die entsprechenden Berechtigungen verfügt und der Schlüssel kein Basisschlüssel oder auf der Ebene direkt unter den Basisschlüsseln ist. Jedem Schlüssel können auch mehrere Werte zugeordnet sein (ein Wert kann mit einer Datei verglichen werden), die zum Speichern der Informationen verwendet werden, z. B. Informationen zu einer auf dem Computer installierten Anwendung. Jeder Wert enthält eine bestimmte Information, die bei Bedarf abgerufen oder aktualisiert werden kann. Für instance können Sie unter RegistryKey dem Schlüssel HKEY_LOCAL_MACHINE\Software einen für Ihr Unternehmen und dann einen Unterschlüssel für jede Anwendung erstellen, die Ihr Unternehmen erstellt. Jeder Unterschlüssel enthält die spezifischen Informationen für diese Anwendung, z. B. Farbeinstellungen, Bildschirmspeicherort und -größe oder erkannte Dateierweiterungen.

Beachten Sie, dass die in der Registrierung gespeicherten Informationen für andere Anwendungen und Benutzer verfügbar sind und daher nicht zum Speichern von Sicherheitsdaten oder kritischen Anwendungsinformationen verwendet werden sollten.

Achtung

Machen Sie Objekte nicht so verfügbar RegistryKey , dass ein schadhaftes Programm Tausende von bedeutungslosen Unterschlüsseln oder Schlüssel-Wert-Paaren erstellen könnte. Lassen Sie beispielsweise nicht zu, dass Aufrufer beliebige Schlüssel oder Werte eingeben.

Ab .NET Framework 4 ist die Länge eines Registrierungsschlüssels nicht mehr auf 255 Zeichen beschränkt.

Eigenschaften

Handle	Ruft ein SafeRegistryHandle-Objekt ab, das den Registrierungsschlüssel darstellt, der vom aktuellen RegistryKey-Objekt gekapselt wird.
Name	Ruft den Namen des Schlüssels ab.
SubKeyCount	Ruft die Anzahl der Unterschlüssel des aktuellen Schlüssels ab.
ValueCount	Ruft die Anzahl der Werte im Schlüssel ab.
View	Ruft die Ansicht ab, mit der der Registrierungsschlüssel erstellt wurde.

Methoden

Close()	Schließt den Schlüssel und schreibt diesen auf den Datenträger weg, sofern der Inhalt verändert wurde.
CreateObjRef(Type)	Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Geerbt von MarshalByRefObject)
CreateSubKey(String)	Erstellt einen neuen Unterschlüssel oder öffnet einen vorhandenen Unterschlüssel für Schreibzugriff.
CreateSubKey(String, Boolean)	Erstellt einen neuen Unterschlüssel oder öffnet einen vorhandenen Unterschlüssel mit dem angegebenen Zugriffsmodus. Verfügbar ab .NET Framework 4.6.
CreateSubKey(String, Boolean, RegistryOptions)	Erstellt einen neuen Unterschlüssel oder öffnet einen vorhandenen Unterschlüssel mit dem angegebenen Zugriffsmodus. Verfügbar ab .NET Framework 4.6.
CreateSubKey(String, RegistryKeyPermissionCheck)	Erstellt einen neuen Unterschlüssel oder öffnet einen vorhandenen Unterschlüssel für Schreibzugriff unter Verwendung der angegebenen Berechtigungsprüfungsoption.
CreateSubKey(String, RegistryKeyPermissionCheck, RegistryOptions)	Erstellt oder öffnet einen Unterschlüssel für Schreibzugriff unter Verwendung der angegebenen Berechtigungsprüfungs- und Registrierungsoptionen.
CreateSubKey(String, RegistryKeyPermissionCheck, RegistryOptions, RegistrySecurity)	Erstellt oder öffnet einen Unterschlüssel für Schreibzugriff unter Verwendung der angegebenen Berechtigungsprüfungsoption, Registrierungsoption und Registrierungssicherheit.
CreateSubKey(String, RegistryKeyPermissionCheck, RegistrySecurity)	Erstellt einen neuen Unterschlüssel oder öffnet einen vorhandenen Unterschlüssel für Schreibzugriff unter Verwendung der angegebenen Berechtigungsprüfungsoption und der Registrierungssicherheit.
DeleteSubKey(String)	Löscht den angegebenen Unterschlüssel.
DeleteSubKey(String, Boolean)	Löscht den angegebenen Unterschlüssel und gibt an, ob eine Ausnahme ausgelöst wird, wenn der Unterschlüssel nicht gefunden wird.
DeleteSubKeyTree(String)	Löscht einen Unterschlüssel und alle untergeordneten Unterschlüssel rekursiv.
DeleteSubKeyTree(String, Boolean)	Löscht den angegebenen Unterschlüssel und untergeordnete Unterschlüssel rekursiv und gibt an, ob eine Ausnahme ausgelöst wird, wenn der Unterschlüssel nicht gefunden wird.
DeleteValue(String)	Löscht den angegebenen Wert aus diesem Schlüssel.
DeleteValue(String, Boolean)	Löscht den angegebenen Wert aus diesem Schlüssel und gibt an, ob eine Ausnahme ausgelöst wird, wenn der Wert nicht gefunden wird.
Dispose()	Gibt alle von der aktuellen Instanz der RegistryKey-Klasse verwendeten Ressourcen frei.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
Flush()	Schreibt alle Attribute des angegebenen geöffneten Registrierungsschlüssels in die Registrierung.
FromHandle(SafeRegistryHandle)	Erstellt einen Registrierungsschlüssel aus einem angegebenen Handle.
FromHandle(SafeRegistryHandle, RegistryView)	Erstellt einen Registrierungsschlüssel aus einem angegebenen Handle und einer Registrierungsansichtseinstellung.
GetAccessControl()	Gibt die Zugriffssteuerungssicherheit für den aktuellen Registrierungsschlüssel zurück.
GetAccessControl(AccessControlSections)	Gibt die angegebenen Abschnitte der Zugriffssteuerungssicherheit für den aktuellen Registrierungsschlüssel zurück.
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetSubKeyNames()	Ruft ein Array von Zeichenfolgen mit den Namen aller Unterschlüssel ab.
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
GetValue(String)	Ruft den Wert ab, der dem angegebenen Namen zugeordnet ist. Gibt null zurück, wenn das Name-Wert-Paar in der Registrierung nicht vorhanden ist.
GetValue(String, Object)	Ruft den Wert ab, der dem angegebenen Namen zugeordnet ist. Wenn der Name nicht gefunden wird, wird der von Ihnen bereitgestellte Standardwert zurückgegeben.
GetValue(String, Object, RegistryValueOptions)	Ruft den Wert ab, der dem angegebenen Namen und den Abrufoptionen zugeordnet ist. Wenn der Name nicht gefunden wird, wird der von Ihnen bereitgestellte Standardwert zurückgegeben.
GetValueKind(String)	Ruft den Registrierungsdatentyp des Werts ab, der dem angegebenen Namen zugeordnet ist.
GetValueNames()	Ruft ein Array von Zeichenfolgen ab, das die Namen aller diesem Schlüssel zugeordneten Werte enthält.
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab. (Geerbt von MarshalByRefObject)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
MemberwiseClone(Boolean)	Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject)
OpenBaseKey(RegistryHive, RegistryView)	Öffnet einen neuen RegistryKey, der den angeforderten Schlüssel auf dem lokalen Computer mit der angegebenen Ansicht darstellt.
OpenRemoteBaseKey(RegistryHive, String)	Öffnet einen neuen RegistryKey, der den angeforderten Schlüssel für einen Remotecomputer darstellt.
OpenRemoteBaseKey(RegistryHive, String, RegistryView)	Öffnet einen neuen Registrierungsschlüssel, der den angeforderten Schlüssel auf einem Remotecomputer mit der angegebenen Ansicht darstellt.
OpenSubKey(String)	Ruft einen Unterschlüssel als schreibgeschützt ab.
OpenSubKey(String, Boolean)	Ruft einen angegebenen Unterschlüssel ab und gibt an, ob Schreibzugriff auf den Schlüssel angewendet werden soll.
OpenSubKey(String, RegistryKeyPermissionCheck)	Ruft den angegebenen Unterschlüssel für Lesezugriff oder Lese-/Schreibzugriff ab.
OpenSubKey(String, RegistryKeyPermissionCheck, RegistryRights)	Ruft den angegebenen Unterschlüssel für Lesezugriff oder Lese-/Schreibzugriff ab, und fordert die angegebenen Zugriffsrechte an.
OpenSubKey(String, RegistryRights)	Ruft einen Unterschlüssel mit dem angegebenen Namen und Zugriffsrechten ab. Verfügbar ab .NET Framework 4.6.
SetAccessControl(RegistrySecurity)	Übernimmt Windows-Zugriffssteuerungssicherheit für einen vorhandenen Registrierungsschlüssel.
SetValue(String, Object)	Legt das angegebene Name-Wert-Paar fest.
SetValue(String, Object, RegistryValueKind)	Legt mithilfe des angegebenen Registrierungsdatentyps den Wert eines Name-Wert-Paars im Registrierungsschlüssel fest.
ToString()	Ruft eine Zeichenfolgenentsprechung dieses Schlüssels ab.

Erweiterungsmethoden

Weitere Informationen

• Registry
• RegistryHive