RegistryKeyPermissionCheck Enumeração

Definição

Namespace:

Microsoft.Win32

Assembly:

Microsoft.Win32.Registry.dll

Especifica se verificações de segurança são executadas ao abrir chaves do Registro e acessar seus pares nome/valor.

public enum class RegistryKeyPermissionCheck

public enum RegistryKeyPermissionCheck

type RegistryKeyPermissionCheck = 

Public Enum RegistryKeyPermissionCheck

Herança

Object

ValueType

Enum

RegistryKeyPermissionCheck

Campos

Default	0	A chave do Registro herda o modo de seu pai. Verificações de segurança são executadas ao tentar acessar subchaves ou valores, a menos que o pai tenha sido aberto com os modos ReadSubTree ou ReadWriteSubTree.
ReadSubTree	1	Verificações de segurança não são executadas ao acessar subchaves ou valores. Uma verificação de segurança é executada ao tentar abrir a chave atual, a menos que o pai tenha sido aberto com ReadSubTree ou ReadWriteSubTree.
ReadWriteSubTree	2	Verificações de segurança não são executadas ao acessar subchaves ou valores. Uma verificação de segurança é executada ao tentar abrir a chave atual, a menos que o pai tenha sido aberto com ReadWriteSubTree.

Exemplos

O exemplo de código a seguir cria uma subchave contendo 100 pares chave/valor e a fecha. O exemplo abre a subchave com Default e registra o tempo necessário para ler todos os valores. Em seguida, o exemplo abre a subchave com ReadSubTree e registra o tempo necessário para ler todos os valores. Por fim, o exemplo calcula e exibe o aprimoramento percentual.

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

Comentários

Quando um aplicativo salva ou recupera um grande número de configurações do Registro de um conjunto de subchaves, várias verificações de segurança redundantes são executadas. Essa enumeração especifica quando as verificações de segurança em uma chave devem ser omitidas.

A tabela a seguir mostra quando as verificações de segurança são executadas, com base na forma como a chave pai e a chave atual são abertas.

Chave pai aberta com	Chave atual aberta com	Resultado
Padrão	Padrão	Uma marcar de segurança é executada ao acessar qualquer valor na chave atual ou ao tentar acessar uma subchave. Esse é o comportamento nas versões .NET Framework 1.0 e 1.1.
Padrão	Readsubtree	Uma marcar de segurança é executada ao tentar abrir a chave atual.
Padrão	Readwritesubtree	Uma marcar de segurança é executada ao tentar abrir a chave atual.
Readsubtree	Padrão ou ReadSubTree	Nenhuma verificação de segurança é executada ao abrir a chave atual ou seus valores.
Readsubtree	Readwritesubtree	Uma marcar de segurança é executada ao tentar abrir a chave atual.
Readwritesubtree	Qualquer	Nenhuma verificação de segurança é executada ao abrir a chave atual ou seus valores.