Type.GetEvents Metodo

  • Riferimento

Definizione

Spazio dei nomi:
System
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Ottiene gli eventi dichiarati o ereditati dall'oggetto Type corrente.

Overload

GetEvents()

Restituisce tutti gli eventi pubblici dichiarati o ereditati dall'oggetto Type corrente.
GetEvents(BindingFlags)

Quando ne viene eseguito l'override in una classe derivata, cerca gli eventi dichiarati o ereditati dall'oggetto Type corrente, usando i vincoli di associazione specificati.

GetEvents()

Source:
Type.cs
Source:
Type.cs
Source:
Type.cs

Restituisce tutti gli eventi pubblici dichiarati o ereditati dall'oggetto Type corrente.

public:
 virtual cli::array <System::Reflection::EventInfo ^> ^ GetEvents();
public virtual System.Reflection.EventInfo[] GetEvents ();
abstract member GetEvents : unit -> System.Reflection.EventInfo[]
override this.GetEvents : unit -> System.Reflection.EventInfo[]
Public Overridable Function GetEvents () As EventInfo()

Restituisce

EventInfo[]

Matrice di oggetti EventInfo che rappresentano tutti gli eventi pubblici dichiarati o ereditati dall'oggetto Type corrente.

-oppure-

Matrice vuota di tipo EventInfo, se per l'oggetto Type corrente non esistono eventi pubblici.

Implementazioni

GetEvents()

Esempio

Nell'esempio seguente viene ottenuta una matrice di EventInfo oggetti , vengono ottenuti tutti gli eventi per una Button classe e vengono visualizzati i nomi degli eventi. Per compilare l'esempio di Visual Basic, usare la riga di comando seguente:

vbc type_getevents1.vb /r:System.Windows.Forms.dll /r:System.dll

#using <System.dll>
#using <System.Windows.Forms.dll>
#using <System.Drawing.dll>

using namespace System;
using namespace System::Reflection;
using namespace System::Security;

int main()
{
   try
   {
      Type^ myType = System::Windows::Forms::Button::typeid;
      array<EventInfo^>^myEvents = myType->GetEvents();
      Console::WriteLine( "The events on the Button class are: " );
      for ( int index = 0; index < myEvents->Length; index++ )
      {
         Console::WriteLine( myEvents[ index ] );

      }
   }
   catch ( SecurityException^ e ) 
   {
      Console::WriteLine( "SecurityException: {0}", e->Message );
   }
   catch ( ArgumentNullException^ e ) 
   {
      Console::WriteLine( "ArgumentNullException: {0}", e->Message );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "Exception: {0}", e->Message );
   }
}

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

class EventsSample
{
    public static void Main()
    {
        try
        {
            // Creates a bitmask based on BindingFlags.
            BindingFlags myBindingFlags = BindingFlags.Instance | BindingFlags.Public;
            Type myTypeEvent = typeof(System.Windows.Forms.Button);
            EventInfo[] myEventsBindingFlags = myTypeEvent.GetEvents(myBindingFlags);
            Console.WriteLine("\nThe events on the Button class with the specified BindingFlags are : ");
            for (int index = 0; index < myEventsBindingFlags.Length; index++)
            {
                Console.WriteLine(myEventsBindingFlags[index].ToString());
            }
        }
        catch(SecurityException e)
        {
            Console.WriteLine("SecurityException :" + e.Message);
        }
        catch(ArgumentNullException e)
        {
            Console.WriteLine("ArgumentNullException : " + e.Message);
        }
        catch(Exception e)
        {
            Console.WriteLine("Exception : " + e.Message);
        }
    }
}

open System
open System.Reflection
open System.Security

try
    // Creates a bitmask based on BindingFlags.
    let myBindingFlags = BindingFlags.Instance ||| BindingFlags.Public
    let myTypeEvent = typeof<System.Windows.Forms.Button>
    let myEventsBindingFlags = myTypeEvent.GetEvents myBindingFlags
    printfn "\nThe events on the Button class with the specified BindingFlags are : "
    for flag in myEventsBindingFlags do
        printfn $"{flag}"
