EventInfo.AddEventHandler(Object, Delegate) Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Fügt einen Ereignishandler einer Ereignisquelle hinzu.
public:
virtual void AddEventHandler(System::Object ^ target, Delegate ^ handler);public virtual void AddEventHandler (object target, Delegate handler);public virtual void AddEventHandler (object? target, Delegate? handler);public void AddEventHandler (object target, Delegate handler);abstract member AddEventHandler : obj * Delegate -> unit
override this.AddEventHandler : obj * Delegate -> unitPublic Overridable Sub AddEventHandler (target As Object, handler As Delegate)Public Sub AddEventHandler (target As Object, handler As Delegate)Parameter
- target
- Object
Die Ereignisquelle.
- handler
- Delegate
Kapselt eine Methode oder Methoden ein, die aufgerufen werden sollen, wenn das Ereignis vom Ziel ausgelöst wird.
Implementiert
Ausnahmen
Das Ereignis besitzt keinen öffentlichen add-Accessor.
Der übergebene Handler kann nicht verwendet werden.
Der Aufrufer verfügt nicht über Zugriffsberechtigung für diesen Member.
Hinweis: Erfassen Sie in .NET für Windows Store-Apps oder der portablen Klassenbibliothek stattdessen die Basisklassen-Ausnahme MemberAccessException.
Der target-Parameter ist null, und das Ereignis ist nicht statisch.
- oder -
Die EventInfo ist im Ziel nicht deklariert.
Hinweis: In .NET für Windows Store-Apps oder der portablen Klassenbibliothek sollten Sie stattdessen abfangen Exception .
Beispiele
Im folgenden Beispiel wird eine Instanz der System.Timers.Timer -Klasse erstellt, ein Ereignishandler mithilfe einer dynamischen Assembly erstellt und der dynamische Ereignishandler eingebunden. Alle Aktionen werden mithilfe der späten Bindung ausgeführt.
Die Timer -Instanz wird in einer Variablen vom Typ Objectgespeichert, und der gesamte Code, der auf die Timer zugreift, erfolgt so spät gebunden. Im Beispiel wird die Type.GetEvent -Methode zum Abrufen des Ereignisses Elapsed und die EventHandlerType -Eigenschaft verwendet, um den Delegatentyp für das Ereignis abzurufen.
Das Beispiel ruft eine MethodInfo für die Invoke Methode des Delegatentyps ab und ruft die Signatur des Delegaten von der MethodInfo Instanz ab. Das Beispiel erstellt dann eine dynamische Assembly mit einem Modul, das einen einzelnen Typ namens Handler enthält, und gibt dem Typ eine static Methode (Shared Methode in Visual Basic) mit dem Namen DynamicHandler , die das Ereignis behandelt.
Nachdem der dynamische Typ erstellt wurde, ruft das Beispiel eine MethodInfo für die fertige Methode ab und verwendet ihn, um eine Delegateninstanz zu erstellen. Diese Instanz wird an die AddEventHandler -Methode übergeben, um das Ereignis zu verbinden. Das Programm hält dann an, damit das Ereignis ausgelöst werden kann.
using System;
using System.Reflection;
using System.Reflection.Emit;
public class Example
{
private static object? timer;
public static void Main()
{
// Get the Timer type.
Type t = typeof(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 ?? 0];
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. (You can use also 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 = AssemblyBuilder.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.
if (handlerType is not null && eventHandler is not null)
{
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 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.
*/
Imports System.Reflection
Imports System.Reflection.Emit
Public Class Example
Private Shared timer As Object
Public Shared Sub Main()
' Get the Timer type.
Dim t As Type = GetType(System.Timers.Timer)
' Create an instance of the Timer type.
timer = Activator.CreateInstance(t)
' Use reflection to get the Elapsed event.
Dim eInfo As EventInfo = 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.
'
Dim handlerType As Type = eInfo.EventHandlerType
Dim invokeMethod As MethodInfo = handlerType.GetMethod("Invoke")
Dim parms As ParameterInfo() = invokeMethod.GetParameters()
'
' Note that in Visual Basic you must dimension the array one
' unit smaller than the source array in order to get an array
' of the same size. This is because Visual Basic adds an extra
' element to every array, for ease of use.
'
Dim parmTypes(parms.Length - 1) As Type
Dim i As Integer
For i = 0 To parms.Length - 1
parmTypes(i) = parms(i).ParameterType
Next i
' 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. (You can alsso use dynamic methods,
' which are simpler because there is no need to create an
' assembly, module, or type.)
Dim aName As New AssemblyName()
aName.Name = "DynamicTypes"
Dim ab As AssemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(aName, AssemblyBuilderAccess.Run)
Dim mb As ModuleBuilder = ab.DefineDynamicModule(aName.Name)
Dim tb As TypeBuilder = mb.DefineType("Handler", TypeAttributes.Class Or TypeAttributes.Public)
' Create the method that will handle the event. The name
' is not important. The method is Shared ("static" in
' reflection), because there is no reason to create an
' instance of the dynamic type "Handler".
'
' The parameter types and return type of the method are
' the same as those of the delegate's Invoke method,
' captured earlier.
Dim handler As MethodBuilder = tb.DefineMethod("DynamicHandler", MethodAttributes.Public Or MethodAttributes.Static, invokeMethod.ReturnType, parmTypes)
' Generate code to handle the event. In this case, the
' handler simply prints a text string to the console.
'
Dim il As ILGenerator = 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.
Dim finished As Type = tb.CreateType()
Dim eventHandler As MethodInfo = finished.GetMethod("DynamicHandler")
' Use the MethodInfo to create a delegate of the correct
' type, and call the AddEventHandler method to hook up
' the event.
Dim d As [Delegate] = [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, Nothing, timer, New [Object]() {1000})
t.InvokeMember("Enabled", BindingFlags.SetProperty, Nothing, timer, New [Object]() {True})
Console.WriteLine("Press the Enter key to end the program.")
Console.ReadLine()
End Sub
End Class
' This 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.
Hinweise
Diese Methode versucht, einen Delegaten hinzuzufügen, um das Ereignis für das Zielobjekt zu synchronisieren.
Jedes Mal, wenn das Ereignis durch den Zielparameter ausgelöst wird, werden die vom Handler gekapselten Methoden aufgerufen.
Sie können die AddEventHandler -Methode verwenden, wenn Sie einen Typ laden, nachdem das Programm bereits kompiliert wurde, wenn es nicht möglich ist, die C# +=-Syntax oder die Visual Basic-Schlüsselwörter WithEvents und Handles die Schlüsselwörter zum Einbinden des Ereignisses zu verwenden.
