Assembly.GetTypes Methode

Definition

Ruft die in dieser Assembly definierten Typen ab.Gets the types defined in this assembly.

public:
 virtual cli::array <Type ^> ^ GetTypes();
public virtual Type[] GetTypes ();
abstract member GetTypes : unit -> Type[]
override this.GetTypes : unit -> Type[]
Public Overridable Function GetTypes () As Type()

Gibt zurück

Type[]

Ein Array, das alle in dieser Assembly definierten Typen enthält.An array that contains all the types that are defined in this assembly.

Implementiert

Ausnahmen

Die Assembly enthält einen oder mehrere Typen, die nicht geladen werden können.The assembly contains one or more types that cannot be loaded. Das von der Types-Eigenschaft dieser Ausnahme zurückgegebene Array enthält ein Type-Objekt für jeden Typ, der geladen wurde und null für jeden Typ, der nicht geladen werden konnte, während die LoaderExceptions-Eigenschaft eine Ausnahme für jeden Typ enthält, der nicht geladen werden konnte.The array returned by the Types property of this exception contains a Type object for each type that was loaded and null for each type that could not be loaded, while the LoaderExceptions property contains an exception for each type that could not be loaded.

Beispiele

Im folgenden Beispiel werden Parameter einer Methode für einen Typ in der angegebenen Assembly angezeigt.The following example displays parameters of one method on a type in the specified assembly.

Assembly^ SampleAssembly;
SampleAssembly = Assembly::LoadFrom( "c:\\Sample.Assembly.dll" );
// Obtain a reference to a method known to exist in assembly.
MethodInfo^ Method = SampleAssembly->GetTypes()[ 0 ]->GetMethod( "Method1" );
// Obtain a reference to the parameters collection of the MethodInfo instance.
array<ParameterInfo^>^ Params = Method->GetParameters();
// Display information about method parameters.
// Param = sParam1
//   Type = System::String
//   Position = 0
//   Optional=False
for each ( ParameterInfo^ Param in Params )
{
   Console::WriteLine( "Param= {0}", Param->Name );
   Console::WriteLine( "  Type= {0}", Param->ParameterType );
   Console::WriteLine( "  Position= {0}", Param->Position );
   Console::WriteLine( "  Optional= {0}", Param->IsOptional );
}
Assembly SampleAssembly;
SampleAssembly = Assembly.LoadFrom("c:\\Sample.Assembly.dll");
// Obtain a reference to a method known to exist in assembly.
MethodInfo Method = SampleAssembly.GetTypes()[0].GetMethod("Method1");
// Obtain a reference to the parameters collection of the MethodInfo instance.
ParameterInfo[] Params = Method.GetParameters();
// Display information about method parameters.
// Param = sParam1
//   Type = System.String
//   Position = 0
//   Optional=False
foreach (ParameterInfo Param in Params)
{
    Console.WriteLine("Param=" + Param.Name.ToString());
    Console.WriteLine("  Type=" + Param.ParameterType.ToString());
    Console.WriteLine("  Position=" + Param.Position.ToString());
    Console.WriteLine("  Optional=" + Param.IsOptional.ToString());
}
Dim SampleAssembly As [Assembly]
SampleAssembly = [Assembly].LoadFrom("c:\Sample.Assembly.dll")
' Obtain a reference to a method known to exist in assembly.
Dim Method As MethodInfo = SampleAssembly.GetTypes()(0).GetMethod("Method1")
' Obtain a reference to the parameters collection of the MethodInfo instance.
Dim Params As ParameterInfo() = Method.GetParameters()
' Display information about method parameters.
' Param = sParam1
'   Type = System.String
'   Position = 0
'   Optional=False
For Each Param As ParameterInfo In Params
    Console.WriteLine(("Param=" + Param.Name.ToString()))
    Console.WriteLine(("  Type=" + Param.ParameterType.ToString()))
    Console.WriteLine(("  Position=" + Param.Position.ToString()))
    Console.WriteLine(("  Optional=" + Param.IsOptional.ToString()))
Next 

Hinweise

Das zurückgegebene Array enthält eine Reihe von Typen.The returned array includes nested types.

Wenn die GetTypes-Methode für eine Assembly aufgerufen wird und ein Typ in dieser Assembly von einem Typ in einer Assembly abhängt, die nicht geladen wurde (z. b. Wenn Sie von einem Typ in der zweiten Assembly abgeleitet ist), wird eine ReflectionTypeLoadException ausgelöst.If the GetTypes method is called on an assembly and a type in that assembly is dependent on a type in an assembly that has not been loaded (for example, if it derives from a type in the second assembly), a ReflectionTypeLoadException is thrown. Dies kann z. b. der Fall sein, wenn die erste Assembly mit den Methoden ReflectionOnlyLoad oder ReflectionOnlyLoadFrom geladen wurde und die zweite Assembly nicht geladen wurde.For example, this can happen if the first assembly was loaded with the ReflectionOnlyLoad or ReflectionOnlyLoadFrom methods, and the second assembly was not loaded. Dies kann auch bei Assemblys vorkommen, die mithilfe der Methoden Load und LoadFile geladen wurden, wenn die zweite Assembly nicht gefunden werden kann, wenn die GetTypes-Methode aufgerufen wird.It can also happen with assemblies loaded using the Load and LoadFile methods if the second assembly cannot be located when the GetTypes method is called.

Hinweis

Wenn ein Typ an eine andere Assembly weitergeleitet wurde, ist er nicht im zurückgegebenen Array enthalten.If a type has been forwarded to another assembly, it is not included in the returned array. Informationen zur Typweiterleitung finden Sie unter Typweiterleitung in der Common Language Runtime.For information on type forwarding, see Type Forwarding in the Common Language Runtime.

Um eine Auflistung von TypeInfo Objekten anstelle eines Arrays von Type Objekten abzurufen, verwenden Sie die Assembly.DefinedTypes-Eigenschaft.To retrieve a collection of TypeInfo objects instead of an array of Type objects, use the Assembly.DefinedTypes property.

Gilt für: