Comparteix a través de

Type.FindMembers(MemberTypes, BindingFlags, MemberFilter, Object) Método

  • Referencia

Definición

Espacio de nombres:
System
Ensamblado:
System.Runtime.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll
Source:
Type.Helpers.cs
Source:
Type.Helpers.cs
Source:
Type.Helpers.cs

Devuelve una matriz filtrada de objetos MemberInfo del tipo del miembro especificado.

public:
 virtual cli::array <System::Reflection::MemberInfo ^> ^ FindMembers(System::Reflection::MemberTypes memberType, System::Reflection::BindingFlags bindingAttr, System::Reflection::MemberFilter ^ filter, System::Object ^ filterCriteria);
public virtual System.Reflection.MemberInfo[] FindMembers (System.Reflection.MemberTypes memberType, System.Reflection.BindingFlags bindingAttr, System.Reflection.MemberFilter? filter, object? filterCriteria);
public virtual System.Reflection.MemberInfo[] FindMembers (System.Reflection.MemberTypes memberType, System.Reflection.BindingFlags bindingAttr, System.Reflection.MemberFilter filter, object filterCriteria);
abstract member FindMembers : System.Reflection.MemberTypes * System.Reflection.BindingFlags * System.Reflection.MemberFilter * obj -> System.Reflection.MemberInfo[]
override this.FindMembers : System.Reflection.MemberTypes * System.Reflection.BindingFlags * System.Reflection.MemberFilter * obj -> System.Reflection.MemberInfo[]
Public Overridable Function FindMembers (memberType As MemberTypes, bindingAttr As BindingFlags, filter As MemberFilter, filterCriteria As Object) As MemberInfo()

Parámetros

memberType
MemberTypes

Combinación bit a bit de los valores de enumeración que indica el tipo de miembro por el que se va a buscar.

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.

filter
MemberFilter

Delegado que realiza las comparaciones y que devuelve true si el miembro inspeccionado coincide con filterCriteria y false en caso contrario.

filterCriteria
Object

Criterios de búsqueda que determinan si se devuelve un miembro en la matriz de objetos MemberInfo.

Los campos de FieldAttributes, MethodAttributes y MethodImplAttributes se pueden usar junto con el delegado FilterAttribute que esta clase proporciona.

Devoluciones

MemberInfo[]

Matriz filtrada de objetos MemberInfo del tipo del miembro especificado.

o bien

Matriz vacía si el objeto Type actual no tiene miembros del tipo memberType que coincidan con los criterios de filtro.

Implementaciones

FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)

Excepciones

ArgumentNullException

filter es null.

Ejemplos

En el ejemplo siguiente se buscan todos los miembros de una clase que coinciden con los criterios de búsqueda especificados y, a continuación, se muestran los miembros coincidentes.

using namespace System;
using namespace System::Reflection;
ref class MyFindMembersClass
{
public:
   static void Test()
   {
      Object^ objTest = gcnew Object;
      Type^ objType = objTest->GetType();
      array<MemberInfo^>^arrayMemberInfo;
      try
      {
         
         //Find all static or public methods in the Object class that match the specified name.
         arrayMemberInfo = objType->FindMembers( MemberTypes::Method, static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Static | BindingFlags::Instance), gcnew MemberFilter( DelegateToSearchCriteria ), "ReferenceEquals" );
         for ( int index = 0; index < arrayMemberInfo->Length; index++ )
            Console::WriteLine( "Result of FindMembers -\t {0}", String::Concat( arrayMemberInfo[ index ], "\n" ) );
      }
      catch ( Exception^ e ) 
      {
         Console::WriteLine( "Exception : {0}", e );
      }

   }

   static bool DelegateToSearchCriteria( MemberInfo^ objMemberInfo, Object^ objSearch )
   {
      
      // Compare the name of the member function with the filter criteria.
      if ( objMemberInfo->Name->Equals( objSearch->ToString() ) )
            return true;
      else
            return false;
   }

};

int main()
{
   MyFindMembersClass::Test();
}
/* The example produces the following output:

Result of FindMembers - Boolean ReferenceEquals(System.Object, System.Object)
*/

using System;
using System.Reflection;

class MyFindMembersClass
{
    public static void Main()
    {
        Object objTest = new Object();
        Type objType = objTest.GetType ();
        MemberInfo[] arrayMemberInfo;
        try
        {
            //Find all static or public methods in the Object class that match the specified name.
            arrayMemberInfo = objType.FindMembers(MemberTypes.Method,
                BindingFlags.Public | BindingFlags.Static| BindingFlags.Instance,
                new MemberFilter(DelegateToSearchCriteria),
                "ReferenceEquals");

            for(int index=0;index < arrayMemberInfo.Length ;index++)
                Console.WriteLine ("Result of FindMembers -\t"+ arrayMemberInfo[index].ToString() +"\n");
        }
        catch (Exception e)
        {
            Console.WriteLine ("Exception : " + e.ToString() );
        }
    }
    public static bool DelegateToSearchCriteria(MemberInfo objMemberInfo, Object objSearch)
    {
        // Compare the name of the member function with the filter criteria.
        if(objMemberInfo.Name.ToString() == objSearch.ToString())
            return true;
        else
            return false;
    }
}
/* The example produces the following output:

Result of FindMembers - Boolean ReferenceEquals(System.Object, System.Object)
*/

open System.Reflection

let delegateToSearchCriteria (objMemberInfo: MemberInfo) (objSearch: obj) =
    // Compare the name of the member function with the filter criteria.
    string objMemberInfo.Name = string objSearch

let objTest = obj ()
let objType = objTest.GetType ()
try
    //Find all static or public methods in the Object class that match the specified name.
    let arrayMemberInfo = 
        objType.FindMembers(MemberTypes.Method, BindingFlags.Public ||| BindingFlags.Static ||| BindingFlags.Instance, MemberFilter delegateToSearchCriteria, "ReferenceEquals")

    for info in arrayMemberInfo do
        printfn $"Result of FindMembers -\t{info}\n"
with e ->
    printfn $"Exception : {e}"

(* The example produces the following output:

Result of FindMembers - Boolean ReferenceEquals(System.Object, System.Object)
*)


Imports System.Reflection

Class MyFindMembersClass

    Public Shared Sub Main()
        Dim objTest As New Object()
        Dim objType As Type = objTest.GetType()
        Dim arrayMemberInfo() As MemberInfo
        Try
            'Find all static or public methods in the Object 
            'class that match the specified name.
            arrayMemberInfo = objType.FindMembers(MemberTypes.Method, _
                              BindingFlags.Public Or BindingFlags.Static _
                              Or BindingFlags.Instance, _
                              New MemberFilter(AddressOf DelegateToSearchCriteria), _
                              "ReferenceEquals")

            Dim index As Integer
            For index = 0 To arrayMemberInfo.Length - 1
                Console.WriteLine("Result of FindMembers -" + ControlChars.Tab + _
                               arrayMemberInfo(index).ToString() + ControlChars.Cr)
            Next index
        Catch e As Exception
            Console.WriteLine("Exception : " + e.ToString())
        End Try
    End Sub

    Public Shared Function DelegateToSearchCriteria _
                            (ByVal objMemberInfo As MemberInfo, _
                             ByVal objSearch As Object) As Boolean
        ' Compare the name of the member function with the filter criteria.
        If objMemberInfo.Name.ToString() = objSearch.ToString() Then
            Return True
        Else
            Return False
        End If
    End Function 'DelegateToSearchCriteria 
End Class
' The example produces the following output:
'
' Result of FindMembers - Boolean ReferenceEquals(System.Object, System.Object)

Comentarios

Este método se puede invalidar mediante una clase derivada.

Los miembros incluyen propiedades, métodos, campos, eventos, etc.

Para que el método recupere correctamente la FindMembers información de miembro, el bindingAttr argumento debe incluir al menos uno de BindingFlags.Instance y BindingFlags.Static, junto con al menos uno de BindingFlags.NonPublic y BindingFlags.Public.

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

  • Especifique BindingFlags.Instance para incluir miembros de instancia en la búsqueda.

  • Especifique BindingFlags.Static para incluir miembros estáticos en la búsqueda.

  • Especifique BindingFlags.Public para incluir miembros públicos en la búsqueda.

  • Especifique BindingFlags.NonPublic que incluya miembros no públicos (es decir, miembros privados, internos y protegidos) en la búsqueda.

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

  • BindingFlags.DeclaredOnly para buscar solo los miembros declarados en Type, no los miembros que simplemente se heredaron.

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

Para obtener el inicializador de clase (constructor estático) mediante este método, debe especificar BindingFlags.Static | BindingFlags.NonPublic (BindingFlags.StaticOrBindingFlags.NonPublic en Visual Basic). También puede obtener el inicializador de clase mediante la TypeInitializer propiedad .

Si el objeto actual Type representa un parámetro de tipo de un tipo genérico o un método genérico, FindMembers procesa los miembros declarados por la restricción de clase y las restricciones de interfaz del parámetro de tipo.

El filter argumento puede ser un delegado personalizado de tipo MemberFiltero puede ser uno de los siguientes delegados predefinidos:

Se aplica a

Consulte también