RegistryKeyPermissionCheck Enumeration

Definition

Namespace:

Microsoft.Win32

Assembly:

Microsoft.Win32.Registry.dll

Gibt an, ob beim Öffnen von Registrierungsschlüsseln und beim Zugreifen auf deren Name-Wert-Paare Sicherheitsüberprüfungen durchgeführt werden.

public enum class RegistryKeyPermissionCheck

public enum RegistryKeyPermissionCheck

type RegistryKeyPermissionCheck = 

Public Enum RegistryKeyPermissionCheck

Vererbung

Object

ValueType

Enum

RegistryKeyPermissionCheck

Felder

Default	0	Der Registrierungsschlüssel erbt den Modus von seinem übergeordneten Element. Beim Versuch, auf Unterschlüssel oder Werte zuzugreifen, werden Sicherheitsüberprüfungen durchgeführt, sofern das übergeordnete Element nicht mit dem ReadSubTree-Modus oder dem ReadWriteSubTree-Modus geöffnet wurde.
ReadSubTree	1	Sicherheitsüberprüfungen werden nicht durchgeführt, wenn auf Unterschlüssel oder Werte zugegriffen wird. Beim Versuch, den aktuellen Schlüssel zu öffnen, wird eine Sicherheitsüberprüfung durchgeführt, sofern das übergeordnete Element nicht mit ReadSubTree oder ReadWriteSubTree geöffnet wurde.
ReadWriteSubTree	2	Sicherheitsüberprüfungen werden nicht durchgeführt, wenn auf Unterschlüssel oder Werte zugegriffen wird. Beim Versuch, den aktuellen Schlüssel zu öffnen, wird eine Sicherheitsüberprüfung durchgeführt, sofern das übergeordnete Element nicht mit ReadWriteSubTree geöffnet wurde.

Beispiele

Im folgenden Codebeispiel wird ein Unterschlüssel mit 100 Schlüssel-Wert-Paaren erstellt und geschlossen. Das Beispiel öffnet den Unterschlüssel mit Standard und zeichnet die Zeit auf, die zum Lesen aller Werte benötigt wird. Anschließend öffnet das Beispiel den Unterschlüssel mit ReadSubTree und zeichnet die Zeit auf, die zum Lesen aller Werte benötigt wird. Schließlich wird im Beispiel die prozentuale Verbesserung berechnet und angezeigt.

using System;
using Microsoft.Win32;
using System.Diagnostics;

public class Example
{
    public static void Main()
    {
        const int LIMIT = 100;
        RegistryKey cu = Registry.CurrentUser;
        const string testKey = "RegistryKeyPermissionCheckExample";

        Console.WriteLine("Generating {0} key/value pairs.", LIMIT);
        RegistryKey rk = cu.CreateSubKey(testKey);
        for (int i = 0; i < LIMIT; i++)
        {
            rk.SetValue("Key" + i, i);
        }

        rk.Close();

        Stopwatch s = new Stopwatch();

        // On the default setting, security is checked every time
        // a key/value pair is read.
        rk = cu.OpenSubKey(testKey, RegistryKeyPermissionCheck.Default);

        s.Start();
        for (int i = 0; i < LIMIT; i++)
        {
            rk.GetValue("Key" + i, i);
        }
        s.Stop();
        rk.Close();
        long delta1 = s.ElapsedTicks;

        s.Reset();

        // When the key is opened with ReadSubTree, security is
        // not checked when the values are read.
        rk = cu.OpenSubKey(testKey, RegistryKeyPermissionCheck.ReadSubTree);

        s.Start();
        for (int i = 0; i < LIMIT; i++)
        {
            rk.GetValue("Key" + i, i);
        }
        s.Stop();
        rk.Close();
        long delta2 = s.ElapsedTicks;

        double faster = (double) (delta1 - delta2) / (double) delta1;
        Console.WriteLine("ReadSubTree is {0}% faster for {1} values.",
            (faster * 100).ToString("0.0"), LIMIT);

        cu.DeleteSubKey(testKey);
    }
}

