Type.GetEvent Método

Definición

Espacio de nombres:: System

Ensamblados:: netstandard.dll, System.Runtime.dll

Ensamblado:: System.Runtime.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Obtiene un evento específico declarado o heredado por el objeto actual Type.

Sobrecargas

Nombre	Description
GetEvent(String, BindingFlags)	Cuando se reemplaza en una clase derivada, devuelve el EventInfo objeto que representa el evento especificado mediante las restricciones de enlace especificadas.
GetEvent(String)	Devuelve el EventInfo objeto que representa el evento público especificado.

GetEvent(String, BindingFlags)

Source:: Type.cs

Source:: Type.cs

Source:: Type.cs

Source:: Type.cs

Source:: Type.cs

Cuando se reemplaza en una clase derivada, devuelve el EventInfo objeto que representa el evento especificado mediante las restricciones de enlace especificadas.

public:
 abstract System::Reflection::EventInfo ^ GetEvent(System::String ^ name, System::Reflection::BindingFlags bindingAttr);

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicEvents | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicEvents)]
public abstract System.Reflection.EventInfo? GetEvent(string name, System.Reflection.BindingFlags bindingAttr);

public abstract System.Reflection.EventInfo GetEvent(string name, System.Reflection.BindingFlags bindingAttr);

public abstract System.Reflection.EventInfo? GetEvent(string name, System.Reflection.BindingFlags bindingAttr);

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicEvents | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicEvents)>]
abstract member GetEvent : string * System.Reflection.BindingFlags -> System.Reflection.EventInfo

abstract member GetEvent : string * System.Reflection.BindingFlags -> System.Reflection.EventInfo

Public MustOverride Function GetEvent (name As String, bindingAttr As BindingFlags) As EventInfo

Parámetros

name: String

Nombre de un evento declarado o heredado por el objeto actual Type.

bindingAttr: BindingFlags

Combinación bit a bit de los valores de enumeración que especifican cómo se realiza la búsqueda.

O bien

Default para devolver null.

Devoluciones

EventInfo

Objeto que representa el evento especificado declarado o heredado por el objeto actual Type, si se encuentra; de lo contrario, null.

Implementaciones

GetEvent(String, BindingFlags)

Atributos: DynamicallyAccessedMembersAttribute

Excepciones

ArgumentNullException

name es null.

Ejemplos

En el ejemplo de código siguiente se usa el método GetEvent(String, BindingFlags) para buscar un tipo de evento público o no público denominado "Click" que no es static (Shared en Visual Basic).

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);
        }
    }
}

open System
open System.Reflection
open System.Security

try
    // Creates a bitmask based on BindingFlags.
    let myBindingFlags = BindingFlags.Instance ||| BindingFlags.Public ||| BindingFlags.NonPublic
    let myTypeBindingFlags = typeof<System.Windows.Forms.Button>
    let myEventBindingFlags = myTypeBindingFlags.GetEvent("Click", myBindingFlags)
    if myEventBindingFlags <> null then
        printfn $"Looking for the Click event in the Button class with the specified BindingFlags.\n{myEventBindingFlags}"
    else
        printfn "The Click event is not available with the Button class."
with
| :? SecurityException as e ->
    printfn "An exception occurred."
    printfn $"Message :{e.Message}"
| :? ArgumentNullException as e ->
    printfn "An exception occurred."
    printfn $"Message :{e.Message}"
| e ->
    printfn $"The following exception was raised : {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

Comentarios

Las marcas de filtro siguientes BindingFlags se pueden usar para definir qué eventos se van a incluir en la búsqueda:

Debe especificar ya sea BindingFlags.Instance o BindingFlags.Static para obtener una devolución.
Especifique BindingFlags.Public para incluir eventos públicos en la búsqueda.
Especifique BindingFlags.NonPublic para incluir eventos no públicos (es decir, eventos privados, internos y protegidos) en la búsqueda.
Especifique BindingFlags.FlattenHierarchy para incluir public y protected los miembros estáticos en la jerarquía; private no se incluyen los miembros estáticos de las clases heredadas.

Se pueden usar las marcas modificadores siguientes BindingFlags para cambiar el funcionamiento de la búsqueda:

BindingFlags.IgnoreCase para pasar por alto el caso de name.
BindingFlags.DeclaredOnly para buscar solo los eventos declarados en Type, no los eventos que simplemente se heredaron.

Consulte System.Reflection.BindingFlags para obtener más información.

Un evento se considera público para la reflexión si tiene al menos un método o descriptor de acceso público. De lo contrario, el evento se considera privado y debe usar BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static (en Visual Basic, combine los valores mediante Or) para obtenerlo.

Si el objeto actual Type representa un tipo genérico construido, este método devuelve el EventInfo con los parámetros de tipo reemplazados por los argumentos de tipo adecuados.

Si el objeto actual Type representa un parámetro de tipo en la definición de un tipo genérico o un método genérico, este método busca en los eventos de la restricción de clase.

