Assembly.GetTypes Assembly.GetTypes Assembly.GetTypes Assembly.GetTypes Method

Definição

Obtém os tipos definidos neste assembly.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()

Retornos

Type[]

Uma matriz que contém todos os tipos que são definidos nesse assembly.An array that contains all the types that are defined in this assembly.

Implementações

Exceções

O assembly contém um ou mais tipos que não podem ser carregados.The assembly contains one or more types that cannot be loaded. A matriz retornada pela propriedade Types dessa exceção contém um objeto Type para cada tipo que foi carregado e null para cada tipo que não pôde ser carregado, enquanto a propriedade LoaderExceptions contém uma exceção para cada tipo que não pôde ser carregado.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.

Exemplos

O exemplo a seguir exibe parâmetros de um método em um tipo no assembly especificado.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 

Comentários

A matriz retornada inclui tipos aninhados.The returned array includes nested types.

Se o GetTypes método for chamado em um assembly e um tipo nesse assembly for dependente de um tipo em um assembly que não foi carregado (por exemplo, se for derivado de um tipo no segundo assembly), um ReflectionTypeLoadException será gerado.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. Por exemplo, isso pode acontecer se o primeiro assembly foi carregado com os ReflectionOnlyLoad métodos ReflectionOnlyLoadFrom ou e o segundo assembly não foi carregado.For example, this can happen if the first assembly was loaded with the ReflectionOnlyLoad or ReflectionOnlyLoadFrom methods, and the second assembly was not loaded. Ele também pode acontecer com assemblies carregados usando os Load métodos LoadFile e se o segundo assembly não puder ser localizado quando GetTypes o método for chamado.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.

Observação

Se um tipo foi encaminhado para outro assembly, ele não é incluído na matriz retornada.If a type has been forwarded to another assembly, it is not included in the returned array. Para obter informações sobre o encaminhamento de tipo, consulte o encaminhamento de tipo no Common Language Runtime.For information on type forwarding, see Type Forwarding in the Common Language Runtime.

Para recuperar uma coleção de TypeInfo objetos em vez de uma matriz Type de objetos, use Assembly.DefinedTypes a propriedade.To retrieve a collection of TypeInfo objects instead of an array of Type objects, use the Assembly.DefinedTypes property.

Aplica-se a