EventInfo.AddEventHandler(Object, Delegate) EventInfo.AddEventHandler(Object, Delegate) EventInfo.AddEventHandler(Object, Delegate) EventInfo.AddEventHandler(Object, Delegate) Method

정의

이벤트 소스에 이벤트 처리기를 추가합니다. Adds an event handler to an event source.

public:
 virtual void AddEventHandler(System::Object ^ target, Delegate ^ handler);
public virtual void AddEventHandler (object target, Delegate handler);
abstract member AddEventHandler : obj * Delegate -> unit
override this.AddEventHandler : obj * Delegate -> unit
Public Overridable Sub AddEventHandler (target As Object, handler As Delegate)

매개 변수

target
Object Object Object Object

이벤트 소스입니다. The event source.

handler
Delegate Delegate Delegate Delegate

이벤트가 대상에 의해 발생할 때 호출될 메서드를 캡슐화합니다. Encapsulates a method or methods to be invoked when the event is raised by the target.

구현

예외

이 이벤트에 public add 접근자가 없는 경우 The event does not have a public add accessor.

전달된 처리기를 사용할 수 없는 경우 The handler that was passed in cannot be used.

Windows 스토어 앱용 .NET 또는 이식 가능한 클래스 라이브러리에서 대신 기본 클래스 예외 MemberAccessException을 catch합니다. In .NET for Windows Store apps or the Portable Class Library, catch the base class exception, MemberAccessException, instead.

호출자에게 멤버에 대한 액세스 권한이 없는 경우 The caller does not have access permission to the member.

Windows 스토어 앱용 .NET 또는 이식 가능한 클래스 라이브러리에서 대신 Exception을 catch합니다. In .NET for Windows Store apps or the Portable Class Library, catch Exception instead.

target 매개 변수가 null이고 이벤트가 static이 아닌 경우 The target parameter is null and the event is not static. 또는 -or- EventInfo가 대상에서 선언되지 않은 경우 The EventInfo is not declared on the target.

예제

다음 예제에서는 인스턴스를 만듭니다를 System.Timers.Timer 클래스 동적 어셈블리를 사용 하 여 이벤트 처리기를 만들고 동적 이벤트 처리기를 연결 합니다.The following example creates an instance of the System.Timers.Timer class, creates an event handler using a dynamic assembly, and hooks up the dynamic event handler. 런타임에 바인딩을 사용 하 여 모든 작업을 수행 합니다.All actions are performed using late binding.

합니다 Timer 인스턴스 형식의 변수에 저장 됩니다 Object, 및 액세스 하는 모든 코드는 Timer 수행 되므로 런타임에 바인딩.The Timer instance is stored in a variable of type Object, and all code that accesses the Timer does so late-bound. 예제에서는 합니다 Type.GetEvent 메서드를를 Elapsed 이벤트 및 EventHandlerType 이벤트의 대리자 형식을 가져올 속성입니다.The example uses the Type.GetEvent method to get the Elapsed event, and the EventHandlerType property to get the delegate type for the event.

예제에서는 가져옵니다를 MethodInfo 에 대 한는 Invoke 대리자 형식의 메서드 및 대리자의 시그니처를 가져옵니다는 MethodInfo 인스턴스.The example gets a MethodInfo for the Invoke method of the delegate type and obtains the signature of the delegate from the MethodInfo instance. 다음 예제에서는 명명 된 단일 형식을 포함 하는 하나의 모듈을 사용 하 여 동적 어셈블리를을 만듭니다 Handler 는 형식을 제공 하 고는 static 메서드 (Shared Visual Basic에서 메서드) 라는 DynamicHandler 이벤트를 처리 하는 합니다.The example then creates a dynamic assembly with one module containing a single type named Handler and gives the type a static method (Shared method in Visual Basic) named DynamicHandler that handles the event.

예제 가져옵니다 동적 형식 만들어지면는 MethodInfo 완료 메서드에 대 한 대리자 인스턴스를 만들고 사용 하 여 합니다.After the dynamic type is created, the example gets a MethodInfo for the finished method and uses it to create a delegate instance. 이 인스턴스가 전달 되는 AddEventHandler 이벤트를 후크 하는 방법입니다.This instance is passed to the AddEventHandler method to hook up the event. 프로그램이는 이벤트를 발생 수 있도록 한 다음 일시 중지 합니다.The program then pauses to allow the event to be raised.

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];
        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.
        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.

설명

이 메서드는 대상 개체에 이벤트를 동기화 하는 대리자를 추가 하려고 합니다.This method attempts to add a delegate to synchronize the event on the target object.

대상 매개 변수에서 이벤트가 발생 될 때마다 메서드 또는 처리기에 의해 캡슐화 된 메서드가 호출 됩니다.Each time the event is raised by the target parameter, the method or methods encapsulated by the handler are invoked.

사용할 수 있습니다 합니다 AddEventHander + = 구문은 C# 또는 Visual Basic을 사용할 수 없는 경우 프로그램으로 이미 컴파일된 후 형식을 로드 하는 경우 메서드 WithEventsHandles 이벤트를 후크 하는 키워드입니다.You might use the AddEventHander method when you load a type after the program is already compiled, when it is not possible to use the C# += syntax or the Visual Basic WithEvents and Handles keywords to hook up the event.

보안

ReflectionPermission
호출 될 때 런타임에 바인딩된 메커니즘을 통해 같은 InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])합니다. when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). 연관된 열거형: MemberAccess Associated enumeration: MemberAccess.

적용 대상

추가 정보