Export (0) Print
Expand All

EventInfo Class

Discovers the attributes of an event and provides access to event metadata.

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

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
[ClassInterfaceAttribute(ClassInterfaceType.None)] 
public abstract class EventInfo : MemberInfo, _EventInfo
/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
/** @attribute ClassInterfaceAttribute(ClassInterfaceType.None) */ 
public abstract class EventInfo extends MemberInfo implements _EventInfo
SerializableAttribute 
ComVisibleAttribute(true) 
ClassInterfaceAttribute(ClassInterfaceType.None) 
public abstract class EventInfo extends MemberInfo implements _EventInfo
Not applicable.

Events are used with delegates. An event listener instantiates an event-handler delegate that is invoked whenever the event is raised by an event source. In order to connect to the event source, the event listener adds this delegate to the invocation list on the source. When the event is raised, the invoke method of the event-handler delegate is called. Both multicast and single-cast event notifications are supported. The Add and Remove methods, as well as the event-handler delegate class associated with an event, must be marked in the metadata.

Delegates are object-oriented function pointers. In C or C++, a function pointer is a reference to a method. In contrast to the C or C++ function pointer, a delegate contains two references: a reference to a method and a reference to an object that supports the method. Delegates can invoke a method without knowing the class type that declares or inherits the method. Delegates need only know the return type and parameter list of the method.

The event model works equally well for single-cast and multicast delegates. When the delegate's invoke method is called, only a single object will have a method called on it. A multicast modifier can be applied to a delegate declaration, which allows multiple methods to be called when the invoke method of the delegate is called.

Calling ICustomAttributeProvider.GetCustomAttributes on EventInfo when the inherit parameter of GetCustomAttributes is true does not walk the type hierarchy. Use System.Attribute to inherit custom attributes.

Notes to Inheritors: When you inherit from EventInfo, you must override the following members: GetAddMethod, GetRemoveMethod, and GetRaiseMethod.

The following code gets an EventInfo object for the Click event of the Button class.

using System;
using System.Reflection;
using System.Security;

class MyEventExample
{
    public static void Main()
    {  
        try
        {

            // Creates a bitmask based on BindingFlags.
            BindingFlags myBindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
            Type myTypeBindingFlags = typeof(System.Windows.Forms.Button);
            EventInfo myEventBindingFlags = myTypeBindingFlags.GetEvent("Click", myBindingFlags);
            if(myEventBindingFlags != null)
            {
                Console.WriteLine("Looking for the Click event in the Button class with the specified BindingFlags.");
                Console.WriteLine(myEventBindingFlags.ToString());
            }
            else
                Console.WriteLine("The Click event is not available with the Button class.");
        }
        catch(SecurityException e)
        {
            Console.WriteLine("An exception occurred.");
            Console.WriteLine("Message :"+e.Message);
        }
        catch(ArgumentNullException e)
        {
            Console.WriteLine("An exception occurred.");
            Console.WriteLine("Message :"+e.Message);
        }
        catch(Exception e)
        {
            Console.WriteLine("The following exception was raised : {0}",e.Message);
        }
    }
}

import System.*;
import System.Reflection.*;
import System.Security.*;

class MyEventExample
{
    public static void main(String[] args)
    {
        try {
            // Creates a bitmask based on BindingFlags.
            BindingFlags myBindingFlags = BindingFlags.Instance
                | BindingFlags.Public | BindingFlags.NonPublic;
            Type myTypeBindingFlags = System.Windows.Forms.Button.class.ToType();
            EventInfo myEventBindingFlags = myTypeBindingFlags.GetEvent("Click",
                myBindingFlags);
            if (myEventBindingFlags != null) {
                Console.WriteLine("Looking for the Click event in the Button"
                    + " class with the specified BindingFlags.");
                Console.WriteLine(myEventBindingFlags.ToString());
            }
            else {
                Console.WriteLine("The Click event is not available with the"
                    + " Button class.");
            }
        }
        catch (SecurityException e) {
            Console.WriteLine("An exception occurred.");
            Console.WriteLine("Message :" + e.get_Message());
        }
        catch (ArgumentNullException e) {
            Console.WriteLine("An exception occurred.");
            Console.WriteLine("Message :" + e.get_Message());
        }
        catch (System.Exception e) {
            Console.WriteLine("The following exception was raised : {0}",
                e.get_Message());
        }
    } //main
} //MyEventExample

System.Object
   System.Reflection.MemberInfo
    System.Reflection.EventInfo

This type is thread safe.

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

The Microsoft .NET Framework 3.0 is supported on Windows Vista, Microsoft Windows XP SP2, and Windows Server 2003 SP1.

.NET Framework

Supported in: 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Supported in: 2.0, 1.0

XNA Framework

Supported in: 1.0

Community Additions

ADD
Show:
© 2014 Microsoft