Module.FindTypes(TypeFilter, Object) Metodo

  • Riferimento

Definizione

Spazio dei nomi:
System.Reflection
Assembly:
System.Runtime.dll
Assembly:
netstandard.dll
Assembly:
System.Reflection.dll
Assembly:
mscorlib.dll

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);
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 della classe speciale. La ReflectionTypeLoadException.Types proprietà contiene la matrice di classi definite nel modulo e caricate. Questa matrice può contenere alcuni valori Null. La proprietà è una matrice di eccezioni che rappresentano le eccezioni generate ReflectionTypeLoadException.LoaderExceptions dal caricatore di classi. I fori nella matrice di classi sono allineati con le eccezioni.

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

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

Si applica a

Vedi anche