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

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

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

Devoluciones

Implementaciones

Excepciones

Ejemplos

En el ejemplo siguiente se buscan todos los miembros de una clase que coincidan con los criterios de búsqueda especificados y, a continuación, se muestran los miembros coincidentes.The following example finds all the members in a class that match the specified search criteria, and then displays the matched members.

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

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

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

Comentarios

Este método se puede invalidar mediante una clase derivada.This method can be overridden by a derived class.

Los miembros incluyen propiedades, métodos, campos, eventos, etc.Members include properties, methods, fields, events, and so on.

Para que el método FindMembers recupere correctamente la información de los miembros, el argumento bindingAttr debe incluir al menos una de BindingFlags.Instance y BindingFlags.Static, junto con al menos una de BindingFlags.NonPublic y BindingFlags.Public.For the FindMembers method to successfully retrieve member information, the bindingAttr argument must include at least one of BindingFlags.Instance and BindingFlags.Static, along with at least one of BindingFlags.NonPublic and BindingFlags.Public.

Se pueden usar las siguientes marcas de filtro de BindingFlags para definir los miembros que se incluirán en la búsqueda:The following BindingFlags filter flags can be used to define which members to include in the search:

• Especifique BindingFlags.Instance para incluir miembros de instancia en la búsqueda.Specify BindingFlags.Instance to include instance members in the search.

• Especifique BindingFlags.Static para incluir miembros estáticos en la búsqueda.Specify BindingFlags.Static to include static members in the search.

• Especifique BindingFlags.Public para incluir miembros públicos en la búsqueda.Specify BindingFlags.Public to include public members in the search.

• Especifique BindingFlags.NonPublic para incluir miembros no públicos (es decir, miembros privados, internos y protegidos) en la búsqueda.Specify BindingFlags.NonPublic to include non-public members (that is, private, internal, and protected members) in the search.

Se pueden usar las siguientes marcas de modificador de BindingFlags para cambiar el funcionamiento de la búsqueda:The following BindingFlags modifier flags can be used to change how the search works:

• BindingFlags.DeclaredOnly para buscar solo los miembros declarados en el Type, no los miembros que se han heredado simplemente.BindingFlags.DeclaredOnly to search only the members declared on the Type, not members that were simply inherited.

Vea System.Reflection.BindingFlags para obtener más información.See System.Reflection.BindingFlags for more information.

Para obtener el inicializador de clase (constructor estático) con este método, debe especificar BindingFlags.Static | BindingFlags.NonPublic (BindingFlags.StaticOrBindingFlags.NonPublic en Visual Basic).To get the class initializer (static constructor) using this method, you must specify BindingFlags.Static | BindingFlags.NonPublic (BindingFlags.StaticOrBindingFlags.NonPublic in Visual Basic). También puede obtener el inicializador de clase mediante la propiedad TypeInitializer.You can also get the class initializer using the TypeInitializer property.

Si el Type actual representa un parámetro de tipo de un tipo genérico o de 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.If the current Type represents a type parameter of a generic type or generic method, FindMembers processes any members declared by the class constraint and the interface constraints of the type parameter.

El filter argumento puede ser un delegado personalizado de tipo MemberFiltero puede ser uno de los siguientes delegados predefinidos:The filter argument can be a custom delegate of type MemberFilter, or it can be one of the following predefined delegates:

• Type.FilterAttribute, que usa una máscara deFieldAttributes, MethodAttributeso MethodImplAttributes como valor filterCriteria.Type.FilterAttribute, which uses aFieldAttributes, MethodAttributes, or MethodImplAttributes bitmask as the filterCriteria value.

• Type.FilterName, que realiza una comparación con distinción entre mayúsculas y minúsculas de cada nombre de miembro con la cadena pasada a filterCriteria.Type.FilterName, which performs a case-sensitive comparison of each member name with the string passed to filterCriteria.

• Type.FilterNameIgnoreCase, que realiza una comparación sin distinción entre mayúsculas y minúsculas de cada nombre de miembro con la cadena pasada a filterCriteria.Type.FilterNameIgnoreCase, which performs a case-insensitive comparison of each member name with the string passed to filterCriteria.

Se aplica a

Consulte también:

• MemberInfo
• BindingFlags
• DefaultBinder
• GetMember(String)
• GetMembers()
• GetDefaultMembers()