Esporta (0) Stampa
Espandi tutto

Metodo EventInfo.AddEventHandler

Aggiornamento: novembre 2007

Aggiunge un gestore eventi a un'origine eventi.

Spazio dei nomi:  System.Reflection
Assembly:  mscorlib (in mscorlib.dll)

public void AddEventHandler(
	Object target,
	Delegate handler
)
public final void AddEventHandler(
	Object target,
	Delegate handler
)
public final function AddEventHandler(
	target : Object, 
	handler : Delegate
)

Parametri

target
Tipo: System.Object

Origine dell'evento.

handler
Tipo: System.Delegate

Incapsula uno o più metodi da richiamare quando l'evento viene generato dalla destinazione.

Implementa

_EventInfo.AddEventHandler(Object, Delegate)

EccezioneCondizione
InvalidOperationException

L'evento non dispone di una funzione di accesso add pubblica.

ArgumentException

Non è possibile utilizzare il gestore che è stato passato.

MethodAccessException

Il chiamante non dispone dell'autorizzazione per accedere al membro.

TargetException

Il parametro target non è null e l'evento non è static.

-o-

L'oggetto EventInfo non è dichiarato nella destinazione.

Questo metodo tenta di aggiungere un delegato per sincronizzare l'evento con l'oggetto di destinazione.

Ogni volta che l'evento viene generato dal parametro di destinazione, il metodo o i metodi incapsulati dal gestore vengono richiamati.

Nell'esempio di codice riportato di seguito viene illustrato come caricare un assembly, creare un'istanza di un tipo dall'assembly, creare un gestore eventi utilizzando un assembly dinamico e associare il gestore eventi dinamico. Tutte le azioni vengono eseguite utilizzando l'associazione tardiva.

Nell'esempio di codice viene caricato il file System.dll e viene creata un'istanza della classe System.Timers.Timer. Nell'esempio vengono utilizzati il metodo Type.GetEvent per ottenere l'evento Elapsed e la proprietà EventHandlerType per ottenere il tipo delegato per l'evento.

Nell'esempio di codice viene ottenuta una classe MethodInfo per il metodo Invoke del tipo delegato. Da tale classe MethodInfo viene inoltre ottenuta la firma del delegato. Viene quindi creato un assembly dinamico con un unico modulo contenente un solo tipo denominato Handler cui viene assegnato un metodo static (metodo Shared in Visual Basic) denominato DynamicHandler che verrà utilizzato per gestire l'evento.

Dopo la creazione del tipo dinamico, viene ottenuta una classe MethodInfo per il metodo terminato che viene utilizzata per creare un'istanza del delegato. Questa istanza viene passata al metodo AddEventHandler per associare l'evento. L'esecuzione del programma viene quindi sospesa per consentire la generazione dell'evento.

// 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.
 */


Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition , Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile per Smartphone, Windows Mobile per Pocket PC, Xbox 360

.NET Framework e .NET Compact Framework non supportano tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

.NET Framework

Supportato in: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Supportato in: 3.5, 2.0, 1.0

XNA Framework

Supportato in: 2.0, 1.0

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft