Type Classe

Definição

Representa as declarações de tipo: tipos de classe, tipos de interface, tipos de matriz, tipos de valor, tipos de enumeração, parâmetros de tipo, definições de tipo genérico e tipos genéricos construídos abertos ou fechados.

public ref class Type abstract
public ref class Type abstract : System::Reflection::MemberInfo, System::Reflection::IReflect
public ref class Type abstract : System::Reflection::MemberInfo, System::Reflection::IReflect, System::Runtime::InteropServices::_Type
public abstract class Type
public abstract class Type : System.Reflection.MemberInfo, System.Reflection.IReflect
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Serializable]
public abstract class Type : System.Reflection.MemberInfo, System.Reflection.IReflect, System.Runtime.InteropServices._Type
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Type : System.Reflection.MemberInfo, System.Reflection.IReflect, System.Runtime.InteropServices._Type
type Type = class
type Type = class
    inherit MemberInfo
    interface IReflect
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Serializable>]
type Type = class
    inherit MemberInfo
    interface _Type
    interface IReflect
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Type = class
    inherit MemberInfo
    interface _Type
    interface IReflect
Public MustInherit Class Type
Public MustInherit Class Type
Inherits MemberInfo
Implements IReflect
Public MustInherit Class Type
Inherits MemberInfo
Implements _Type, IReflect
Herança
Type
Herança
Derivado
Atributos
Implementações

Exemplos

O exemplo a seguir mostra alguns recursos representativos de Type. O operador C# typeof (GetTypeoperador no Visual Basic) é usado para obter um Type objeto que Stringrepresenta . Type Desse objeto, o GetMethod método é usado para obter uma MethodInfo representação da String.Substring sobrecarga que usa um local inicial e um comprimento.

Para identificar a assinatura de sobrecarga, o exemplo de código cria uma matriz temporária que contém dois Type objetos que int representam (Integer em Visual Basic).

Observação

Para ser preciso, a matriz contém duas referências à instância Type que representa int no domínio do aplicativo atual. Para qualquer tipo, há apenas uma instância de Type domínio por aplicativo.

O exemplo de código usa o MethodInfo método para invocar a Substring cadeia de caracteres "Olá, Mundo!", e exibe o resultado.

#using <System.dll>

using namespace System;
using namespace System::Reflection;

void main()
{
    // Get a Type object representing the System.String type.
    Type^ t = String::typeid;

    MethodInfo^ substr = t->GetMethod("Substring", 
        gcnew array<Type^> { int::typeid, int::typeid });

    Object^ result = 
        substr->Invoke("Hello, World!", gcnew array<Object^> { 7, 5 });
    Console::WriteLine("{0} returned \"{1}\".", substr, result);
}

/* This code example produces the following output:

System.String Substring(Int32, Int32) returned "World".
 */
using System;
using System.Reflection;

class Example
{
    static void Main()
    {
        Type t = typeof(String);

        MethodInfo substr = t.GetMethod("Substring", 
            new Type[] { typeof(int), typeof(int) });

        Object result = 
            substr.Invoke("Hello, World!", new Object[] { 7, 5 });
        Console.WriteLine("{0} returned \"{1}\".", substr, result);
    }
}

/* This code example produces the following output:

System.String Substring(Int32, Int32) returned "World".
 */
open System

let t = typeof<String>

let substr = t.GetMethod("Substring", [| typeof<int>; typeof<int> |])

let result = substr.Invoke("Hello, World!", [| 7; 5 |])
printfn $"{substr} returned \"{result}\"."

(* This code example produces the following output:

System.String Substring(Int32, Int32) returned "World".
 *)
Imports System.Reflection

Module Example
    
    Sub Main() 

        Dim t As Type = GetType(String)
        
        Dim substr As MethodInfo = t.GetMethod("Substring", _
            New Type() { GetType(Integer), GetType(Integer) })
        
        Dim result As Object = _ 
            substr.Invoke("Hello, World!", New Object() { 7, 5 })
        Console.WriteLine("{0} returned ""{1}"".", substr, result)
    
    End Sub 
End Module

' This code example produces the following output:
'
'System.String Substring(Int32, Int32) returned "World".

Comentários

Type é a raiz da System.Reflection funcionalidade e é a principal maneira de acessar metadados. Use os membros Type para obter informações sobre uma declaração de tipo, sobre os membros de um tipo (como construtores, métodos, campos, propriedades e eventos de uma classe), bem como o módulo e o assembly no qual a classe é implantada.

Nenhuma permissão é necessária para que o código use reflexão para obter informações sobre tipos e seus membros, independentemente de seus níveis de acesso. Nenhuma permissão é necessária para que o código use reflexão para acessar membros públicos ou outros membros cujos níveis de acesso os tornariam visíveis durante a compilação normal. No entanto, para que seu código use reflexão para acessar membros que normalmente estariam inacessíveis, como métodos privados ou internos, ou campos protegidos de um tipo que sua classe não herda, seu código deve ter ReflectionPermission. Consulte considerações de segurança para reflexão.

Type é uma classe base abstrata que permite várias implementações. O sistema sempre fornecerá a classe RuntimeTypederivada. Em reflexão, todas as classes que começam com a palavra Runtime são criadas apenas uma vez por objeto no sistema e dão suporte a operações de comparação.

Observação

Em cenários multithreading, não bloqueie Type objetos para sincronizar o acesso aos static dados. Outro código, sobre o qual você não tem controle, também pode bloquear o tipo de classe. Isso pode resultar em um deadlock. Em vez disso, sincronize o acesso a dados estáticos bloqueando um objeto privado static .

Observação

Uma classe derivada pode acessar membros protegidos das classes base do código de chamada. Além disso, o acesso é permitido aos membros do assembly do código de chamada. Como regra, se você tiver permissão para acessar o código com limite antecipado, você também poderá acessar o código com limite tardio.