with
| :? SecurityException as e ->
    printfn $"SecurityException: {e.Message}"
| :? ArgumentNullException as e ->
    printfn $"ArgumentNullException: {e.Message}"
| e ->
    printfn $"Exception : {e.Message}"

Imports System.Reflection
Imports System.Security

' Compile this sample using the following command line:
' vbc type_getevents.vb /r:"System.Windows.Forms.dll" /r:"System.dll"

Class EventsSample

    Public Shared Sub Main()
        Try
            ' Creates a bitmask based on BindingFlags.
            Dim myBindingFlags As BindingFlags = BindingFlags.Instance Or BindingFlags.Public
            Dim myTypeEvent As Type = GetType(System.Windows.Forms.Button)
            Dim myEventsBindingFlags As EventInfo() = myTypeEvent.GetEvents(myBindingFlags)
            Console.WriteLine(ControlChars.Cr + "The events on the Button class with the specified BindingFlags are : ")
            Dim index As Integer
            For index = 0 To myEventsBindingFlags.Length - 1
                Console.WriteLine(myEventsBindingFlags(index).ToString())
            Next index
        Catch e As SecurityException
            Console.WriteLine(("SecurityException :" + e.Message))
        Catch e As ArgumentNullException
            Console.WriteLine(("ArgumentNullException : " + e.Message))
        Catch e As Exception
            Console.WriteLine(("Exception : " + e.Message))
        End Try
    End Sub
End Class

Commenti

Un evento viene considerato pubblico per la reflection se ha almeno un metodo o una funzione di accesso pubblica. In caso contrario, l'evento è considerato privato ed è necessario usare BindingFlags.NonPublic | | BindingFlags.InstanceBindingFlags.Static (in Visual Basic, combinare i valori usando Or) per ottenerlo.

In .NET 6 e versioni precedenti, il GetEvents metodo non restituisce eventi in un ordine specifico, ad esempio ordine alfabetico o di dichiarazione. Il codice non deve dipendere dall'ordine in cui vengono restituiti gli eventi, perché tale ordine varia. Tuttavia, a partire da .NET 7, l'ordinamento è deterministico in base all'ordinamento dei metadati nell'assembly.

Questo metodo può essere sottoposto a override da una classe derivata.

Nella tabella seguente vengono illustrati i membri di una classe base restituiti dai Get metodi quando si riflette su un tipo.

Tipo di membro Static Non statico
Costruttore No No
Campo No Sì. Un campo è sempre hide-by-name-and-signature.
Evento Non applicabile La regola di sistema dei tipi comune è che l'ereditarietà è uguale a quella dei metodi che implementano la proprietà . La reflection considera le proprietà come hide-by-name-and-signature. Vedere la nota 2 di seguito.
Metodo No Sì. Un metodo (sia virtuale che non virtuale) può essere hide-by-name o hide-by-name-and-signature.
Tipo annidato No No
Proprietà Non applicabile La regola di sistema dei tipi comune è che l'ereditarietà è uguale a quella dei metodi che implementano la proprietà . La reflection considera le proprietà come hide-by-name-and-signature. Vedere la nota 2 di seguito.

  1. Hide-by-name-and-signature considera tutte le parti della firma, inclusi modificatori personalizzati, tipi restituiti, tipi di parametro, sentinel e convenzioni di chiamata non gestite. Si tratta di un confronto binario.

  2. Per la reflection, le proprietà e gli eventi sono hide-by-name-and-signature. Se nella classe base è presente una proprietà con una funzione di accesso get e una funzione di accesso set, ma la classe derivata ha solo una funzione di accesso get, la proprietà della classe derivata nasconde la proprietà della classe base e non sarà possibile accedere al setter nella classe base.

  3. Gli attributi personalizzati non fanno parte del sistema di tipi comuni.

Se l'oggetto corrente Type rappresenta un tipo generico costruito, questo metodo restituisce gli EventInfo oggetti con i parametri di tipo sostituiti dagli argomenti di tipo appropriati.

