Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

EventInfo.AddEventHandler-Methode: (Object, Delegate)

 

Fügt einen Ereignishandler auf eine Ereignisquelle hinzu.

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

public virtual void AddEventHandler(
	object target,
	Delegate handler
)

Parameter

target
Type: System.Object

Die Ereignisquelle.

handler
Type: System.Delegate

Kapselt eine Methode oder Methoden aufgerufen werden, wenn das Ereignis, die vom Ziel ausgelöst wird.

Exception Condition
InvalidOperationException

Das Ereignis verfügt nicht über eine öffentliche add Accessor.

ArgumentException

Der Handler, der übergeben wurde, kann nicht verwendet werden.

MethodAccessException
System_CAPS_noteHinweis

In der .NET for Windows Store apps oder Portable Klassenbibliothek, fangen die Ausnahme Basisklasse MemberAccessException, stattdessen.

Der Aufrufer keine Zugriffsberechtigung für den Member.

TargetException
System_CAPS_noteHinweis

In der .NET for Windows Store apps oder Portable Klassenbibliothek, catch Exception stattdessen.

Die target Parameter ist null und das Ereignis ist nicht statisch.

- oder -

Die EventInfo ist auf dem Ziel nicht deklariert.

Diese Methode versucht, einen Delegaten für das Ereignis für das Zielobjekt synchronisieren hinzuzufügen.

Jedes Mal, wenn das Ereignis durch den Zielparameter ausgelöst wird, werden die Methode oder die vom Handler gekapselten Methoden aufgerufen werden.

Im folgenden Codebeispiel wird veranschaulicht, wie auf eine Assembly zu laden, erstellen Sie eine Instanz eines Typs aus der Assembly, mit einer dynamischen Assembly einen Ereignishandler erstellen und die dynamische Ereignishandler. Alle Aktionen werden mit später Bindung ausgeführt.

Im Codebeispiel wird System.dll geladen und erstellt eine Instanz der System.Timers.Timer Klasse. Im Beispiel wird die Type.GetEvent Methode zum Abrufen der Elapsed -Ereignis, und der EventHandlerType -Eigenschaft den Delegattyp für das Ereignis abgerufen.

Im Codebeispiel wird eine MethodInfo für die Invoke -Methode des Delegattyps, und aus der MethodInfo wird die Signatur des Delegaten abgerufen. Das Codebeispiel erstellt dann eine dynamische Assembly mit einem Modul mit einem einzelnen Typ mit dem Namen Handler, und gibt den Typ einer static Methode (Shared -Methode in Visual Basic) mit dem Namen DynamicHandler für die Ereignisbehandlung verwendet wird.

Nachdem der dynamische Typ erstellt wurde, wird im Codebeispiel wird eine MethodInfo für die abgeschlossene Methode und verwendet, um eine Delegatinstanz zu erstellen. Diese Instanz wird übergeben, um die AddEventHandler Methode, um das Ereignis aufzurufen. Das Programm hält dann damit das Ereignis ausgelöst werden kann.

// New example (user feedback bug 23592) GlennHa 1/4/06
using System;
using System.Reflection;
using System.Reflection.Emit;

public class Example
{
    // The type used for this code example is the System.Timers.Timer 
    // class. The Timer object is stored in a variable of type object,
    // and all code that accesses the Timer does so late-bound. This
    // is because the scenario in which you might use the AddEVentHander
    // method is when you load the type after the program is already
    // compiled, when it is not possible to use the C# += syntax to
    // hook up the event. (Note that there is no "using" statement
    // for the System.Timers namespace.)
    //
    private static object timer;