Observação

Interfaces que estendem outras interfaces não herdam os métodos definidos nas interfaces estendidas.

Nesta seção:

Quais tipos um objeto Type representa?
Recuperando um objeto Type
Comparando objetos de tipo para igualdade

Quais tipos um objeto Type representa?

Essa classe é thread safe; vários threads podem ser lidos simultaneamente de uma instância desse tipo. Uma instância da Type classe pode representar qualquer um dos seguintes tipos:

  • Classes

  • Tipos de valor

  • Matrizes

  • Interfaces

  • Enumerações

  • Delegados

  • Tipos genéricos construídos e definições de tipo genérico

  • Tipos de argumentos e parâmetros de tipo de tipos genéricos construídos, definições de tipo genérico e definições de método genérico

Recuperando um objeto Type

O Type objeto associado a um tipo específico pode ser obtido das seguintes maneiras:

  • O método de instância Object.GetType retorna um Type objeto que representa o tipo de uma instância. Como todos os tipos gerenciados derivam, Objecto GetType método pode ser chamado em uma instância de qualquer tipo.

    O exemplo a seguir chama o Object.GetType método para determinar o tipo de runtime de cada objeto em uma matriz de objetos.

    using namespace System;
    
    void main()
    {
       array<Object^>^ values = { "word", true, 120, 136.34 };
       for each (Object^ value in values)
          Console::WriteLine("{0} - type {1}", value, 
                            value->GetType()->Name);
    }
    // The example displays the following output:
    //       word - type String
    //       True - type Boolean
    //       120 - type Int32
    //       136.34 - type Double
    
    object[] values = { "word", true, 120, 136.34, 'a' };
    foreach (var value in values)
       Console.WriteLine("{0} - type {1}", value, 
                         value.GetType().Name);
    
    // The example displays the following output:
    //       word - type String
    //       True - type Boolean
    //       120 - type Int32
    //       136.34 - type Double
    //       a - type Char
    
    let values: obj[] = [| "word"; true; 120; 136.34; 'a' |]
    for value in values do
       printfn $"{value} - type {value.GetType().Name}"
    
    // The example displays the following output:
    //       word - type String
    //       True - type Boolean
    //       120 - type Int32
    //       136.34 - type Double
    //       a - type Char
    
    Module Example
       Public Sub Main()
          Dim values() As Object = { "word", True, 120, 136.34, "a"c }
          For Each value In values
             Console.WriteLine("{0} - type {1}", value, 
                               value.GetType().Name)
          Next
       End Sub
    End Module
    ' The example displays the following output:
    '       word - type String
    '       True - type Boolean
    '       120 - type Int32
    '       136.34 - type Double
    '       a - type Char
    
  • Os métodos estáticos Type.GetType retornam um Type objeto que representa um tipo especificado por seu nome totalmente qualificado.

  • Os Module.GetTypesmétodos e os Module.GetTypeModule.FindTypes métodos retornam Type objetos que representam os tipos definidos em um módulo. O primeiro método pode ser usado para obter uma matriz de Type objetos para todos os tipos públicos e privados definidos em um módulo. (Você pode obter uma instância por meio do Module Assembly.GetModule método ou Assembly.GetModules por meio da Type.Module propriedade.)

  • O System.Reflection.Assembly objeto contém vários métodos para recuperar as classes definidas em um assembly, incluindo Assembly.GetType, Assembly.GetTypese Assembly.GetExportedTypes.

  • O FindInterfaces método retorna uma lista filtrada de tipos de interface compatíveis com um tipo.

  • O GetElementType método retorna um Type objeto que representa o elemento.

  • Os GetInterfaces métodos e GetInterface os métodos retornam Type objetos que representam os tipos de interface compatíveis com um tipo.

  • O GetTypeArray método retorna uma matriz de Type objetos que representam os tipos especificados por um conjunto arbitrário de objetos. Os objetos são especificados com uma matriz de tipo Object.

  • Os GetTypeFromProgID métodos e os métodos GetTypeFromCLSID são fornecidos para interoperabilidade COM. Eles retornam um Type objeto que representa o tipo especificado por um ProgID ou CLSID.

  • O GetTypeFromHandle método é fornecido para interoperabilidade. Ele retorna um Type objeto que representa o tipo especificado por um identificador de classe.

  • O operador C#typeof, o operador C++ typeid e o operador Visual Basic GetType obtêm o Type objeto para um tipo.

  • O MakeGenericType método retorna um Type objeto que representa um tipo genérico construído, que é um tipo aberto construído se sua ContainsGenericParameters propriedade retornar truee um tipo construído fechado, caso contrário. Um tipo genérico só poderá ser instanciado se for fechado.

  • Os MakeArrayTypemétodos , MakePointerTypee MakeByRefType os métodos retornam Type objetos que representam, respectivamente, uma matriz de um tipo especificado, um ponteiro para um tipo especificado e o tipo de um parâmetro de referência (ref em C#, 'byref' em F#, ByRef em Visual Basic).

Comparando objetos de tipo para igualdade

Um Type objeto que representa um tipo é exclusivo; ou seja, duas Type referências de objeto se referem ao mesmo objeto se e somente se representarem o mesmo tipo. Isso permite a comparação de Type objetos usando a igualdade de referência. O exemplo a seguir compara os Type objetos que representam um número de valores inteiros para determinar se eles são do mesmo tipo.

using namespace System;

void main()
{
   Int64 number1 = 1635429;
   Int32 number2 = 16203;
   double number3 = 1639.41;
   Int64 number4 = 193685412;
   
   // Get the type of number1.
   Type^ t = number1.GetType();
   
   // Compare types of all objects with number1.
   Console::WriteLine("Type of number1 and number2 are equal: {0}",
                      Object::ReferenceEquals(t, number2.GetType()));
   Console::WriteLine("Type of number1 and number3 are equal: {0}",
                      Object::ReferenceEquals(t, number3.GetType()));
   Console::WriteLine("Type of number1 and number4 are equal: {0}",
                      Object::ReferenceEquals(t, number4.GetType()));
}
// The example displays the following output:
//       Type of number1 and number2 are equal: False
//       Type of number1 and number3 are equal: False
//       Type of number1 and number4 are equal: True
long number1 = 1635429;
int number2 = 16203;
double number3 = 1639.41;
long number4 = 193685412;

// Get the type of number1.
Type t = number1.GetType();

// Compare types of all objects with number1.
Console.WriteLine("Type of number1 and number2 are equal: {0}",
                  Object.ReferenceEquals(t, number2.GetType()));
Console.WriteLine("Type of number1 and number3 are equal: {0}",
                  Object.ReferenceEquals(t, number3.GetType()));
Console.WriteLine("Type of number1 and number4 are equal: {0}",
                  Object.ReferenceEquals(t, number4.GetType()));

// The example displays the following output:
//       Type of number1 and number2 are equal: False
//       Type of number1 and number3 are equal: False
//       Type of number1 and number4 are equal: True
let number1 = 1635429L
let number2 = 16203
let number3 = 1639.41
let number4 = 193685412L

// Get the type of number1.
let t = number1.GetType()

// Compare types of all objects with number1.
printfn $"Type of number1 and number2 are equal: {Object.ReferenceEquals(t, number2.GetType())}"
printfn $"Type of number1 and number3 are equal: {Object.ReferenceEquals(t, number3.GetType())}"
printfn $"Type of number1 and number4 are equal: {Object.ReferenceEquals(t, number4.GetType())}"

// The example displays the following output:
//       Type of number1 and number2 are equal: False
//       Type of number1 and number3 are equal: False
//       Type of number1 and number4 are equal: True
Module Example
   Public Sub Main()
      Dim number1 As Long = 1635429
      Dim number2 As Integer = 16203
      Dim number3 As Double = 1639.41
      Dim number4 As Long = 193685412
      
      ' Get the type of number1.
      Dim t As Type = number1.GetType()
      
      ' Compare types of all objects with number1.
      Console.WriteLine("Type of number1 and number2 are equal: {0}",
                        Object.ReferenceEquals(t, number2.GetType()))
      Console.WriteLine("Type of number1 and number3 are equal: {0}",
                        Object.ReferenceEquals(t, number3.GetType()))
      Console.WriteLine("Type of number1 and number4 are equal: {0}",
                        Object.ReferenceEquals(t, number4.GetType()))
   End Sub
End Module
' The example displays the following output:
'       Type of number1 and number2 are equal: False
'       Type of number1 and number3 are equal: False
'       Type of number1 and number4 are equal: True

Notas aos Implementadores

Ao herdar, Typevocê deve substituir os seguintes membros:

Construtores

Type()

Inicializa uma nova instância da classe Type.

Campos

Delimiter

Separa nomes no namespace de Type. Este campo é somente leitura.

EmptyTypes

Representa uma matriz vazia do tipo Type. Este campo é somente leitura.

FilterAttribute

Representa o filtro de membro usado em atributos. Este campo é somente leitura.

FilterName

Representa o filtro de membro, que diferencia maiúsculas de minúsculas, usado nos nomes. Este campo é somente leitura.

FilterNameIgnoreCase

Representa o filtro de membro, que não diferencia maiúsculas de minúsculas, usado nos nomes. Este campo é somente leitura.

Missing

Representa um valor ausente nas informações Type. Este campo é somente leitura.

Propriedades

Assembly

Obtém o Assembly no qual o tipo é declarado. Para tipos genéricos, obtém o Assembly no qual o tipo genérico é definido.

AssemblyQualifiedName

Obtém o nome do tipo qualificado pelo assembly, que inclui o nome do assembly do qual este objeto Type foi carregado.

Attributes

Obtém os atributos associados ao Type.

BaseType

Obtém o tipo do qual o Type atual é herdado diretamente.

ContainsGenericParameters

Obtém um valor que indica se o objeto Type atual tem parâmetros de tipo que não foram substituídos por tipos específicos.

CustomAttributes

Obtém uma coleção que contém os atributos personalizados desse membro.

(Herdado de MemberInfo)
DeclaringMethod

Obtém um MethodBase que representa o método declarativo, se o Type atual representa um parâmetro de tipo de um método genérico.

DeclaringType

Obtém o tipo que declara o tipo aninhado atual ou o parâmetro de tipo genérico.

DefaultBinder

Obtém uma referência ao associador padrão, que implementa regras internas para selecionar os membros adequados a serem chamados por InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]).

