Module.FindTypes(TypeFilter, Object) Module.FindTypes(TypeFilter, Object) Module.FindTypes(TypeFilter, Object) Module.FindTypes(TypeFilter, Object) Method

Definizione

Restituisce una matrice di classi accettate dal filtro specificato e dai criteri di filtro.Returns an array of classes accepted by the given filter and filter criteria.

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

Parametri

filter
TypeFilter TypeFilter TypeFilter TypeFilter

Delegato usato per filtrare le classi.The delegate used to filter the classes.

filterCriteria
Object Object Object Object

Oggetto usato per filtrare le classi.An Object used to filter the classes.

Restituisce

Type[]

Matrice di tipo Type contenente le classi accettate dal filtro.An array of type Type containing classes that were accepted by the filter.

Eccezioni

Non è stato possibile caricare una o più classi in un modulo.One or more classes in a module could not be loaded.

Esempi

Nell'esempio seguente viene illustrato FindTypes il metodo.The following example demonstrates the FindTypes method.

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 'Main
    End Class 'MyMainClass

    Class MySecondClass
    End Class 'MySecondClass

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

Commenti

ReflectionTypeLoadExceptioneccezione di caricamento speciale della classe.ReflectionTypeLoadException is a special class load exception. La ReflectionTypeLoadException.Types proprietà contiene la matrice di classi definite nel modulo e caricate.The ReflectionTypeLoadException.Types property contains the array of classes that were defined in the module and were loaded. Questa matrice può contenere alcuni valori null.This array may contain some null values. La ReflectionTypeLoadException.LoaderExceptions proprietà è una matrice di eccezioni che rappresentano le eccezioni generate dal caricatore della classe.The ReflectionTypeLoadException.LoaderExceptions property is an array of exceptions that represent the exceptions that were thrown by the class loader. I buchi nella matrice di classi si allineano con le eccezioni.The holes in the class array line up with the exceptions.

Il delegato fornito da filter viene chiamato per ogni classe nel modulo, passando lungo l' Type oggetto che rappresenta la classe e l'oggetto specificato filterCriteria.The delegate given by filter is called for each class in the module, passing along the Type object representing the class as well as the given filterCriteria. Se filter restituisce una classe specifica, tale classe verrà inclusa nella matrice restituita.If filter returns a particular class, that class will be included in the returned array. Se filter filterCriteria restituisce null, vengono restituite tutte le classi e viene ignorato.If filter returns null, all classes are returned and filterCriteria is ignored.

FindTypesnon può essere utilizzato per cercare i tipi con parametri, ad esempio le matrici.FindTypes cannot be used to look up parameterized types such as arrays.

Si applica a

Vedi anche