    public static void Main()
    {
        // Get the assembly that contains the Timer type (Sytem.dll). 
        // The following code uses the fact that System.dll has the
        // same public key as mscorlib.dll to construct a string
        // representing the full assembly name. 
        string fullName = "";
        foreach (Assembly assem in AppDomain.CurrentDomain.GetAssemblies())
        {
            if (assem.GetName().Name == "mscorlib")
            {
                fullName = assem.FullName;
            }
        }
        Assembly sys = Assembly.Load("System" + fullName.Substring(fullName.IndexOf(",")));

        // Get a Type object representing the Timer type.
        Type t = sys.GetType("System.Timers.Timer");

        // Create an instance of the Timer type.
        timer = Activator.CreateInstance(t);

        // Use reflection to get the Elapsed event.
        EventInfo eInfo = t.GetEvent("Elapsed");

        // In order to create a method to handle the Elapsed event,
        // it is necessary to know the signature of the delegate 
        // used to raise the event. Reflection.Emit can then be
        // used to construct a dynamic class with a static method
        // that has the correct signature.

        // Get the event handler type of the Elapsed event. This is
        // a delegate type, so it has an Invoke method that has
        // the same signature as the delegate. The following code
        // creates an array of Type objects that represent the 
        // parameter types of the Invoke method.
        //
        Type handlerType = eInfo.EventHandlerType;
        MethodInfo invokeMethod = handlerType.GetMethod("Invoke");
        ParameterInfo[] parms = invokeMethod.GetParameters();
        Type[] parmTypes = new Type[parms.Length];
        for (int i = 0; i < parms.Length; i++)
        {
            parmTypes[i] = parms[i].ParameterType;
        }

        // Use Reflection.Emit to create a dynamic assembly that
        // will be run but not saved. An assembly must have at 
        // least one module, which in this case contains a single
        // type. The only purpose of this type is to contain the 
        // event handler method. (In the .NET Framework version 
        // 2.0 you can use dynamic methods, which are simpler 
        // because there is no need to create an assembly, module,
        // or type.)
        AssemblyName aName = new AssemblyName();
        aName.Name = "DynamicTypes";
        AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly(aName, AssemblyBuilderAccess.Run);
        ModuleBuilder mb = ab.DefineDynamicModule(aName.Name);
        TypeBuilder tb = mb.DefineType("Handler", TypeAttributes.Class | TypeAttributes.Public);

        // Create the method that will handle the event. The name
        // is not important. The method is static, because there is
        // no reason to create an instance of the dynamic type.
        //
        // The parameter types and return type of the method are
        // the same as those of the delegate's Invoke method, 
        // captured earlier.
        MethodBuilder handler = tb.DefineMethod("DynamicHandler", 
            MethodAttributes.Public | MethodAttributes.Static, 
            invokeMethod.ReturnType, parmTypes);

        // Generate code to handle the event. In this case, the 
        // handler simply prints a text string to the console.
        //
        ILGenerator il = handler.GetILGenerator();
        il.EmitWriteLine("Timer's Elapsed event is raised.");
        il.Emit(OpCodes.Ret);

        // CreateType must be called before the Handler type can
        // be used. In order to create the delegate that will
        // handle the event, a MethodInfo from the finished type
        // is required.
        Type finished = tb.CreateType();
        MethodInfo eventHandler = finished.GetMethod("DynamicHandler");

        // Use the MethodInfo to create a delegate of the correct 
        // type, and call the AddEventHandler method to hook up 
        // the event.
        Delegate d = Delegate.CreateDelegate(handlerType, eventHandler);
        eInfo.AddEventHandler(timer, d);

        // Late-bound calls to the Interval and Enabled property 
        // are required to enable the timer with a one-second
        // interval.
        t.InvokeMember("Interval", BindingFlags.SetProperty, null, timer, new Object[] { 1000 });
        t.InvokeMember("Enabled", BindingFlags.SetProperty, null, timer, new Object[] { true });

        Console.WriteLine("Press the Enter key to end the program.");
        Console.ReadLine();
    }
}
/* This code example produces output similar to the following:

Press the Enter key to end the program.
Timer's Elapsed event is raised.
Timer's Elapsed event is raised.
Timer's Elapsed event is raised.
 */

ReflectionPermission

when invoked late-bound through mechanisms such as M:System.Type.InvokeMember(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object,System.Object[],System.Reflection.ParameterModifier[],System.Globalization.CultureInfo,System.String[]). Associated enumeration: F:System.Security.Permissions.ReflectionPermissionFlag.MemberAccess.

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 1.1
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1
Zurück zum Anfang
Anzeigen: