EventAttributes-Enumeration

Artikel
08/20/2007

Gibt die Attribute eines Ereignisses an.

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

Namespace: System.Reflection
Assembly: mscorlib (in mscorlib.dll)

Syntax

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

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

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

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

SerializableAttribute 
FlagsAttribute 
ComVisibleAttribute(true) 
public enum EventAttributes

Member

	Membername	Beschreibung
	None	Gibt an, dass das Ereignis keine Attribute hat.
	ReservedMask	Gibt ein reserviertes Flag für die ausschließliche Verwendung durch die Common Language Runtime an.
	RTSpecialName	Gibt an, dass die Common Language Runtime die Namenscodierung überprüfen soll.
	SpecialName	Gibt an, dass der Name eine Besonderheit des Ereignisses beschreibt.

Hinweise

EventAttributes-Werte können mit der bitweisen OR-Operation kombiniert werden, um die entsprechende Kombination abzurufen.

Diese Enumerationen werden in der Datei corhdr.h definiert und stellen eine Kombination aus Bits und Enumeratoren dar.

Beispiel

Imports System
Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit

Public Class MyApplication

   Delegate Sub MyEvent(temp As Object)

   Public Shared Sub Main()
      Dim helloWorldClass As TypeBuilder = CreateCallee(Thread.GetDomain())

      Dim info As EventInfo() = helloWorldClass.GetEvents(BindingFlags.Public Or _
                                                          BindingFlags.Instance)
      Console.WriteLine("'HelloWorld' type has following events :")
      Dim i As Integer
      For i = 0 To info.Length - 1
         Console.WriteLine(info(i).Name)
      Next i
   End Sub 'Main

   ' Create the callee transient dynamic assembly.
   Private Shared Function CreateCallee(myDomain As AppDomain) As TypeBuilder
      Dim myAssemblyName As New AssemblyName()
      myAssemblyName.Name = "EmittedAssembly"

      ' Create the callee dynamic assembly.
      Dim myAssembly As AssemblyBuilder = myDomain.DefineDynamicAssembly _
                                          (myAssemblyName, AssemblyBuilderAccess.Run)
      ' Create a dynamic module named "CalleeModule" in the callee
      Dim myModule As ModuleBuilder = myAssembly.DefineDynamicModule("EmittedModule")

      ' Define a public class named "HelloWorld" in the assembly.
      Dim helloWorldClass As TypeBuilder = myModule.DefineType _
                                           ("HelloWorld", TypeAttributes.Public)

      Dim myMethod1 As MethodBuilder = helloWorldClass.DefineMethod _
                    ("OnClick", MethodAttributes.Public, Nothing, New Type() {GetType(Object)})
      Dim methodIL1 As ILGenerator = myMethod1.GetILGenerator()
      methodIL1.Emit(OpCodes.Ret)
      Dim myMethod2 As MethodBuilder = helloWorldClass.DefineMethod _
                   ("OnMouseUp", MethodAttributes.Public, Nothing, New Type() {GetType(Object)})
      Dim methodIL2 As ILGenerator = myMethod2.GetILGenerator()
      methodIL2.Emit(OpCodes.Ret)

      ' Create the events.
      Dim myEvent1 As EventBuilder = helloWorldClass.DefineEvent _
                                         ("Click", EventAttributes.None, GetType(MyEvent))
      myEvent1.SetRaiseMethod(myMethod1)
      Dim myEvent2 As EventBuilder = helloWorldClass.DefineEvent _
                                         ("MouseUp", EventAttributes.None, GetType(MyEvent))
      myEvent2.SetRaiseMethod(myMethod2)

      helloWorldClass.CreateType()
      Return helloWorldClass
   End Function 'CreateCallee
End Class 'MyApplication

using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;


public class MyApplication
{
   public delegate void MyEvent(Object temp);
   public static void Main()
   {
      TypeBuilder helloWorldClass = CreateCallee(Thread.GetDomain());

      EventInfo[] info =
         helloWorldClass.GetEvents(BindingFlags.Public | BindingFlags.Instance);
      Console.WriteLine("'HelloWorld' type has following events :");
      for(int i=0; i < info.Length; i++)
         Console.WriteLine(info[i].Name);
   }

   // Create the callee transient dynamic assembly.
   private static TypeBuilder CreateCallee(AppDomain myDomain)
   {
      AssemblyName assemblyName = new AssemblyName();
      assemblyName.Name = "EmittedAssembly";

      // Create the callee dynamic assembly.
      AssemblyBuilder myAssembly =
         myDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
      // Create a dynamic module named "CalleeModule" in the callee.
      ModuleBuilder myModule = myAssembly.DefineDynamicModule("EmittedModule");

      // Define a public class named "HelloWorld" in the assembly.
      TypeBuilder helloWorldClass =
         myModule.DefineType("HelloWorld", TypeAttributes.Public);

      MethodBuilder myMethod1 = helloWorldClass.DefineMethod("OnClick",
         MethodAttributes.Public, typeof(void), new Type[]{typeof(Object)});
      ILGenerator methodIL1 = myMethod1.GetILGenerator();
      methodIL1.Emit(OpCodes.Ret);
      MethodBuilder myMethod2 = helloWorldClass.DefineMethod("OnMouseUp",
         MethodAttributes.Public, typeof(void), new Type[]{typeof(Object)});
      ILGenerator methodIL2 = myMethod2.GetILGenerator();
      methodIL2.Emit(OpCodes.Ret);

      // Create the events.
      EventBuilder myEvent1 = helloWorldClass.DefineEvent("Click", EventAttributes.None,
         typeof(MyEvent));
      myEvent1.SetRaiseMethod(myMethod1);
      EventBuilder myEvent2 = helloWorldClass.DefineEvent("MouseUp", EventAttributes.None,
         typeof(MyEvent));
      myEvent2.SetRaiseMethod(myMethod2);

      helloWorldClass.CreateType();
      return(helloWorldClass);
   }
}