FullName

Obtém o nome totalmente qualificado do tipo, incluindo o namespace, mas não o assembly.

GenericParameterAttributes

Obtém uma combinação de GenericParameterAttributes sinalizadores que descrevem a covariância e restrições especiais do parâmetro de tipo genérico atual.

GenericParameterPosition

Obtém a posição do parâmetro de tipo, na lista de parâmetros de tipo, do tipo genérico ou do método que declarou o parâmetro, quando o objeto Type representa um parâmetro de tipo de um tipo genérico ou método genérico.

GenericTypeArguments

Obtém uma matriz dos argumentos de tipo genérico para esse tipo.

GUID

Obtém o GUID associado ao Type.

HasElementType

Obtém um valor que indica se o Type atual abrange ou se refere a outro tipo; ou seja, se o Type atual é uma matriz, um ponteiro ou é passado por referência.

IsAbstract

Obtém um valor que indica se o Type é abstrato e deve ser substituído.

IsAnsiClass

Obtém um valor que indica se o atributo de formato da cadeia de caracteres AnsiClass está selecionado para o Type.

IsArray

Obtém um valor que indica se o tipo é uma matriz.

IsAutoClass

Obtém um valor que indica se o atributo de formato da cadeia de caracteres AutoClass está selecionado para o Type.

IsAutoLayout

Obtém um valor que indica se os campos do tipo atual são apresentados automaticamente pelo Common Language Runtime.

IsByRef

Obtém um valor que indica se o Type é aprovado por referência.

IsByRefLike

Obtém um valor que indica se o tipo é uma estrutura de tipo ByRef.

IsClass

Obtém um valor que indica se o Type é uma classe ou um delegado; ou seja, não um tipo de valor ou interface.

IsCollectible

Obtém um valor que indica se este objeto MemberInfo faz parte de um assembly mantido em uma coleção AssemblyLoadContext.

(Herdado de MemberInfo)
IsCOMObject

Obtém um valor que indica se o Type é um objeto COM.

IsConstructedGenericType

Obtém um valor que indica se este objeto representa um tipo genérico construído. Você pode criar instâncias de um tipo genérico construído.

IsContextful

Obtém um valor que indica se o Type pode ser hospedado em um contexto.

IsEnum

Obtém um valor que indica se o Type atual representa uma enumeração.

IsExplicitLayout

Obtém um valor que indica se os campos do tipo atual são apresentados em deslocamentos explicitamente especificados.

IsGenericMethodParameter

Obtém um valor que indica se o Type atual representa um parâmetro na definição de um método genérico.

IsGenericParameter

Obtém um valor que indica se o Type atual representa um parâmetro de tipo na definição de um tipo ou método genérico.

IsGenericType

Obtém um valor que indica se o tipo atual é um tipo genérico.

IsGenericTypeDefinition

Obtém um valor que indica se o Type atual representa uma definição de tipo genérico, da qual outros tipos genéricos podem ser construídos.

IsGenericTypeParameter

Obtém um valor que indica se o Type atual representa um parâmetro de tipo na definição de um tipo genérico.

IsImport

Obtém um valor que indica se o Type tem um atributo ComImportAttribute aplicado, indicando que ele foi importado de uma biblioteca de tipos COM.

IsInterface

Obtém um valor que indica se o Type é uma interface, ou seja, não é uma classe ou um tipo de valor.

IsLayoutSequential

Obtém um valor que indica se os campos do tipo atual são apresentados em sequência, na ordem em que foram definidos ou emitidos para os metadados.

IsMarshalByRef

Obtém um valor que indica se é realizado marshal no Type por referência.

IsNested

Obtém um valor que indica se o objeto atual Type representa um tipo cuja definição está aninhada dentro da definição de outro tipo.

IsNestedAssembly

Obtém um valor que indica se o Type é aninhado e visível somente dentro de seu próprio assembly.

IsNestedFamANDAssem

Obtém um valor que indica se o Type é aninhado e visíveis somente para classes que pertencem à sua própria família e ao seu próprio assembly.

IsNestedFamily

Obtém um valor que indica se o Type é aninhado e visível somente dentro de sua própria família.

IsNestedFamORAssem

Obtém um valor que indica se o Type é aninhado e visíveis somente para classes que pertençam à sua própria família ou ao seu próprio assembly.

IsNestedPrivate

Obtém um valor que indica se o Type é aninhado e declarado privado.

IsNestedPublic

Obtém um valor que indica se uma classe é aninhada e declarada pública.

IsNotPublic

Obtém um valor que indica se o Type não está declarado como público.

IsPointer

Obtém um valor que indica se o Type é um ponteiro.

IsPrimitive

Obtém um valor que indica se o Type é um dos tipos primitivos.

IsPublic

Obtém um valor que indica se o Type está declarado como público.

IsSealed

Obtém um valor que indica se o Type está declarado selado.

IsSecurityCritical

Obtém um valor que indica se o tipo atual é crítico para segurança ou crítico para segurança e disponível no código transparente no nível de confiança atual e, portanto, pode realizar operações críticas.

IsSecuritySafeCritical

Obtém um valor que indica se o tipo é crítico para segurança e disponível no código transparente no nível de confiança atual, ou seja, se ele pode realizar operações críticas e ser acessado por código transparente.

IsSecurityTransparent

Obtém um valor que indica que se o tipo atual é transparente no nível de confiança atual e, portanto, não pode realizar operações críticas.

IsSerializable

Obtém um valor que indica se o Type é serializável.

IsSignatureType

Obtém um valor que indica se o tipo é um tipo de assinatura.

IsSpecialName

Obtém um valor que indica se o tipo tem um nome que exige tratamento especial.

IsSZArray

Obtém um valor que indica se o tipo é um tipo de matriz que pode representar apenas uma única matriz unidimensional com um limite inferior a zero.

IsTypeDefinition

Obtém um valor que indica se o tipo é uma definição de tipo.

IsUnicodeClass

Obtém um valor que indica se o atributo de formato da cadeia de caracteres UnicodeClass está selecionado para o Type.

IsValueType

Obtém um valor que indica se o Type é um tipo de valor.

IsVariableBoundArray

Obtém um valor que indica se o tipo é um tipo de matriz que pode representar uma matriz multidimensional ou uma matriz com um limite inferior arbitrário.

IsVisible

Obtém um valor que indica se Type pode ser acessado pelo código fora do assembly.

MemberType

Obtém um valor MemberTypes que indica que esse membro é um tipo ou um tipo aninhado.

MetadataToken

Obtém um valor que identifica um elemento de metadados.

(Herdado de MemberInfo)
Module

Obtém o módulo (a DLL) no qual o Type atual está definido.

Name

Quando é substituído em uma classe derivada, obtém o nome do tipo atual.

Name

Obtém o nome do membro atual.

(Herdado de MemberInfo)
Namespace

Obtém o namespace do Type.

ReflectedType

Obtém o objeto de classe que foi usado para obter esse membro.

StructLayoutAttribute

Obtém um StructLayoutAttribute que descreve o layout do tipo atual.

