Module.GetType Método

Definição

Espaço de Nomes:: System.Reflection

Assemblagem:: mscorlib.dll

Assemblagem:: System.Reflection.dll

Assemblagem:: netstandard.dll

Assemblagens:: mscorlib.dll, System.Reflection.dll

Importante

Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.

Devolve o tipo especificado.

Sobrecargas

Name	Description
GetType(String)	Devolve o tipo especificado, realizando uma pesquisa sensível a maiúsculas e minúsculas.
GetType(String, Boolean)	Devolve o tipo especificado, pesquisando o módulo com a sensibilidade de maiúsculas especificada.
GetType(String, Boolean, Boolean)	Devolve o tipo especificado, especificando se deve fazer uma pesquisa sensível a maiúsculas e minúsculas no módulo e se deve lançar uma exceção caso o tipo não seja encontrado.

GetType(String)

Devolve o tipo especificado, realizando uma pesquisa sensível a maiúsculas e minúsculas.

public:
 virtual Type ^ GetType(System::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 localizar. O nome deve ser totalmente qualificado com o espaço de nomes.

Devoluções

Type

Um objeto que Type representa o tipo dado, se o tipo pertence a este 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 é lançada.

ArgumentException

className é uma corda de comprimento zero.

FileNotFoundException

className requer um assembly dependente que não foi encontrado.

FileLoadException

className requer um conjunto dependente que foi encontrado mas não pôde ser carregado.

-ou-

O conjunto de corrente foi carregado no contexto apenas de reflexão e className requer um conjunto dependente que não foi pré-carregado.

BadImageFormatException

className requer uma assembly dependente, mas o ficheiro não é uma assembly válida.

-ou-

className requer um assembly dependente que foi compilado para uma versão do runtime posterior à versão atualmente carregada.

Exemplos

O exemplo seguinte apresenta o nome de um tipo no módulo especificado.

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

Observações

Note

Se o tipo tiver sido encaminhado para outra assembleia, ainda assim é devolvido por este método. Para informações sobre encaminhamento de tipos, veja Encaminhamento de Tipos no Common Language Runtime.

Um tipo pode ser recuperado de um módulo específico usando Module.GetType. Chamar Module.GetType o módulo que contém o manifesto não procura em toda a assembleia. Para recuperar um tipo de um conjunto, independentemente do módulo em que esteja, deve chamar Assembly.GetType.

Aplica-se a

GetType(String, Boolean)

Devolve o tipo especificado, pesquisando o módulo com a sensibilidade de maiúsculas especificada.

public:
 virtual Type ^ GetType(System::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 localizar. O nome deve ser totalmente qualificado com o espaço de nomes.

ignoreCase: Boolean

true para busca insensível a maiúsculas e minúsculas; caso contrário, false.

Devoluções

Type

Um objeto que Type representa o tipo dado, se o tipo pertence a este 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 é lançada.

ArgumentException

className é uma corda de comprimento zero.

FileNotFoundException

className requer um assembly dependente que não foi encontrado.

FileLoadException

className requer um conjunto dependente que foi encontrado mas não pôde ser carregado.

-ou-

O conjunto de corrente foi carregado no contexto apenas de reflexão e className requer um conjunto dependente que não foi pré-carregado.

BadImageFormatException

className requer uma assembly dependente, mas o ficheiro não é uma assembly válida.

-ou-

className requer um assembly dependente que foi compilado para uma versão do runtime posterior à versão atualmente carregada.

Exemplos

O exemplo seguinte mostra 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 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

Observações

Note

Aplica-se a

GetType(String, Boolean, Boolean)

Devolve o tipo especificado, especificando se deve fazer uma pesquisa sensível a maiúsculas e minúsculas no módulo e se deve lançar uma exceção caso o tipo não seja encontrado.

public:
 virtual Type ^ GetType(System::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 localizar. O nome deve ser totalmente qualificado com o espaço de nomes.

throwOnError: Boolean

true lançar uma exceção se o tipo não puder ser encontrado; false para regressar null.

ignoreCase: Boolean

true para busca insensível a maiúsculas e minúsculas; caso contrário, false.

Devoluções

Type

Um objeto que Type represente 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 é lançada.

ArgumentException

className é uma corda de comprimento zero.

TypeLoadException

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

FileNotFoundException

className requer um assembly dependente que não foi encontrado.

FileLoadException

className requer um conjunto dependente que foi encontrado mas não pôde ser carregado.

-ou-

O conjunto de corrente foi carregado no contexto apenas de reflexão e className requer um conjunto dependente que não foi pré-carregado.

BadImageFormatException

className requer uma assembly dependente, mas o ficheiro não é uma assembly válida.

-ou-

className requer um assembly dependente que foi compilado para uma versão do runtime posterior à versão atualmente carregada.

Exemplos

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

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

Observações

O throwOnError parâmetro afeta apenas o que acontece quando o tipo não é encontrado. Não afeta quaisquer outras exceções que possam ser incluídas. Em particular, se o tipo for encontrado mas não puder ser carregado, TypeLoadException pode ser lançado mesmo que throwOnError seja false.

Note

Aplica-se a

Comentários

Esta página foi útil?