using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

ref class MyApplication
{
private:
   delegate void MyEvent( Object^ temp );

public:

   // Create the callee transient dynamic assembly.
   static TypeBuilder^ CreateCallee( AppDomain^ myDomain )
   {
      AssemblyName^ assemblyName = gcnew AssemblyName;
      assemblyName->Name = "EmittedAssembly";
      
      // Create the callee dynamic assembly.
      AssemblyBuilder^ myAssembly = myDomain->DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess::Run );
      
      // Create a dynamic module
      ModuleBuilder^ myModule = myAssembly->DefineDynamicModule( "EmittedModule" );
      
      // Define a public class named "HelloWorld" in the assembly.
      TypeBuilder^ helloWorldClass = myModule->DefineType( "HelloWorld", TypeAttributes::Public );
      array<Type^>^typeArray = gcnew array<Type^>(1);
      typeArray[ 0 ] = Object::typeid;
      MethodBuilder^ myMethod1 = helloWorldClass->DefineMethod( "OnClick", MethodAttributes::Public, void::typeid, typeArray );
      ILGenerator^ methodIL1 = myMethod1->GetILGenerator();
      methodIL1->Emit( OpCodes::Ret );
      MethodBuilder^ myMethod2 = helloWorldClass->DefineMethod( "OnMouseUp", MethodAttributes::Public, void::typeid, typeArray );
      ILGenerator^ methodIL2 = myMethod2->GetILGenerator();
      methodIL2->Emit( OpCodes::Ret );
      
      // Create the events.
      EventBuilder^ myEvent1 = helloWorldClass->DefineEvent( "Click", EventAttributes::None, MyEvent::typeid );
      myEvent1->SetRaiseMethod( myMethod1 );
      EventBuilder^ myEvent2 = helloWorldClass->DefineEvent( "MouseUp", EventAttributes::None, MyEvent::typeid );
      myEvent2->SetRaiseMethod( myMethod2 );
      helloWorldClass->CreateType();
      return (helloWorldClass);
   }
};

int main()
{
   TypeBuilder^ helloWorldClass = MyApplication::CreateCallee( Thread::GetDomain() );
   array<EventInfo^>^info = helloWorldClass->GetEvents( static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Instance) );
   Console::WriteLine( "'HelloWorld' type has following events :" );
   for ( int i = 0; i < info->Length; i++ )
      Console::WriteLine( info[ i ]->Name );
   return 0;
}

import System.*;
import System.Threading.*;
import System.Reflection.*;
import System.Reflection.Emit.*;

public class MyApplication
{
    /** @delegate 
     */
    public delegate void MyEvent(Object temp);

    public static void main(String[] args)
    {
        TypeBuilder helloWorldClass =
            CreateCallee(System.Threading.Thread.GetDomain());

        EventInfo info[] = helloWorldClass.GetEvents(BindingFlags.Public
            | BindingFlags.Instance);
        Console.WriteLine("'HelloWorld' type has following events :");
        for (int i = 0; i < info.length; i++) {
            Console.WriteLine(info[i].get_Name());
        }
    } //main

    // Create the callee transient dynamic assembly.
    private static TypeBuilder CreateCallee(AppDomain myDomain)
    {
        AssemblyName assemblyName = new AssemblyName();
        assemblyName.set_Name("EmittedAssembly");
        // Create the callee dynamic assembly.
        AssemblyBuilder myAssembly = myDomain.DefineDynamicAssembly(assemblyName,
            AssemblyBuilderAccess.Run);
        // Create a dynamic module named "CalleeModule" in the callee.
        ModuleBuilder myModule = myAssembly.DefineDynamicModule("EmittedModule");
        // Define a public class named "HelloWorld" in the assembly.
        TypeBuilder helloWorldClass = myModule.DefineType("HelloWorld",
            TypeAttributes.Public);

        MethodBuilder myMethod1 = helloWorldClass.DefineMethod("OnClick",
            MethodAttributes.Public, void.class.ToType(),
            new Type[] { Object.class.ToType() });
        ILGenerator methodIL1 = myMethod1.GetILGenerator();
        methodIL1.Emit(OpCodes.Ret);
        MethodBuilder myMethod2 = helloWorldClass.DefineMethod("OnMouseUp",
            MethodAttributes.Public, void.class.ToType(),
            new Type[] { Object.class.ToType() });
        ILGenerator methodIL2 = myMethod2.GetILGenerator();
        methodIL2.Emit(OpCodes.Ret);
        // Create the events.
        EventBuilder myEvent1 = helloWorldClass.DefineEvent("Click",
            EventAttributes.None, MyEvent.class.ToType());
        myEvent1.SetRaiseMethod(myMethod1);
        EventBuilder myEvent2 = helloWorldClass.DefineEvent("MouseUp",
            EventAttributes.None, MyEvent.class.ToType());
        myEvent2.SetRaiseMethod(myMethod2);

        helloWorldClass.CreateType();
        return helloWorldClass;
    } //CreateCallee
}//MyApplication

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, 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.

Freigeben über

EventAttributes-Enumeration

Syntax

Member

Hinweise

Beispiel

Plattformen

Versionsinformationen

.NET Framework

.NET Compact Framework

Siehe auch

Referenz

Zusätzliche Ressourcen