ReflectionPermissionFlag-Enumeration

Gibt die zulässige Verwendung von System.Reflection für nicht sichtbare Member an.

Diese Enumeration verfügt über ein FlagsAttribute -Attribut, das die bitweise Kombination der Memberwerte zulässt.

Namespace: System.Security.Permissions
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
<SerializableAttribute> _
<ComVisibleAttribute(True)> _
<FlagsAttribute> _
Public Enumeration ReflectionPermissionFlag
'Usage
Dim instance As ReflectionPermissionFlag

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
[FlagsAttribute] 
public enum ReflectionPermissionFlag

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
[FlagsAttribute] 
public enum class ReflectionPermissionFlag

/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
/** @attribute FlagsAttribute() */ 
public enum ReflectionPermissionFlag

SerializableAttribute 
ComVisibleAttribute(true) 
FlagsAttribute 
public enum ReflectionPermissionFlag

Member

	Membername	Beschreibung
	AllFlags	TypeInformation, MemberAccess und ReflectionEmit werden festgelegt.
	MemberAccess	Operationsaufrufe sind für alle Typmember zulässig. Wenn dieses Flag nicht festgelegt ist, sind Operationsaufrufe ausschließlich für sichtbare Typmember zulässig.
	NoFlags	Für nicht sichtbare Typen ist Reflektion nicht zulässig.
	ReflectionEmit	Die Verwendung von System.Reflection.Emit ist zulässig.
	TypeInformation	Reflektion ist für nicht sichtbare Member eines Typs zulässig.

Hinweise

Diese Enumeration wird von ReflectionPermission verwendet. Wenn keine ReflectionPermission gewährt wird, ist Reflektion ausschließlich für sichtbare Member zulässig.

Warnung

Da ReflectionPermission den Zugriff auf private Klassenmember und Metadaten ermöglicht, sollte Internetcode keine ReflectionPermission gewährt werden.

Beispiel

Imports System
Imports System.Security
Imports System.Security.Permissions
Imports Microsoft.VisualBasic

Public Class ReflectionGenerator


    Private myReflection As ReflectionPermissionFlag() = _
        {ReflectionPermissionFlag.AllFlags, _
         ReflectionPermissionFlag.MemberAccess, _
         ReflectionPermissionFlag.NoFlags, _
         ReflectionPermissionFlag.ReflectionEmit, _
         ReflectionPermissionFlag.TypeInformation}

    Private reflectionIndex As Integer = 0


    Public Sub New()
        ResetIndex()
    End Sub 'New


    Public Sub ResetIndex()
        reflectionIndex = 0
    End Sub 'ResetIndex

    ' CreateReflection creates a ReflectionPermission object.
    Public Function CreateReflection(ByRef reflectionPerm As ReflectionPermission, ByRef reflection As ReflectionPermissionFlag) As Boolean

        If reflectionIndex >= myReflection.Length Then
            reflectionPerm = New ReflectionPermission(PermissionState.None)
            reflection = ReflectionPermissionFlag.NoFlags
            reflectionIndex &= 1
            Return False
        End If
        reflection = myReflection(reflectionIndex)
        reflectionIndex = reflectionIndex + 1
        Try
            reflectionPerm = New ReflectionPermission(reflection)
            Return True
        Catch e As Exception
            Console.WriteLine(("Cannot create ReflectionPermission: " & reflection & " " & e.ToString()))
            reflectionPerm = New ReflectionPermission(PermissionState.None)
            reflection = ReflectionPermissionFlag.NoFlags
            Return True
        End Try
    End Function 'CreateReflection
End Class 'ReflectionGenerator 
' End of ReflectionGenerator.

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


public class ReflectionGenerator
{


    private ReflectionPermissionFlag[] myReflection =
{
    ReflectionPermissionFlag.AllFlags,
    ReflectionPermissionFlag.MemberAccess,
    ReflectionPermissionFlag.NoFlags,
    ReflectionPermissionFlag.ReflectionEmit,
    ReflectionPermissionFlag.TypeInformation
};

    private int reflectionIndex = 0;

    public ReflectionGenerator()
    {
        ResetIndex();
    }

    public void ResetIndex()
    {
        reflectionIndex = 0;
    }
    // CreateReflection creates a ReflectionPermission object.
    public bool CreateReflection(out ReflectionPermission reflectionPerm,
        out ReflectionPermissionFlag reflection)
    {

        if(reflectionIndex >= myReflection.Length)
        {
            reflectionPerm = new ReflectionPermission(PermissionState.None);
            reflection=ReflectionPermissionFlag.NoFlags;
            reflectionIndex++;
            return false;
        }
        reflection = myReflection[reflectionIndex++];
        try
        {
            reflectionPerm = new ReflectionPermission(reflection);
            return true;
        }
        catch(Exception e)
        {
            Console.WriteLine("Cannot create ReflectionPermission: " + reflection +" "+e);
            reflectionPerm = new ReflectionPermission(PermissionState.None);
            reflection=ReflectionPermissionFlag.NoFlags;
            return true;
        }
    }
} // End of ReflectionGenerator.

using namespace System;
using namespace System::Security;
using namespace System::Security::Permissions;
using namespace System::Runtime::InteropServices;
public ref class ReflectionGenerator
{
private:
   array<ReflectionPermissionFlag>^myReflection;
   int reflectionIndex;

public:
   ReflectionGenerator()
   {
      array<ReflectionPermissionFlag>^ temp = {ReflectionPermissionFlag::AllFlags,ReflectionPermissionFlag::MemberAccess,ReflectionPermissionFlag::NoFlags,ReflectionPermissionFlag::ReflectionEmit,ReflectionPermissionFlag::TypeInformation};
      myReflection = temp;
      ResetIndex();
   }

   void ResetIndex()
   {
      reflectionIndex = 0;
   }


   // CreateReflection creates a ReflectionPermission Object*.
   bool CreateReflection( [Out]interior_ptr<ReflectionPermission^> reflectionPerm, [Out]ReflectionPermissionFlag * reflection )
   {
      if ( reflectionIndex >= myReflection->Length )
      {
          *reflectionPerm = gcnew ReflectionPermission( PermissionState::None );
          *reflection = ReflectionPermissionFlag::NoFlags;
         reflectionIndex++;
         return false;
      }

       *reflection = myReflection[ reflectionIndex++ ];
      try
      {
          *reflectionPerm = gcnew ReflectionPermission(  *reflection );
         return true;
      }
      catch ( Exception^ e ) 
      {
         Console::WriteLine( "Cannot create ReflectionPermission: {0}{1}",  *reflection, e );
          *reflectionPerm = gcnew ReflectionPermission( PermissionState::None );
          *reflection = ReflectionPermissionFlag::NoFlags;
         return true;
      }

   }

};

// End of ReflectionGenerator.

Plattformen

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

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

Siehe auch

Referenz

System.Security.Permissions-Namespace
ReflectionPermission-Klasse
ReflectionPermissionAttribute-Klasse