Se l'oggetto corrente Type rappresenta un parametro di tipo nella definizione di un tipo generico o di un metodo generico, questo metodo cerca gli eventi del vincolo di classe.

Vedi anche

Si applica a

GetEvents(BindingFlags)

Source:
Type.cs
Source:
Type.cs
Source:
Type.cs

Quando ne viene eseguito l'override in una classe derivata, cerca gli eventi dichiarati o ereditati dall'oggetto Type corrente, usando i vincoli di associazione specificati.

public:
 abstract cli::array <System::Reflection::EventInfo ^> ^ GetEvents(System::Reflection::BindingFlags bindingAttr);
public abstract System.Reflection.EventInfo[] GetEvents (System.Reflection.BindingFlags bindingAttr);
abstract member GetEvents : System.Reflection.BindingFlags -> System.Reflection.EventInfo[]
Public MustOverride Function GetEvents (bindingAttr As BindingFlags) As EventInfo()

Parametri

bindingAttr
BindingFlags

Combinazione bit per bit di valori di enumerazione che specifica il modo in cui viene eseguita la ricerca.

-oppure-

Default per restituire una matrice vuota.

Restituisce

EventInfo[]

Matrice di oggetti EventInfo che rappresentano tutti gli eventi dichiarati o ereditati dalla classe Type corrente e che corrispondono ai vincoli di associazione specificati.

-oppure-

Matrice vuota di tipo EventInfo, se l'oggetto Type corrente non dispone di eventi oppure se nessuno degli eventi corrisponde ai vincoli di binding.

Implementazioni

GetEvents(BindingFlags)

Esempio

Nell'esempio seguente viene ottenuta una matrice di oggetti che corrispondono ai flag di EventInfo associazione specificati, ottiene tutti gli eventi per una Button classe e visualizza i nomi degli eventi. Per compilare l'esempio di Visual Basic, usare la riga di comando seguente:

vbc type_getevents2.vb /r:System.Windows.Forms.dll /r:System.dll

#using <System.dll>
#using <System.Windows.Forms.dll>
#using <System.Drawing.dll>

using namespace System;
using namespace System::Reflection;
using namespace System::Security;

int main()
{
   try
   {
      
      // Create a bitmask based on BindingFlags.
      BindingFlags myBindingFlags = static_cast<BindingFlags>(BindingFlags::Instance | BindingFlags::Public);
      Type^ myTypeEvent = System::Windows::Forms::Button::typeid;
      array<EventInfo^>^myEventsBindingFlags = myTypeEvent->GetEvents( myBindingFlags );
      Console::WriteLine( "\nThe events on the Button class with the specified BindingFlags are:" );
      for ( int index = 0; index < myEventsBindingFlags->Length; index++ )
      {
         Console::WriteLine( myEventsBindingFlags[ index ] );

      }
   }
   catch ( SecurityException^ e ) 
   {
      Console::WriteLine( "SecurityException: {0}", e->Message );
   }
   catch ( ArgumentNullException^ e ) 
   {
      Console::WriteLine( "ArgumentNullException: {0}", e->Message );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "Exception: {0}", e->Message );
   }
}

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

class EventsSample
{
    public static void Main()
    {
        try
        {
            // Create a bitmask based on BindingFlags.
            BindingFlags myBindingFlags = BindingFlags.Instance | BindingFlags.Public;
            Type myTypeEvent = typeof(System.Windows.Forms.Button);
            EventInfo[] myEventsBindingFlags = myTypeEvent.GetEvents(myBindingFlags);
            Console.WriteLine("\nThe events on the Button class with the specified BindingFlags are:");
            for (int index = 0; index < myEventsBindingFlags.Length; index++)
            {
                Console.WriteLine(myEventsBindingFlags[index].ToString());
            }
        }
        catch(SecurityException e)
        {
            Console.WriteLine("SecurityException:" + e.Message);
        }
        catch(ArgumentNullException e)
        {
            Console.WriteLine("ArgumentNullException: " + e.Message);
        }
        catch(Exception e)
        {
            Console.WriteLine("Exception: " + e.Message);
        }
    }
}

