Module.FindTypes(TypeFilter, Object) Metodo

Definizione

Spazio dei nomi:

System.Reflection

Assembly:

System.Runtime.dll

Origine:

Module.cs

Restituisce una matrice di classi accettate dal filtro specificato e dai criteri di filtro.

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

Delegato usato per filtrare le classi.

filterCriteria

Object

Oggetto usato per filtrare le classi.

Restituisce

Type[]

Matrice di tipo Type contenente le classi accettate dal filtro.

Eccezioni

ReflectionTypeLoadException

Non è stato possibile caricare una o più classi in un modulo.

Esempio

Nell'esempio seguente viene illustrato il FindTypes metodo.

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

Commenti

ReflectionTypeLoadException è un'eccezione di caricamento di classe speciale. La ReflectionTypeLoadException.Types proprietà contiene la matrice di classi definite nel modulo e caricate. Questa matrice può contenere alcuni valori Null. La ReflectionTypeLoadException.LoaderExceptions proprietà è una matrice di eccezioni che rappresentano le eccezioni generate dal caricatore della classe. I fori nella matrice di classi si allineano con le eccezioni.

Il delegato specificato da filter viene chiamato per ogni classe nel modulo, passando lungo l'oggetto Type che rappresenta la classe e l'oggetto specificato filterCriteria. Se filter restituisce una classe specifica, tale classe verrà inclusa nella matrice restituita. Se filter restituisce null, tutte le classi vengono restituite e filterCriteria vengono ignorate.

FindTypes non può essere usato per cercare tipi con parametri, ad esempio matrici.

Vedi anche

• FilterTypeName
• FilterTypeNameIgnoreCase
• ReflectionTypeLoadException