Module.FindTypes(TypeFilter, Object) Método

Definición

Espacio de nombres:

System.Reflection

Ensamblado:

System.Runtime.dll

Source:

Module.cs

Devuelve una matriz de las clases aceptadas por el filtro y los criterios de filtro dados.

public:
 virtual cli::array <Type ^> ^ FindTypes(System::Reflection::TypeFilter ^ filter, System::Object ^ filterCriteria);

public virtual Type[] FindTypes (System.Reflection.TypeFilter? filter, object? filterCriteria);

abstract member FindTypes : System.Reflection.TypeFilter * obj -> Type[]
override this.FindTypes : System.Reflection.TypeFilter * obj -> Type[]

Public Overridable Function FindTypes (filter As TypeFilter, filterCriteria As Object) As Type()

Parámetros

filter

TypeFilter

Delegado utilizado para filtrar las clases.

filterCriteria

Object

Objeto utilizado para filtrar las clases.

Devoluciones

Type[]

Matriz de tipo Type que contiene las clases ya aceptadas por el filtro.

Excepciones

ReflectionTypeLoadException

No se pudieron cargar una o más clases en un módulo.

Ejemplos

En el siguiente ejemplo se muestra el FindTypes método.

using namespace System;
using namespace System::Reflection;
using namespace System::Collections;
public ref class MySecondClass{};


// This class does not fit the filter criterion My*.
public ref class YourClass{};

int main()
{
   array<Module^>^moduleArray;
   moduleArray = Assembly::GetExecutingAssembly()->GetModules( false );
   
   // In a simple project with only one module, the module at index
   // 0 will be the module containing these classes.
   Module^ myModule = moduleArray[ 0 ];
   array<Type^>^tArray;
   tArray = myModule->FindTypes( Module::FilterTypeName, "My*" );
   IEnumerator^ myEnum = tArray->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Type^ t = safe_cast<Type^>(myEnum->Current);
      Console::WriteLine( "Found a module beginning with My*: {0}.", t->Name );
   }
}

using System;
using System.Reflection;

namespace ReflectionModule_Examples
{
    class MyMainClass
    {
        static void Main()
        {
            Module[] moduleArray;
            
            moduleArray = typeof(MyMainClass).Assembly.GetModules(false);
            
            // In a simple project with only one module, the module at index
            // 0 will be the module containing these classes.
            Module myModule = moduleArray[0];

            Type[] tArray;

            tArray = myModule.FindTypes(Module.FilterTypeName, "My*");
            
            foreach(Type t in tArray)
            {
                Console.WriteLine("Found a module beginning with My*: {0}.", t.Name);
            }
        }
    }

    class MySecondClass
    {
    }

    // This class does not fit the filter criteria My*.
    class YourClass
    {
    }
}

Imports System.Reflection

Namespace ReflectionModule_Examples
    Class MyMainClass
        Shared Sub Main()
            Dim moduleArray() As [Module]

            moduleArray = GetType(MyMainClass).Assembly.GetModules(False)

            ' In a simple project with only one module, the module at index
            ' 0 will be the module containing these classes.
            Dim myModule As [Module] = moduleArray(0)

            Dim tArray() As Type

            tArray = myModule.FindTypes([Module].FilterTypeName, "My*")

            Dim t As Type
            For Each t In tArray
                Console.WriteLine("Found a module beginning with My*: {0}", t.Name)
            Next t
        End Sub
    End Class

    Class MySecondClass
    End Class

    ' This class does not fit the filter criteria My*.
    Class YourClass
    End Class
End Namespace 'ReflectionModule_Examples

Comentarios

ReflectionTypeLoadException es una excepción de carga de clase especial. La ReflectionTypeLoadException.Types propiedad contiene la matriz de clases que se definieron en el módulo y se cargaron. Esta matriz puede contener algunos valores NULL. La ReflectionTypeLoadException.LoaderExceptions propiedad es una matriz de excepciones que representan las excepciones producidas por el cargador de clases. Los agujeros de la matriz de clases se alinean con las excepciones.

Se llama al delegado proporcionado por filter para cada clase del módulo, pasando el Type objeto que representa la clase, así como el especificado filterCriteria. Si filter devuelve una clase determinada, esa clase se incluirá en la matriz devuelta. Si filter devuelve null, se devuelven todas las clases y filterCriteria se omite.

FindTypes no se puede usar para buscar tipos con parámetros, como matrices.

Consulte también

• FilterTypeName
• FilterTypeNameIgnoreCase
• ReflectionTypeLoadException