Partilhar via


Module.GetType Método

Definição

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

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

Atributos

Exceções

className é null.

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

className é uma cadeia de comprimento zero.

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

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.

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

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

Atributos

Exceções

className é null.

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

className é uma cadeia de comprimento zero.

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

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.

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

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

Atributos

Exceções

className é null.

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

className é uma cadeia de comprimento zero.

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

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

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.

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