Compartir a través de


RegistryKeyPermissionCheck Enumeración

Definición

Especifica si se deben realizar comprobaciones de seguridad al abrir las claves del Registro y al tener acceso a sus pares de nombre y valor.

public enum class RegistryKeyPermissionCheck
public enum RegistryKeyPermissionCheck
type RegistryKeyPermissionCheck = 
Public Enum RegistryKeyPermissionCheck
Herencia
RegistryKeyPermissionCheck

Campos

Default 0

La clave del Registro hereda el modo de su elemento primario. Se realizan comprobaciones de seguridad al intentar el acceso a las subclaves o valores, a menos que el elemento primario se haya abierto con el modo ReadSubTree o ReadWriteSubTree.

ReadSubTree 1

No se realizan comprobaciones de seguridad al tener acceso a subclaves o valores. Se realiza una comprobación de seguridad al intentar abrir la clave actual, a menos que el elemento primario se haya abierto con ReadSubTree o ReadWriteSubTree.

ReadWriteSubTree 2

No se realizan comprobaciones de seguridad al tener acceso a subclaves o valores. Se realiza una comprobación de seguridad al intentar abrir la clave actual, a menos que el elemento primario se haya abierto con ReadWriteSubTree.

Ejemplos

En el ejemplo de código siguiente se crea una subclave que contiene 100 pares clave-valor y la cierra. En el ejemplo se abre la subclave con Default y se registra el tiempo necesario para leer todos los valores. A continuación, el ejemplo abre la subclave con ReadSubTree y registra el tiempo necesario para leer todos los valores. Por último, el ejemplo calcula y muestra la mejora porcentual.

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.
'

Comentarios

Cuando una aplicación guarda o recupera un gran número de configuraciones del Registro de un conjunto de subclaves, se realizan numerosas comprobaciones de seguridad redundantes. Esta enumeración especifica cuándo se omitirán las comprobaciones de seguridad en una clave.

En la tabla siguiente se muestra cuándo se realizan comprobaciones de seguridad, en función de la forma en que se abre la clave primaria y la clave actual.

Clave primaria abierta con Clave actual abierta con Resultado
Default Default Se realiza una comprobación de seguridad al acceder a cualquier valor de la clave actual o al intentar acceder a una subclave. Este es el comportamiento de las versiones 1.0 y 1.1 de .NET Framework.
Default ReadSubTree Se realiza una comprobación de seguridad al intentar abrir la clave actual.
Default ReadWriteSubTree Se realiza una comprobación de seguridad al intentar abrir la clave actual.
ReadSubTree Default o ReadSubTree No se realizan comprobaciones de seguridad al abrir la clave actual o sus valores.
ReadSubTree ReadWriteSubTree Se realiza una comprobación de seguridad al intentar abrir la clave actual.
ReadWriteSubTree Any No se realizan comprobaciones de seguridad al abrir la clave actual o sus valores.

Se aplica a