Consulte también

Se aplica a

GetEvent(String)

Source:: Type.cs

Source:: Type.cs

Source:: Type.cs

Source:: Type.cs

Source:: Type.cs

Devuelve el EventInfo objeto que representa el evento público especificado.

public:
 System::Reflection::EventInfo ^ GetEvent(System::String ^ name);

public:
 virtual System::Reflection::EventInfo ^ GetEvent(System::String ^ name);

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicEvents)]
public System.Reflection.EventInfo? GetEvent(string name);

public System.Reflection.EventInfo GetEvent(string name);

public System.Reflection.EventInfo? GetEvent(string name);

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicEvents)>]
member this.GetEvent : string -> System.Reflection.EventInfo

member this.GetEvent : string -> System.Reflection.EventInfo

abstract member GetEvent : string -> System.Reflection.EventInfo
override this.GetEvent : string -> System.Reflection.EventInfo

Public Function GetEvent (name As String) As EventInfo

Parámetros

name: String

Cadena que contiene el nombre de un evento declarado o heredado por el objeto actual Type.

Devoluciones

EventInfo

Objeto que representa el evento público especificado declarado o heredado por el objeto actual Type, si se encuentra; de lo contrario, null.

Implementaciones

GetEvent(String)

Atributos: DynamicallyAccessedMembersAttribute

Excepciones

ArgumentNullException

name es null.

Ejemplos

En el ejemplo siguiente se crea un EventInfo objeto y se obtiene el evento de una clase de botón para el evento especificado.

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

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

            Type myType = typeof(System.Windows.Forms.Button);
            EventInfo myEvent = myType.GetEvent("Click");
            if(myEvent != null)
            {
                Console.WriteLine("Looking for the Click event in the Button class.");
                Console.WriteLine(myEvent.ToString());
            }
            else
            {
                Console.WriteLine("The Click event is not available in 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);
        }
    }
}

open System
open System.Security

try
    let myType = typeof<System.Windows.Forms.Button>
    let myEvent = myType.GetEvent "Click"
    if myEvent <> null then
        printfn $"Looking for the Click event in the Button class.\n{myEvent}"
    else
        printfn "The Click event is not available in the Button class."
with
| :? SecurityException as e ->
    printfn "An exception occurred."
    printfn $"Message :{e.Message}"
| :? ArgumentNullException as e ->
    printfn "An exception occurred."
    printfn $"Message :{e.Message}"
| e ->
    printfn $"The following exception was raised : {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
            Dim myType As Type = GetType(System.Windows.Forms.Button)
            Dim myEvent As EventInfo = myType.GetEvent("Click")
            If Not (myEvent Is Nothing) Then
                Console.WriteLine(ControlChars.Cr + "Looking for the Click event in the Button class.")
                Console.WriteLine(ControlChars.Cr + myEvent.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

Comentarios

La búsqueda de name distingue mayúsculas de minúsculas. La búsqueda incluye eventos de instancia pública y estática.

En la tabla siguiente se muestra qué miembros de una clase base devuelven los métodos Get al reflexionar sobre un tipo.

Tipo de miembro	Static	No estático
Constructor	No	No
Campo	No	Yes. Un campo siempre se oculta según el nombre y la firma.
Event	No aplicable	La regla del sistema de tipos común es que la herencia es igual a la de los métodos que implementan la propiedad. La reflexión trata las propiedades como hide-by-name-and-signature. Vea la nota 2 a continuación.
Método	No	Yes. Un método (tanto virtual como no virtual) puede ocultarse por nombre o por nombre y firma.
Tipo anidado	No	No
Propiedad	No aplicable	La regla del sistema de tipos común es que la herencia es igual a la de los métodos que implementan la propiedad. La reflexión trata las propiedades como hide-by-name-and-signature. Vea la nota 2 a continuación.

En ocultar por nombre y firma se tienen en cuenta todas las partes de la firma, incluidos modificadores personalizados, tipos de valor devuelto, tipos de parámetros, sentinels y convenciones de llamada no administradas. Se trata de una comparación binaria.
En reflexión, las propiedades y eventos se ocultan por nombre y firma. Si tiene una propiedad con un descriptor de acceso get y set en la clase base, pero la clase derivada solo tiene un descriptor de acceso get, la propiedad de clase derivada oculta la propiedad de clase base y no podrá acceder al establecedor en la clase base.
Los atributos personalizados no forman parte del sistema de tipos común.

Si el objeto actual Type representa un tipo genérico construido, este método devuelve el EventInfo con los parámetros de tipo reemplazados por los argumentos de tipo adecuados.

Si el objeto actual Type representa un parámetro de tipo en la definición de un tipo genérico o un método genérico, este método busca en los eventos de la restricción de clase.

Consulte también

Se aplica a

Comentarios

¿Le ha resultado útil esta página?