EventInfo
Class
Definition
Discovers the attributes of an event and provides access to event metadata.
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class EventInfo : System.Reflection.MemberInfo, System.Runtime.InteropServices._EventInfo
- Inheritance
- Derived
- Attributes
- Implements
Inherited Members
System.Object
System.Reflection.MemberInfo
Examples
The following code gets an EventInfo object for the Click event of the Button class.
#using <System.dll>
#using <System.Windows.Forms.dll>
#using <System.Drawing.dll>
using namespace System;
using namespace System::Reflection;
using namespace System::Security;
using namespace System::Windows::Forms;
int main()
{
try
{
// Creates a bitmask based on BindingFlags.
BindingFlags myBindingFlags = static_cast<BindingFlags>(BindingFlags::Instance | BindingFlags::Public | BindingFlags::NonPublic);
Type^ myTypeBindingFlags = System::Windows::Forms::Button::typeid;
EventInfo^ myEventBindingFlags = myTypeBindingFlags->GetEvent( "Click", myBindingFlags );
if ( myEventBindingFlags != nullptr )
{
Console::WriteLine( "Looking for the Click event in the Button class with the specified BindingFlags." );
Console::WriteLine( myEventBindingFlags );
}
else
Console::WriteLine( "The Click event is not available with the Button class." );
}
catch ( SecurityException^ e )
{
Console::WriteLine( "An exception occurred." );
Console::WriteLine( "Message : {0}", e->Message );
}
catch ( ArgumentNullException^ e )
{
Console::WriteLine( "An exception occurred." );
Console::WriteLine( "Message : {0}", e->Message );
}
catch ( Exception^ e )
{
Console::WriteLine( "The following exception was raised : {0}", e->Message );
}
}
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);
}
}
}
Imports System
Imports System.Reflection
Imports System.Security
Imports Microsoft.VisualBasic
' Compile this sample using the following command line:
' vbc type_getevent.vb /r:"System.Windows.Forms.dll" /r:"System.dll"
Class MyEventExample
Public Shared Sub Main()
Try
' Creates a bitmask comprising BindingFlags.
Dim myBindingFlags As BindingFlags = BindingFlags.Instance Or BindingFlags.Public _
Or BindingFlags.NonPublic
Dim myTypeBindingFlags As Type = GetType(System.Windows.Forms.Button)
Dim myEventBindingFlags As EventInfo = myTypeBindingFlags.GetEvent("Click", myBindingFlags)
If myEventBindingFlags IsNot Nothing Then
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.")
End If
Catch e As SecurityException
Console.WriteLine("An exception occurred.")
Console.WriteLine("Message :" + e.Message)
Catch e As ArgumentNullException
Console.WriteLine("An exception occurred.")
Console.WriteLine("Message :" + e.Message)
Catch e As Exception
Console.WriteLine("The following exception was raised : {0}", e.Message)
End Try
End Sub 'Main
End Class 'MyEventExample
Remarks
Use the EventInfo class to inspect events and to hook up event handlers, as shown in the example code for the AddEventHandler method.
Note
EventInfo is not intended to be used to raise events. An object raises events as dictated by its internal state.
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 Attribute to inherit custom attributes.
Constructors
| EventInfo() |
Initializes a new instance of the |
Properties
| AddMethod |
Gets the MethodInfo object for the AddEventHandler(Object, Delegate) method of the event, including non-public methods. |
| Attributes |
Gets the attributes for this event. |
| EventHandlerType |
Gets the |
| IsMulticast |
Gets a value indicating whether the event is multicast. |
| IsSpecialName |
Gets a value indicating whether the |
| MemberType |
Gets a MemberTypes value indicating that this member is an event. |
| RaiseMethod |
Gets the method that is called when the event is raised, including non-public methods. |
| RemoveMethod |
Gets the |
Methods
| AddEventHandler(Object, Delegate) |
Adds an event handler to an event source. |
| Equals(Object) |
Returns a value that indicates whether this instance is equal to a specified object. |
| GetAddMethod() |
Returns the method used to add an event handler delegate to the event source. |
| GetAddMethod(Boolean) |
When overridden in a derived class, retrieves the |
| GetHashCode() |
Returns the hash code for this instance. |
| GetOtherMethods() |
Returns the public methods that have been associated with an event in metadata using the |
| GetOtherMethods(Boolean) |
Returns the methods that have been associated with the event in metadata using the |
| GetRaiseMethod() |
Returns the method that is called when the event is raised. |
| GetRaiseMethod(Boolean) |
When overridden in a derived class, returns the method that is called when the event is raised, specifying whether to return non-public methods. |
| GetRemoveMethod(Boolean) |
When overridden in a derived class, retrieves the |
| GetRemoveMethod() |
Returns the method used to remove an event handler delegate from the event source. |
| RemoveEventHandler(Object, Delegate) |
Removes an event handler from an event source. |
Operators
| Equality(EventInfo, EventInfo) |
Indicates whether two EventInfo objects are equal. |
| Inequality(EventInfo, EventInfo) |
Indicates whether two EventInfo objects are not equal. |
Explicit Interface Implementations
| _EventInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) |
Maps a set of names to a corresponding set of dispatch identifiers. |
| _EventInfo.GetType() |
Returns a |
| _EventInfo.GetTypeInfo(UInt32, UInt32, IntPtr) |
Retrieves the type information for an object, which can then be used to get the type information for an interface. |
| _EventInfo.GetTypeInfoCount(UInt32) |
Retrieves the number of type information interfaces that an object provides (either 0 or 1). |
| _EventInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) |
Provides access to properties and methods exposed by an object. |
Extension Methods
Thread Safety
This type is thread safe.