EventInfo Classe

Definição

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

Herança

Object

MemberInfo

EventInfo

Derivado

System.Runtime.InteropServices.ComAwareEventInfo

Atributos

ClassInterfaceAttribute ComVisibleAttribute SerializableAttribute

Implementações

_EventInfo

Exemplos

O código a seguir obtém um EventInfo objeto para o Click evento da 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

Comentários

Use a EventInfo classe para inspecionar eventos e conectar manipuladores de eventos, conforme mostrado no código de exemplo para o AddEventHandler método .

Os eventos são usados com delegados. Um ouvinte de eventos cria uma instância de um delegado manipulador de eventos que é invocado sempre que o evento é gerado por uma origem do evento. Para se conectar à origem do evento, o ouvinte de eventos adiciona esse delegado à lista de invocação na origem. Quando o evento é acionado, o método invoke do delegado do manipulador de eventos é chamado. Há suporte para notificações de evento multicast e de conversão única. Os Add métodos e Remove , bem como a classe delegada do manipulador de eventos associada a um evento, devem ser marcados nos metadados.

Delegados são ponteiros de função orientados a objetos. Em C ou C++, um ponteiro de função é uma referência a um método . Em contraste com o ponteiro de função C ou C++, um delegado contém duas referências: uma referência a um método e uma referência a um objeto que dá suporte ao método . Os delegados podem invocar um método sem saber o tipo de classe que declara ou herda o método . Os delegados só precisam saber o tipo de retorno e a lista de parâmetros do método.

O modelo de evento funciona igualmente bem para delegados de conversão única e multicast. Quando o método de invocação do delegado for chamado, apenas um único objeto terá um método chamado nele. Um modificador multicast pode ser aplicado a uma declaração de delegado, que permite que vários métodos sejam chamados quando o método invoke do delegado é chamado.

Chamar ICustomAttributeProvider.GetCustomAttributes quando EventInfo o inherit parâmetro de GetCustomAttributes é true não percorre a hierarquia de tipos. Use System.Attribute para herdar atributos personalizados.

Notas aos Implementadores

Ao herdar de EventInfo, você deve substituir os seguintes membros: GetAddMethod(Boolean), GetRemoveMethod(Boolean)e GetRaiseMethod(Boolean).

Construtores

Propriedades

Métodos

Operadores

Implantações explícitas de interface

Métodos de Extensão

Aplica-se a

Acesso thread-safe

Este tipo é thread-safe.