TypeHandle

Obtém o identificador do Type atual.

TypeInitializer

Obtém o inicializador para o tipo.

UnderlyingSystemType

Indica o tipo fornecido pelo Common Language Runtime que representa esse tipo.

Métodos

Equals(Object)

Determina se o tipo de sistema subjacente do objeto Type atual é o mesmo que o tipo de sistema subjacente do Object especificado.

Equals(Type)

Determina se o tipo de sistema subjacente do Type atual é o mesmo que o tipo de sistema subjacente do Type especificado.

FindInterfaces(TypeFilter, Object)

Retorna uma matriz de objetos Type que representa uma lista filtrada das interfaces implementadas ou herdadas pelo Type atual.

FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)

Retorna uma matriz filtrada de objetos MemberInfo do tipo do membro especificado.

GetArrayRank()

Obtém o número de dimensões em uma matriz.

GetAttributeFlagsImpl()

Quando substituído em uma classe derivada, implementa a propriedade Attributes e obtém uma combinação bit a bit dos valores de enumeração que indicam os atributos associados ao Type.

GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Pesquisa por um construtor cujos parâmetros correspondem aos tipos de argumento e modificadores especificados, usando as restrições de associação especificadas e a convenção de chamada especificada.

GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])

Pesquisa o construtor cujos parâmetros correspondem aos tipos de argumento e modificadores especificados, usando as restrições de associação especificadas.

GetConstructor(BindingFlags, Type[])

Pesquisa um construtor cujos parâmetros correspondem aos tipos de argumento especificados, usando as restrições de associação especificadas.

GetConstructor(Type[])

Pesquisa um construtor de instância pública cujos parâmetros correspondem aos tipos na matriz especificada.

GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Quando substituído em uma classe derivada, pesquisa por um construtor cujos parâmetros correspondem aos tipos de argumento e modificadores especificados, usando as restrições de associação especificadas e a convenção de chamada especificada.

GetConstructors()

Retorna todos os construtores públicos definidos para o Type atual.

GetConstructors(BindingFlags)

Quando substituído em uma classe derivada, pesquisa os construtores definidos para o Type atual usando os BindingFlags especificados.

GetCustomAttributes(Boolean)

Quando substituído em uma classe derivada, retorna uma matriz de todos os atributos personalizados aplicados a esse membro.

(Herdado de MemberInfo)
GetCustomAttributes(Type, Boolean)

Quando substituído em uma classe derivada, retorna uma matriz de atributos personalizados aplicados a esse membro e identificados por Type.

(Herdado de MemberInfo)
GetCustomAttributesData()

Retorna uma lista de objetos CustomAttributeData que representam dados sobre os atributos que foram aplicados ao membro de destino.

(Herdado de MemberInfo)
GetDefaultMembers()

Procura os membros definidos para o Type atual, cujo DefaultMemberAttribute está definido.

GetElementType()

Quando substituído em uma classe derivada, retorna o Type do objeto englobado ou referenciado pelo tipo de matriz, ponteiro ou tipo de referência.

GetEnumName(Object)

Retorna o nome da constante que tem o valor especificado para o tipo de enumeração atual.

GetEnumNames()

Retorna os nomes dos membros do tipo de enumeração atual.

GetEnumUnderlyingType()

Retorna o tipo subjacente do tipo de enumeração atual.

GetEnumValues()

Retorna uma matriz de valores das constantes no tipo de enumeração especificado.

GetEvent(String)

Retorna o objeto EventInfo que representa o evento público especificado.

GetEvent(String, BindingFlags)

Quando substituído em uma classe derivada, retorna o objeto EventInfo que representa o evento especificado, usando as restrições de associação especificadas.

GetEvents()

Retorna todos os eventos públicos que são declarados ou herdados pelo Type atual.

GetEvents(BindingFlags)

Quando substituído em uma classe derivada, procura por eventos que são declarados ou herdados pelo Type atual, usando as restrições de associação especificadas.

GetField(String)

Pesquisa o campo público com o nome especificado.

GetField(String, BindingFlags)

Pesquisa o campo especificado usando as restrições de associação especificadas.

GetFields()

Retorna todos os campos públicos do Type atual.

GetFields(BindingFlags)

Quando é substituído em uma classe derivada, pesquisa os campos definidos para o Type atual usando as restrições de associação especificadas.

GetGenericArguments()

Retorna uma matriz de objetos Type que representam os argumentos de tipo de um tipo genérico fechado ou os parâmetros de tipo de uma definição de tipo genérico.

GetGenericParameterConstraints()

Retorna uma matriz de objetos Type que representam as restrições no parâmetro de tipo genérico atual.

GetGenericTypeDefinition()

Retorna um objeto Type que representa uma definição de tipo genérico do qual o tipo genérico atual pode ser criado.

GetHashCode()

Retorna o código hash para a instância.

GetInterface(String)

Pesquisa a interface com o nome especificado.

GetInterface(String, Boolean)

Quando substituído em uma classe derivada, procura pela interface especificada, indicando se deseja fazer uma pesquisa que não diferencia maiúsculas de minúsculas pelo nome da interface.

GetInterfaceMap(Type)

Retorna um mapeamento de interface para o tipo de interface especificado.

GetInterfaces()

Quando substituído em uma classe derivada, obtém todas as interfaces implementadas ou herdadas pelo Type atual.

GetMember(String)

Pesquisa a propriedade pública com o nome especificado.

GetMember(String, BindingFlags)

Pesquisa os membros especificados usando as restrições de associação especificadas.

GetMember(String, MemberTypes, BindingFlags)

Pesquisa os membros especificados do tipo de membro especificado, usando as restrições de associação especificadas.

GetMembers()

Retorna todos os membros públicos do Type atual.

GetMembers(BindingFlags)

Quando é substituído em uma classe derivada, pesquisa os membros definidos para o Type atual usando as restrições de associação especificadas.

GetMemberWithSameMetadataDefinitionAs(MemberInfo)

Pesquisa o MemberInfo atual Type que corresponde ao especificado MemberInfo.

GetMethod(String)

Pesquisa o método público com o nome especificado.

GetMethod(String, BindingFlags)

Pesquisa o método especificado, usando as restrições de associação especificadas.

GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Pesquisa o método especificado cujos parâmetros correspondem aos tipos de argumento e modificadores especificados, usando as restrições de associação especificadas e a convenção de chamada especificada.

GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])

Pesquisa o método especificado cujos parâmetros correspondem aos tipos de argumento e modificadores especificados, usando as restrições de associação especificadas.

GetMethod(String, BindingFlags, Type[])

Pesquisa o método especificado cujos parâmetros correspondem aos tipos de argumento especificados, usando as restrições de associação especificadas.

GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Pesquisa o método especificado cujos parâmetros correspondem à contagem de parâmetros genéricos, aos tipos de argumento e aos modificadores, usando as restrições de associação especificadas e a convenção de chamada especificada.

GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])

Pesquisa pelo método especificado cujos parâmetros correspondem à contagem de parâmetros genéricos especificada, aos tipos de argumento e aos modificadores, usando as restrições de associação especificadas.

GetMethod(String, Int32, Type[])

Pesquisa o método público especificado cujos parâmetros correspondem à contagem de parâmetros genéricos e aos tipos de argumento especificados.

GetMethod(String, Int32, Type[], ParameterModifier[])

Pesquisa o método público especificado cujos parâmetros correspondem à contagem de parâmetros genéricos, aos tipos de argumento especificados e aos modificadores.

GetMethod(String, Type[])

Pesquisa o método público especificado cujos parâmetros correspondem aos tipos de argumento especificados.

GetMethod(String, Type[], ParameterModifier[])

Pesquisa o método público especificado cujos parâmetros correspondem aos modificadores e tipos de argumento especificados.

GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Quando substituído em uma classe derivada, pesquisa o método especificado, cujos parâmetros correspondem aos tipos de argumento e modificadores especificados, usando as restrições de associação especificadas e a convenção de chamada especificada.

GetMethodImpl(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Quando substituído em uma classe derivada, pesquisa o método especificado, cujos parâmetros correspondem à contagem de parâmetros genéricos, aos tipos de argumento e aos modificadores especificados, usando as restrições de associação especificadas e a convenção de chamada especificada.

GetMethods()

Retorna todos os métodos públicos do Type atual.

GetMethods(BindingFlags)

Quando é substituído em uma classe derivada, pesquisa os métodos definidos para o Type atual usando as restrições de associação especificadas.

GetNestedType(String)

Pesquisa o tipo aninhado público com o nome especificado.

GetNestedType(String, BindingFlags)

Quando substituído em uma classe derivada, pesquisa as propriedades do tipo aninhado especificado, usando as restrições de associação especificadas.

GetNestedTypes()

Retorna os tipos públicos aninhados no Type atual.

GetNestedTypes(BindingFlags)

Quando é substituído em uma classe derivada, pesquisa as propriedades do Type atual, usando as restrições de associação especificadas.

GetProperties()

Retorna todas as propriedades públicas do Type atual.

GetProperties(BindingFlags)

Quando é substituído em uma classe derivada, pesquisa as propriedades do atual Type, usando as restrições de associação especificadas.

GetProperty(String)

Pesquisa a propriedade pública com o nome especificado.

GetProperty(String, BindingFlags)

Pesquisa a propriedade especificada usando as restrições de associação especificadas.

GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

Pesquisa a propriedade especificada cujos parâmetros correspondem aos modificadores e tipos de argumento especificados, usando as restrições de associação especificadas.

GetProperty(String, Type)

Pesquisa a propriedade pública com o nome e tipo retornado especificados.

GetProperty(String, Type, Type[])

Pesquisa a propriedade pública especificada cujos parâmetros correspondem aos tipos de argumento especificados.

GetProperty(String, Type, Type[], ParameterModifier[])

Pesquisa a propriedade pública especificada cujos parâmetros correspondem aos tipos de argumento e modificadores especificados.

GetProperty(String, Type[])

Pesquisa a propriedade pública especificada cujos parâmetros correspondem aos tipos de argumento especificados.

GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

Quando substituído em uma classe derivada, pesquisa a propriedade especificada cujos parâmetros correspondem aos modificadores e tipos de argumento especificados, usando as restrições de associação especificadas.

GetType()

Obtém o Type atual.

GetType()

Obtém o Type da instância atual.

(Herdado de Object)
GetType(String)

Obtém o Type com o nome especificado, com a execução de uma pesquisa que diferencia maiúsculas de minúsculas.

GetType(String, Boolean)

Obtém o Type com o nome especificado, realizando uma pesquisa que diferencia minúsculas e maiúsculas e especificando se deve ou não lançar uma exceção se o tipo não for encontrado.

GetType(String, Boolean, Boolean)

Obtém o Type com o nome especificado, especificando se deve ou não lançar uma exceção se o tipo não for encontrado e se deseja executar uma pesquisa diferenciando maiúsculas de minúsculas.

GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>)

Obtém o tipo com o nome especificado, fornecendo opcionalmente métodos personalizados para resolver o assembly e o tipo.

GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean)

Obtém o tipo com o nome definido, especificando se deverá ser lançada uma exceção se o tipo não for encontrado e, opcionalmente, fornecendo métodos personalizados para resolver o assembly e o tipo.

GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean)

Obtém o tipo com o nome definido, especificando se uma pesquisa que diferencia maiúsculas de minúsculas deverá ser realizada e se uma exceção deverá ser gerada se o tipo não for encontrado, com a opção de também fornecer métodos personalizados para resolver o assembly e o tipo.

