EventInfo Classe

Définition

public ref class EventInfo abstract : System::Reflection::MemberInfo

public ref class EventInfo abstract : System::Reflection::MemberInfo, System::Runtime::InteropServices::_EventInfo

public abstract class EventInfo : System.Reflection.MemberInfo

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public abstract class EventInfo : System.Reflection.MemberInfo, System.Runtime.InteropServices._EventInfo

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public abstract class EventInfo : System.Reflection.MemberInfo, System.Runtime.InteropServices._EventInfo

type EventInfo = class
    inherit MemberInfo

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type EventInfo = class
    inherit MemberInfo
    interface _EventInfo

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
[<System.Serializable>]
type EventInfo = class
    inherit MemberInfo
    interface _EventInfo

Public MustInherit Class EventInfo
Inherits MemberInfo

Public MustInherit Class EventInfo
Inherits MemberInfo
Implements _EventInfo

Héritage

Object

MemberInfo

EventInfo

Dérivé

System.Runtime.InteropServices.ComAwareEventInfo

Attributs

ClassInterfaceAttribute ComVisibleAttribute SerializableAttribute

Implémente

_EventInfo

Exemples

Le code suivant obtient un EventInfo objet pour l’événement Click de la Button classe .

#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.Reflection
Imports System.Security

' 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
End Class

Remarques

Utilisez la EventInfo classe pour inspecter les événements et connecter des gestionnaires d’événements, comme indiqué dans l’exemple de code de la AddEventHandler méthode.

Les événements sont utilisés avec les délégués. Un écouteur d’événements instancie un délégué de gestionnaire d’événements appelé chaque fois que l’événement est déclenché par une source d’événement. Pour se connecter à la source d’événement, l’écouteur d’événements ajoute ce délégué à la liste d’appels sur la source. Lorsque l’événement est déclenché, la méthode invoke du délégué du gestionnaire d’événements est appelée. Les notifications d’événements de multidiffusion et de cast unique sont prises en charge. Les Add méthodes et Remove , ainsi que la classe déléguée du gestionnaire d’événements associée à un événement, doivent être marquées dans les métadonnées.

Les délégués sont des pointeurs de fonction orientés objet. En C ou C++, un pointeur de fonction est une référence à une méthode. Contrairement au pointeur de fonction C ou C++, un délégué contient deux références : une référence à une méthode et une référence à un objet qui prend en charge la méthode. Les délégués peuvent appeler une méthode sans connaître le type de classe qui déclare ou hérite de la méthode. Les délégués doivent uniquement connaître le type de retour et la liste de paramètres de la méthode.

Le modèle d’événement fonctionne également bien pour les délégués mono cast et multidiffusion. Lorsque la méthode invoke du délégué est appelée, une méthode est appelée sur un seul objet. Un modificateur de multidiffusion peut être appliqué à une déclaration de délégué, ce qui permet d’appeler plusieurs méthodes lorsque la méthode invoke du délégué est appelée.

L’appel ICustomAttributeProvider.GetCustomAttributes de on EventInfo lorsque le inherit paramètre de GetCustomAttributes est true n’exécute pas la hiérarchie de types. Utilisez System.Attribute pour hériter d’attributs personnalisés.

Notes pour les responsables de l’implémentation

Lorsque vous héritez de EventInfo, vous devez remplacer les membres suivants : GetAddMethod(Boolean), GetRemoveMethod(Boolean)et GetRaiseMethod(Boolean).

Constructeurs

Propriétés

Méthodes

Opérateurs

Implémentations d’interfaces explicites

Méthodes d’extension

S’applique à

Cohérence de thread

Ce type est thread-safe.