Questa documentazione è stata archiviata e non viene gestita.

Classe ReflectionPermission

Aggiornamento: novembre 2007

Controlla l'accesso ai tipi e ai membri non pubblici tramite gli API System.Reflection. Controlla alcune funzionalità degli API System.Reflection.Emit.

Spazio dei nomi:  System.Security.Permissions
Assembly:  mscorlib (in mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public sealed class ReflectionPermission : CodeAccessPermission, 
	IUnrestrictedPermission
/** @attribute SerializableAttribute */ 
/** @attribute ComVisibleAttribute(true) */
public final class ReflectionPermission extends CodeAccessPermission implements IUnrestrictedPermission
public final class ReflectionPermission extends CodeAccessPermission implements IUnrestrictedPermission

Senza ReflectionPermission, il codice può utilizzare la riflessione unicamente per accedere ai membri pubblici degli oggetti. Un codice con ReflectionPermission e i contrassegni ReflectionPermissionFlag adatti può accedere ai membri protected e private degli oggetti.

Attenzione:

Poiché ReflectionPermission può fornire l'accesso a tipi e membri non pubblici, si consiglia di non concedere ReflectionPermission al codice Internet, se non con il contrassegno ReflectionPermissionFlag.RestrictedMemberAccess. RestrictedMemberAccess consente l'accesso ai membri non pubblici, con la restrizione per cui l'insieme di concessione dei membri non pubblici deve essere uguale all'insieme di concessione del codice che accede ai membri non pubblici, oppure un sottoinsieme di questo.

Alcune funzionalità di reflection emit, ad esempio la creazione di simboli di debug, richiedono ReflectionPermission con il contrassegno ReflectionPermissionFlag.ReflectionEmit.

Per ulteriori informazioni, vedere l'enumerazione ReflectionPermissionFlag.

Nell'esempio di codice riportato di seguito viene illustrato il comportamento dei metodi della classe ReflectionPermission.

Nota:

Nell'esempio di codice viene illustrato il comportamento dei metodi, non il loro utilizzo. In generale, i metodi delle classi di autorizzazioni vengono utilizzati dall'infrastruttura di sicurezza e non vengono di solito utilizzati nelle applicazioni. Generalmente, nel codice dell'applicazione vengono utilizzati soltanto i costruttori. L'istanza creata convalida o controlla l'accesso alla risorsa utilizzando metodi CodeAccessPermission ereditati, ad esempio Demand.

using System;
using System.Security;
using System.Security.Permissions;

public class ReflectionPermissionDemo
{
    // Demonstrate all methods.
    public static void Main(String[] args)
    {
        IsSubsetOfDemo();
        CopyDemo();
        UnionDemo();
        IntersectDemo();
        ToFromXmlDemo();
        Console.WriteLine("Press the Enter key to exit.");
        Console.ReadLine();
    }
    // IsSubsetOf determines whether the current permission is a subset of the specified permission.
    private static void IsSubsetOfDemo()
    {
        ReflectionPermission memberAccessPerm = new ReflectionPermission(ReflectionPermissionFlag.MemberAccess);
        ReflectionPermission restrictedMemberAccessPerm = new ReflectionPermission(ReflectionPermissionFlag.RestrictedMemberAccess);

        if (restrictedMemberAccessPerm.IsSubsetOf(memberAccessPerm))
        {
            Console.WriteLine(restrictedMemberAccessPerm.Flags + " is a subset of " +
                memberAccessPerm.Flags);
        }
        else
        {
            Console.WriteLine(restrictedMemberAccessPerm.Flags + " is not a subset of " +
                memberAccessPerm.Flags);
        }
    }
    // Union creates a new permission that is the union of the current permission and the specified permission.
    private static void UnionDemo()
    {
        ReflectionPermission memberAccessPerm = new ReflectionPermission(ReflectionPermissionFlag.MemberAccess);
        ReflectionPermission restrictedMemberAccessPerm = new ReflectionPermission(ReflectionPermissionFlag.RestrictedMemberAccess);
        ReflectionPermission reflectionPerm3 = (ReflectionPermission)memberAccessPerm.Union(restrictedMemberAccessPerm);
        if (reflectionPerm3 == null)
        {
            Console.WriteLine("The union of " + memberAccessPerm.Flags + " and " +
                restrictedMemberAccessPerm.Flags + " is null.");
        }
        else
        {
            Console.WriteLine("The union of " + memberAccessPerm.Flags + " and " +
                restrictedMemberAccessPerm.Flags + " = " +
                ((ReflectionPermission)reflectionPerm3).Flags.ToString());
        }

    }
    // Intersect creates and returns a new permission that is the intersection of the current
    // permission and the permission specified.
    private static void IntersectDemo()
    {
        ReflectionPermission memberAccessPerm = new ReflectionPermission(ReflectionPermissionFlag.MemberAccess);
        ReflectionPermission restrictedMemberAccessPerm = new ReflectionPermission(ReflectionPermissionFlag.RestrictedMemberAccess);
        ReflectionPermission reflectionPerm3 = (ReflectionPermission)memberAccessPerm.Intersect(restrictedMemberAccessPerm);
        if (reflectionPerm3 != null)
        {
            Console.WriteLine("The intersection of " + memberAccessPerm.Flags +
                " and " + restrictedMemberAccessPerm.Flags + " = " +
                ((ReflectionPermission)reflectionPerm3).Flags.ToString());
        }
        else
        {
            Console.WriteLine("The intersection of " + memberAccessPerm.Flags + " and " +
                restrictedMemberAccessPerm.Flags + " is null.");
        }

    }
    //Copy creates and returns an identical copy of the current permission.
    private static void CopyDemo()
    {
        ReflectionPermission memberAccessPerm = new ReflectionPermission(ReflectionPermissionFlag.MemberAccess);
        ReflectionPermission restrictedMemberAccessPerm = (ReflectionPermission)memberAccessPerm.Copy();
        Console.WriteLine("Result of copy = " + restrictedMemberAccessPerm.ToString());
    }
    // ToXml creates an XML encoding of the permission and its current state;
    // FromXml reconstructs a permission with the specified state from the XML encoding.
    private static void ToFromXmlDemo()
    {
        ReflectionPermission memberAccessPerm = new ReflectionPermission(ReflectionPermissionFlag.MemberAccess);
        ReflectionPermission restrictedMemberAccessPerm = new ReflectionPermission(PermissionState.None);
        restrictedMemberAccessPerm.FromXml(memberAccessPerm.ToXml());
        Console.WriteLine("Result of ToFromXml = " +
            restrictedMemberAccessPerm.ToString());
    }
}

// This code example creates the following output:

//RestrictedMemberAccess is not a subset of MemberAccess
//Result of copy = <IPermission class="System.Security.Permissions.ReflectionPermi
//ssion, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e0
//89"
//version="1"
//Flags="MemberAccess"/>

//The union of MemberAccess and RestrictedMemberAccess = MemberAccess, RestrictedM
//emberAccess
//The intersection of MemberAccess and RestrictedMemberAccess is null.
//Result of ToFromXml = <IPermission class="System.Security.Permissions.Reflection
//Permission, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561
//934e089"
//version="1"
//Flags="MemberAccess"/>

//Press the Enter key to exit.



System.Object
  System.Security.CodeAccessPermission
    System.Security.Permissions.ReflectionPermission

Qualsiasi membro static (Shared in Visual Basic) pubblico di questo tipo è thread-safe. I membri di istanza non sono garantiti come thread-safe.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition , Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98

.NET Framework e .NET Compact Framework non supportano tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

.NET Framework

Supportato in: 3.5, 3.0, 2.0, 1.1, 1.0
Mostra: