Module.GetType Método

  • Referência

Definição

Namespace:
System.Reflection
Assembly:
System.Runtime.dll
Assembly:
System.Reflection.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Retorna o tipo especificado.

Sobrecargas

GetType(String)

Retorna o tipo especificado, executando uma pesquisa que diferencia maiúsculas de minúsculas.
GetType(String, Boolean)

Retorna o tipo especificado, pesquisando o módulo com a diferenciação de maiúsculas e minúsculas especificada.
GetType(String, Boolean, Boolean)

Retorna o tipo especificado, especificando se deve ser feita uma pesquisa que diferencia maiúsculas de minúsculas do módulo e gerar uma exceção se não for possível localizar o tipo.

GetType(String)

Origem:
Module.cs
Origem:
Module.cs
Origem:
Module.cs

Retorna o tipo especificado, executando uma pesquisa que diferencia maiúsculas de minúsculas.

public:
 virtual Type ^ GetType(System::String ^ className);
public virtual Type? GetType (string className);
public virtual Type GetType (string className);
[System.Runtime.InteropServices.ComVisible(true)]
public virtual Type GetType (string className);
override this.GetType : string -> Type
[<System.Runtime.InteropServices.ComVisible(true)>]
override this.GetType : string -> Type
Public Overridable Function GetType (className As String) As Type

Parâmetros

className
String

O nome do tipo a ser localizado. O nome deve ser totalmente qualificado com o namespace.

Retornos

Type

Um objeto Type que representará o tipo especificado se o tipo estiver nesse módulo; caso contrário, null.

Atributos
ComVisibleAttribute

Exceções

ArgumentNullException

className é null.

TargetInvocationException

Os inicializadores de classe são invocados e uma exceção é gerada.

ArgumentException

className é uma cadeia de comprimento zero.

FileNotFoundException

className requer um assembly dependente que não pôde ser encontrado.

FileLoadException

className exige um assembly dependente que foi encontrado, mas que não pôde ser carregado.

- ou -

O assembly atual foi carregado no contexto somente reflexão e o className exige um assembly dependente que não foi pré-carregado.

BadImageFormatException

className exige um assembly dependente, mas o arquivo não é um assembly válido.

- ou -

className exige um assembly dependente que foi compilado para uma versão do runtime posterior à versão carregada no momento.

Exemplos

O exemplo a seguir exibe o nome de um tipo no módulo especificado.

using namespace System;
using namespace System::Reflection;

namespace ReflectionModule_Examples
{
   public ref class MyMainClass{};

}

int main()
{
   array<Module^>^moduleArray;
   moduleArray = ReflectionModule_Examples::MyMainClass::typeid->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^ myType;
   myType = myModule->GetType( "ReflectionModule_Examples.MyMainClass" );
   Console::WriteLine( "Got type: {0}", myType );
}

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 myType;

            myType = myModule.GetType("ReflectionModule_Examples.MyMainClass");
            Console.WriteLine("Got type: {0}", myType.ToString());
        }
    }
}

Imports System.Reflection

'This code assumes that the root namespace is set to empty("").
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 myType As Type

            myType = myModule.GetType("ReflectionModule_Examples.MyMainClass")
            Console.WriteLine("Got type: {0}", myType.ToString())
        End Sub
    End Class
End Namespace 'ReflectionModule_Examples

Comentários

Observação

Se o tipo tiver sido encaminhado para outro assembly, ele ainda será retornado por esse método. Para obter informações sobre o encaminhamento de tipos, consulte Encaminhamento de tipos no Common Language Runtime.

Um tipo pode ser recuperado de um módulo específico usando Module.GetType. Chamar Module.GetType no módulo que contém o manifesto não pesquisará todo o assembly. Para recuperar um tipo de um assembly, independentemente do módulo em que ele está, você deve chamar Assembly.GetType.

Aplica-se a

GetType(String, Boolean)

Origem:
Module.cs
Origem:
Module.cs
Origem:
Module.cs

Retorna o tipo especificado, pesquisando o módulo com a diferenciação de maiúsculas e minúsculas especificada.

public:
 virtual Type ^ GetType(System::String ^ className, bool ignoreCase);
public virtual Type? GetType (string className, bool ignoreCase);
public virtual Type GetType (string className, bool ignoreCase);
[System.Runtime.InteropServices.ComVisible(true)]
public virtual Type GetType (string className, bool ignoreCase);
override this.GetType : string * bool -> Type
[<System.Runtime.InteropServices.ComVisible(true)>]
override this.GetType : string * bool -> Type
Public Overridable Function GetType (className As String, ignoreCase As Boolean) As Type

Parâmetros

className
String

O nome do tipo a ser localizado. O nome deve ser totalmente qualificado com o namespace.

ignoreCase
Boolean

true para a pesquisa que não diferencia maiúsculas de minúsculas; caso contrário, false.

Retornos

Type

Um objeto Type que representará o tipo especificado se o tipo estiver nesse módulo; caso contrário, null.

Atributos
ComVisibleAttribute

Exceções

ArgumentNullException

className é null.

TargetInvocationException

Os inicializadores de classe são invocados e uma exceção é gerada.

ArgumentException

className é uma cadeia de comprimento zero.

FileNotFoundException

className requer um assembly dependente que não pôde ser encontrado.

FileLoadException

className exige um assembly dependente que foi encontrado, mas que não pôde ser carregado.

- ou -

O assembly atual foi carregado no contexto somente reflexão e o className exige um assembly dependente que não foi pré-carregado.

BadImageFormatException

className exige um assembly dependente, mas o arquivo não é um assembly válido.

- ou -

className exige um assembly dependente que foi compilado para uma versão do runtime posterior à versão carregada no momento.

Exemplos

O exemplo a seguir exibe o nome de um tipo no módulo especificado, especificando false para o ignoreCase parâmetro para que esse caso não seja ignorado.

using namespace System;
using namespace System::Reflection;

namespace ReflectionModule_Examples
{
   public ref class MyMainClass{};

}

int main()
{
   array<Module^>^moduleArray;
   moduleArray = ReflectionModule_Examples::MyMainClass::typeid->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^ myType;
   myType = myModule->GetType( "ReflectionModule_Examples.MyMainClass", false );
   Console::WriteLine( "Got type: {0}", myType );
}

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 myType;
            myType = myModule.GetType("ReflectionModule_Examples.MyMainClass", false);
            Console.WriteLine("Got type: {0}", myType.ToString());
        }
    }
}

Imports System.Reflection

'This code assumes that the root namespace is set to empty("").
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 myType As Type
            myType = myModule.GetType("ReflectionModule_Examples.MyMainClass", False)
            Console.WriteLine("Got type: {0}", myType.ToString())
        End Sub
    End Class
End Namespace 'ReflectionModule_Examples

Comentários

Observação

Se o tipo tiver sido encaminhado para outro assembly, ele ainda será retornado por esse método. Para obter informações sobre o encaminhamento de tipos, consulte Encaminhamento de tipos no Common Language Runtime.

Um tipo pode ser recuperado de um módulo específico usando Module.GetType. Chamar Module.GetType no módulo que contém o manifesto não pesquisará todo o assembly. Para recuperar um tipo de um assembly, independentemente do módulo em que ele está, você deve chamar Assembly.GetType.

Aplica-se a

GetType(String, Boolean, Boolean)

Origem:
Module.cs
Origem:
Module.cs
Origem:
Module.cs

Retorna o tipo especificado, especificando se deve ser feita uma pesquisa que diferencia maiúsculas de minúsculas do módulo e gerar uma exceção se não for possível localizar o tipo.

public:
 virtual Type ^ GetType(System::String ^ className, bool throwOnError, bool ignoreCase);