/* This code example produces output similar to the following:

Generating 100 key/value pairs.
ReadSubTree is 23.4% faster for 100 values.
 */

Imports Microsoft.Win32
Imports System.Diagnostics

Public Class Example
    
    Public Shared Sub Main() 

        Const LIMIT As Integer = 100
        Dim cu As RegistryKey = Registry.CurrentUser
        Const testKey As String = "RegistryKeyPermissionCheckExample"
        
        Console.WriteLine("Generating {0} key/value pairs.", LIMIT)
        Dim rk As RegistryKey = cu.CreateSubKey(testKey)

        For i As Integer = 0 To LIMIT
            rk.SetValue("Key" & i, i)
        Next i
        
        rk.Close()
        
        Dim s As New Stopwatch()
        
        ' On the default setting, security is checked every time
        ' a key/value pair is read.
        rk = cu.OpenSubKey(testKey, _
            RegistryKeyPermissionCheck.Default)
        
        s.Start()
        For i As Integer = 0 To LIMIT
            rk.GetValue("Key" & i, i)
        Next i
        s.Stop()
        rk.Close()
        Dim delta1 As Long = s.ElapsedTicks
        
        s.Reset()
        
        ' When the key is opened with ReadSubTree, security is 
        ' not checked when the values are read.
        rk = cu.OpenSubKey(testKey, _
            RegistryKeyPermissionCheck.ReadSubTree)
        
        s.Start()
        For i As Integer = 0 To LIMIT
            rk.GetValue("Key" & i, i)
        Next i
        s.Stop()
        rk.Close()
        Dim delta2 As Long = s.ElapsedTicks
        
        Dim faster As Double = _
            CDbl(delta1 - delta2) * 100.0 / CDbl(delta1)
        Console.WriteLine("ReadSubTree is {0}% faster for {1} values.", _
            faster.ToString("0.0"), LIMIT)
        
        cu.DeleteSubKey(testKey)
    
    End Sub 
End Class 

' This code example produces output similar to the following:
'
'Generating 100 key/value pairs.
'ReadSubTree is 23.4% faster for 100 values.
'

Hinweise

Wenn eine Anwendung eine große Anzahl von Registrierungseinstellungen aus einer Reihe von Unterschlüsseln speichert oder abruft, werden zahlreiche redundante Sicherheitsüberprüfungen durchgeführt. Diese Enumeration gibt an, wann Sicherheitsprüfungen für einen Schlüssel ausgelassen werden sollen.

Die folgende Tabelle zeigt, wann Sicherheitsüberprüfungen durchgeführt werden, basierend auf der Art und Weise, wie der übergeordnete Schlüssel und der aktuelle Schlüssel geöffnet werden.

Übergeordneter Schlüssel geöffnet mit	Aktueller Schlüssel geöffnet mit	Ergebnis
Standard	Standard	Beim Zugriff auf einen Wert im aktuellen Schlüssel oder beim Versuch, auf einen Unterschlüssel zuzugreifen, wird eine Sicherheitsüberprüfung durchgeführt. Dies ist das Verhalten in den .NET Framework Versionen 1.0 und 1.1.
Standard	Readsubtree	Beim Öffnen des aktuellen Schlüssels wird eine Sicherheitsüberprüfung durchgeführt.
Standard	ReadWriteSubTree	Beim Öffnen des aktuellen Schlüssels wird eine Sicherheitsüberprüfung durchgeführt.
Readsubtree	Default oder ReadSubTree	Beim Öffnen des aktuellen Schlüssels oder seiner Werte werden keine Sicherheitsüberprüfungen durchgeführt.
Readsubtree	ReadWriteSubTree	Beim Öffnen des aktuellen Schlüssels wird eine Sicherheitsüberprüfung durchgeführt.
ReadWriteSubTree	Any	Beim Öffnen des aktuellen Schlüssels oder seiner Werte werden keine Sicherheitsüberprüfungen durchgeführt.