GetTypeArray(Object[])

Obtém os tipos dos objetos na matriz especificada.

GetTypeCode(Type)

Obtém o código de tipo subjacente do Type especificado.

GetTypeCodeImpl()

Retorna o código de tipo subjacente desta instância Type.

GetTypeFromCLSID(Guid)

Obtém o tipo associado ao identificador de classe especificado (CLSID).

GetTypeFromCLSID(Guid, Boolean)

Obtém o tipo associado ao CLSID (identificador de classe) especificado, especificando se deverá gerar uma exceção se ocorrer um erro ao carregar o tipo.

GetTypeFromCLSID(Guid, String)

Obtém o tipo associado ao CLSID (identificador de classe) especificado do servidor especificado.

GetTypeFromCLSID(Guid, String, Boolean)

Obtém o tipo associado ao CLSID (identificador de classe) especificado do servidor especificado, determinando se uma exceção deverá ser gerada se ocorrer um erro durante o carregamento do tipo.

GetTypeFromHandle(RuntimeTypeHandle)

Obtém o tipo referenciado pelo identificador do tipo especificado.

GetTypeFromProgID(String)

Obtém o tipo associado ao identificador de programa (ProgID) especificado, retornando null se for encontrado um erro ao carregar o Type.

GetTypeFromProgID(String, Boolean)

Obtém o tipo associado ao ProgID (identificador de programa) especificado, especificando se uma exceção deverá ser gerada se ocorrer um erro ao carregar o tipo.

GetTypeFromProgID(String, String)

Obtém o tipo associado ao progID (identificador de programa) especificado do servidor especificado, retornando nulo caso seja encontrado algum erro ao carregar o tipo.

GetTypeFromProgID(String, String, Boolean)

Obtém o tipo associado ao progID (identificador de programa) especificado do servidor especificado, especificando se uma exceção deverá ser gerada se ocorrer um erro durante o carregamento do tipo.

GetTypeHandle(Object)

Obtém o identificador para o Type de um objeto especificado.

HasElementTypeImpl()

Quando substituído em uma classe derivada, implementa a propriedade HasElementType e determina se o Type atual abrange ou se refere a outro tipo, ou seja, se o Type atual é uma matriz, um ponteiro ou é passado por referência.

HasSameMetadataDefinitionAs(MemberInfo) (Herdado de MemberInfo)
InvokeMember(String, BindingFlags, Binder, Object, Object[])

Invoca o membro especificado, usando as restrições de associação especificadas e fazendo a correspondência da lista de argumentos especificada.

InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)

Invoca o membro especificado, usando as restrições de associação especificadas e fazendo a correspondência da lista de argumentos e cultura especificadas.

InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])

Quando substituído em uma classe derivada, invoca o membro especificado usando as restrições de associação especificadas e correspondendo a cultura, modificadores e lista de argumentos especificados.

IsArrayImpl()

Quando substituído em uma classe derivada, implementa a propriedade IsArray e determina se o Type é uma matriz.

IsAssignableFrom(Type)

Determina se uma instância de um tipo c especificado pode ser atribuída a uma variável do tipo atual.

IsAssignableTo(Type)

Determina se o tipo atual pode ser atribuído a uma variável do targetType especificado.

IsByRefImpl()

Quando substituído em uma classe derivada, implementa a propriedade IsByRef e determina se o Type é passado por referência.

IsCOMObjectImpl()

Quando substituído em uma classe derivada, implementa a propriedade IsCOMObject e determina se o Type é um objeto COM.

IsContextfulImpl()

Implementa a propriedade IsContextful e determina se o Type pode ser hospedado em um contexto.

IsDefined(Type, Boolean)

Quando substituído em uma classe derivada, indica se um ou mais atributos do tipo especificado ou de seus tipos derivados são aplicados a esse membro.

(Herdado de MemberInfo)
IsEnumDefined(Object)

Retorna um valor que indica se o valor especificado existe no tipo de enumeração atual.

IsEquivalentTo(Type)

Determina se dois tipos COM têm a mesma identidade e são elegíveis para equivalência de tipo.

IsInstanceOfType(Object)

Determina se o objeto especificado é uma instância do Type atual.

IsMarshalByRefImpl()

Implementa a propriedade IsMarshalByRef e determina se é realizado marshal no Type por referência.

IsPointerImpl()

Quando substituído em uma classe derivada, implementa a propriedade IsPointer e determina se o Type é um ponteiro.

IsPrimitiveImpl()

Quando substituído em uma classe derivada, implementa a propriedade IsPrimitive e determina se o Type é um dos tipos primitivos.

IsSubclassOf(Type)

Determina se o Type atual deriva do Type especificado.

IsValueTypeImpl()

Implementa a propriedade IsValueType e determina se o Type é um tipo de valor, ou seja, não é uma classe nem uma interface.

MakeArrayType()

Retorna um objeto Type que representa uma matriz unidimensional do tipo atual, com um limite inferior de zero.

MakeArrayType(Int32)

Retorna um objeto Type que representa uma matriz do tipo atual, com o número de dimensões especificado.

MakeByRefType()

Retorna um objeto Type que representa o tipo atual quando passado como um parâmetro ref (parâmetro ByRef no Visual Basic).

MakeGenericMethodParameter(Int32)

Retorna um objeto de tipo de assinatura que pode ser passado para o parâmetro de matriz Type[] de um método GetMethod para representar uma referência de parâmetro genérico.

MakeGenericSignatureType(Type, Type[])

Cria um tipo de assinatura genérico, que permite reimplementações de terceiros de Refletir para dar suporte completo ao uso de tipos de assinatura ao consultar membros de tipo.

MakeGenericType(Type[])

Substitui os elementos de uma matriz de tipos pelos parâmetros de tipo da definição de tipo genérico atual e retorna um objeto Type que representa o tipo construído resultante.

MakePointerType()

Retorna um objeto Type que representa um ponteiro para o tipo atual.

MemberwiseClone()

Cria uma cópia superficial do Object atual.

(Herdado de Object)
ReflectionOnlyGetType(String, Boolean, Boolean)
Obsoleto.

Obtém o Type com o nome especificado, especificando se deverá realizar uma pesquisa que diferencia maiúsculas de minúsculas e se deverá gerar uma exceção se o tipo não for encontrado. O tipo é carregado para reflexão apenas, não para execução.

ToString()

Retorna uma String que representa o nome da Type atual.

Operadores

Equality(Type, Type)

Indica se dois objetos Type são iguais.

Inequality(Type, Type)

Indica se dois objetos Type não são iguais.

Implantações explícitas de interface

_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mapeia um conjunto de nomes para um conjunto correspondente de identificadores de expedição.

(Herdado de MemberInfo)
_MemberInfo.GetType()

Obtém um objeto Type que representa a classe MemberInfo.

(Herdado de MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera as informações do tipo de um objeto, que podem ser usadas para obter informações de tipo para uma interface.

(Herdado de MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Retorna o número de interfaces de informações do tipo que um objeto fornece (0 ou 1).

(Herdado de MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fornece acesso a propriedades e métodos expostos por um objeto.

(Herdado de MemberInfo)
_Type.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mapeia um conjunto de nomes para um conjunto correspondente de identificadores de expedição.

_Type.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera as informações do tipo de um objeto, que podem ser usadas para obter informações de tipo para uma interface.

_Type.GetTypeInfoCount(UInt32)

Retorna o número de interfaces de informações do tipo que um objeto fornece (0 ou 1).

_Type.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fornece acesso a propriedades e métodos expostos por um objeto.

Métodos de Extensão

GetCustomAttribute(MemberInfo, Type)

Recupera um atributo personalizado de um tipo especificado aplicado a um membro especificado.

GetCustomAttribute(MemberInfo, Type, Boolean)

Recupera um atributo personalizado de um tipo especificado aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.

GetCustomAttribute<T>(MemberInfo)

Recupera um atributo personalizado de um tipo especificado aplicado a um membro especificado.

GetCustomAttribute<T>(MemberInfo, Boolean)

Recupera um atributo personalizado de um tipo especificado aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.

GetCustomAttributes(MemberInfo)

Recupera uma coleção de atributos personalizados que são aplicados a um membro especificado.

GetCustomAttributes(MemberInfo, Boolean)

Recupera uma coleção de atributos personalizados aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.

GetCustomAttributes(MemberInfo, Type)

Recupera uma coleção de atributos personalizados de um tipo especificado que são aplicados a um membro especificado.

GetCustomAttributes(MemberInfo, Type, Boolean)

Recupera uma coleção de atributos personalizados de um tipo especificado aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.

GetCustomAttributes<T>(MemberInfo)

Recupera uma coleção de atributos personalizados de um tipo especificado que são aplicados a um membro especificado.

GetCustomAttributes<T>(MemberInfo, Boolean)

Recupera uma coleção de atributos personalizados de um tipo especificado aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.

IsDefined(MemberInfo, Type)

Indica se os atributos personalizados de um tipo especificados são aplicados a um membro especificado.

IsDefined(MemberInfo, Type, Boolean)

Indica se os atributos personalizados de um tipo especificado são aplicados a um membro especificado e, opcionalmente, aplicados a seus ancestrais.

GetTypeInfo(Type)

Retorna a representação de TypeInfo do tipo especificado.

GetMetadataToken(MemberInfo)

Obtém um token de metadados para o membro fornecido, se disponível.

HasMetadataToken(MemberInfo)

Retorna um valor que indica se um token de metadados está disponível para o membro especificado.

GetRuntimeEvent(Type, String)

Recupera um objeto que representa o evento especificado.

GetRuntimeEvents(Type)

Recupera uma coleção que representa todos os eventos definidos em um tipo especificado.

GetRuntimeField(Type, String)

Recupera um objeto que representa um campo especificado.

GetRuntimeFields(Type)

Recupera uma coleção que representa todos os campos definidos em um tipo especificado.

GetRuntimeMethod(Type, String, Type[])

Recupera um objeto que representa um método especificado.

GetRuntimeMethods(Type)

Recupera uma coleção que representa todos os métodos definidos em um tipo especificado.

GetRuntimeProperties(Type)

Recupera uma coleção que representa todas as propriedades definidas em um tipo especificado.

GetRuntimeProperty(Type, String)

Recupera um objeto que representa uma propriedade especificada.

GetConstructor(Type, Type[])
GetConstructors(Type)
GetConstructors(Type, BindingFlags)
GetDefaultMembers(Type)
GetEvent(Type, String)
GetEvent(Type, String, BindingFlags)
GetEvents(Type)
GetEvents(Type, BindingFlags)
GetField(Type, String)
GetField(Type, String, BindingFlags)
GetFields(Type)
GetFields(Type, BindingFlags)
GetGenericArguments(Type)
GetInterfaces(Type)
GetMember(Type, String)
GetMember(Type, String, BindingFlags)
GetMembers(Type)
GetMembers(Type, BindingFlags)
GetMethod(Type, String)
GetMethod(Type, String, BindingFlags)
GetMethod(Type, String, Type[])
GetMethods(Type)
GetMethods(Type, BindingFlags)
GetNestedType(Type, String, BindingFlags)
GetNestedTypes(Type, BindingFlags)
GetProperties(Type)
GetProperties(Type, BindingFlags)
GetProperty(Type, String)
GetProperty(Type, String, BindingFlags)
GetProperty(Type, String, Type)
GetProperty(Type, String, Type, Type[])
IsAssignableFrom(Type, Type)
IsInstanceOfType(Type, Object)

Aplica-se a

Acesso thread-safe

Este tipo é thread-safe.

Confira também