public virtual Type GetType (string className, bool throwOnError, bool ignoreCase);
public virtual Type? GetType (string className, bool throwOnError, bool ignoreCase);
[System.Runtime.InteropServices.ComVisible(true)]
public virtual Type GetType (string className, bool throwOnError, bool ignoreCase);
override this.GetType : string * bool * bool -> Type
[<System.Runtime.InteropServices.ComVisible(true)>]
override this.GetType : string * bool * bool -> Type
Public Overridable Function GetType (className As String, throwOnError As Boolean, ignoreCase As Boolean) As Type

Parâmetros

className
String

O nome do tipo a ser localizado. O nome deve ser totalmente qualificado com o namespace.

throwOnError
Boolean

true para gerar uma exceção se não for possível encontrar o tipo; false para retornar null.

ignoreCase
Boolean

true para a pesquisa que não diferencia maiúsculas de minúsculas; caso contrário, false.

Retornos

Type

Um objeto Type que representa o tipo especificado, se o tipo for declarado neste módulo; caso contrário, null.

Atributos
ComVisibleAttribute

Exceções

ArgumentNullException

className é null.

TargetInvocationException

Os inicializadores de classe são invocados e uma exceção é gerada.

ArgumentException

className é uma cadeia de comprimento zero.

TypeLoadException

throwOnError é true e o tipo não pode ser encontrado.

FileNotFoundException

className requer um assembly dependente que não pôde ser encontrado.

FileLoadException

className exige um assembly dependente que foi encontrado, mas que não pôde ser carregado.

- ou -

O assembly atual foi carregado no contexto somente reflexão e o className exige um assembly dependente que não foi pré-carregado.

BadImageFormatException

className exige um assembly dependente, mas o arquivo não é um assembly válido.

- ou -

className exige um assembly dependente que foi compilado para uma versão do runtime posterior à versão carregada no momento.

Exemplos

O exemplo a seguir exibe o nome de um tipo no módulo especificado. Os throwOnError parâmetros e ignoreCase são especificados como false.

using namespace System;
using namespace System::Reflection;

namespace ReflectionModule_Examples
{
   public ref class MyMainClass{};

}

int main()
{
   array<Module^>^moduleArray;
   moduleArray = ReflectionModule_Examples::MyMainClass::typeid->Assembly->GetModules( false );
   
   //In a simple project with only one module, the module at index
   // 0 will be the module containing this class.
   Module^ myModule = moduleArray[ 0 ];
   Type^ myType;
   myType = myModule->GetType( "ReflectionModule_Examples.MyMainClass", false, false );
   Console::WriteLine( "Got type: {0}", myType );
}

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 this class.
            Module myModule = moduleArray[0];

            Type myType;
            myType = myModule.GetType("ReflectionModule_Examples.MyMainClass", false, false);
            Console.WriteLine("Got type: {0}", myType.ToString());
        }
    }
}

Imports System.Reflection

'This code assumes that the root namespace is set to empty("").
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 this class.
            Dim myModule As [Module] = moduleArray(0)

            Dim myType As Type
            myType = myModule.GetType("ReflectionModule_Examples.MyMainClass", False, False)
            Console.WriteLine("Got type: {0}", myType.ToString())
        End Sub
    End Class
End Namespace 'ReflectionModule_Examples

Comentários

O throwOnError parâmetro afeta apenas o que acontece quando o tipo não é encontrado. Ele não afeta nenhuma outra exceção que possa ser gerada. Em particular, se o tipo for encontrado, mas não puder ser carregado, TypeLoadException poderá ser gerado mesmo se throwOnError for false.

Observação

Se o tipo tiver sido encaminhado para outro assembly, ele ainda será retornado por esse método. Para obter informações sobre o encaminhamento de tipos, consulte Encaminhamento de tipos no Common Language Runtime.

Um tipo pode ser recuperado de um módulo específico usando Module.GetType. Chamar Module.GetType no módulo que contém o manifesto não pesquisará todo o assembly. Para recuperar um tipo de um assembly, independentemente do módulo em que ele está, você deve chamar Assembly.GetType.

Aplica-se a