open System
open System.Reflection
open System.Security

try
    // Creates a bitmask based on BindingFlags.
    let myBindingFlags = BindingFlags.Instance ||| BindingFlags.Public
    let myTypeEvent = typeof<System.Windows.Forms.Button>
    let myEventsBindingFlags = myTypeEvent.GetEvents myBindingFlags
    printfn "\nThe events on the Button class with the specified BindingFlags are : "
    for flag in myEventsBindingFlags do
        printfn $"{flag}"
with
| :? SecurityException as e ->
    printfn $"SecurityException: {e.Message}"
| :? ArgumentNullException as e ->
    printfn $"ArgumentNullException: {e.Message}"
| e ->
    printfn $"Exception : {e.Message}"

Imports System.Reflection
Imports System.Security
Imports System.Windows.Forms

Class EventsSample

    Public Shared Sub Main()
        Try
            ' Create a bitmask based on BindingFlags.
            Dim myBindingFlags As BindingFlags = BindingFlags.Instance Or BindingFlags.Public
            Dim myTypeEvent As Type = GetType(System.Windows.Forms.Button)
            Dim myEventsBindingFlags As EventInfo() = myTypeEvent.GetEvents(myBindingFlags)
            Console.WriteLine(ControlChars.Cr + "The events on the Button class with the specified BindingFlags are:")
            Dim index As Integer
            For index = 0 To myEventsBindingFlags.Length - 1
                Console.WriteLine(myEventsBindingFlags(index).ToString())
            Next index
        Catch e As SecurityException
            Console.WriteLine("SecurityException:" + e.Message)
        Catch e As ArgumentNullException
            Console.WriteLine("ArgumentNullException: " + e.Message)
        Catch e As Exception
            Console.WriteLine("Exception: " + e.Message)
        End Try
    End Sub
End Class

Commenti

In .NET 6 e versioni precedenti, il GetEvents metodo non restituisce eventi in un ordine specifico, ad esempio ordine alfabetico o di dichiarazione. Il codice non deve dipendere dall'ordine in cui vengono restituiti gli eventi, perché tale ordine varia. Tuttavia, a partire da .NET 7, l'ordinamento è deterministico in base all'ordinamento dei metadati nell'assembly.

È possibile usare i flag di filtro seguenti BindingFlags per definire gli eventi da includere nella ricerca:

  • È necessario specificare BindingFlags.Instance o BindingFlags.Static per ottenere un ritorno.

  • Specificare BindingFlags.Public per includere gli eventi pubblici nella ricerca.

  • Specificare BindingFlags.NonPublic di includere eventi non pubblici (ovvero eventi privati, interni e protetti) nella ricerca. Vengono restituiti solo gli eventi protetti e interni nelle classi di base; gli eventi privati nelle classi di base non vengono restituiti.

  • Specificare BindingFlags.FlattenHierarchy di includere public e protected membri statici fino alla gerarchia. private I membri statici nelle classi ereditate non sono inclusi.

Per modificare il funzionamento della ricerca, è possibile usare i flag di modificatore seguenti BindingFlags :

  • BindingFlags.DeclaredOnly per cercare solo gli eventi dichiarati in Type, non gli eventi semplicemente ereditati.

Per altre informazioni, vedere System.Reflection.BindingFlags.

Un evento viene considerato pubblico per la reflection se ha almeno un metodo o una funzione di accesso pubblica. In caso contrario, l'evento è considerato privato ed è necessario usare BindingFlags.NonPublic | | BindingFlags.InstanceBindingFlags.Static (in Visual Basic, combinare i valori usando Or) per ottenerlo.

Se l'oggetto corrente Type rappresenta un tipo generico costruito, questo metodo restituisce gli EventInfo oggetti con i parametri di tipo sostituiti dagli argomenti di tipo appropriati.

Se l'oggetto corrente Type rappresenta un parametro di tipo nella definizione di un tipo generico o di un metodo generico, questo metodo cerca gli eventi del vincolo di classe.

Vedi anche

Si applica a