Especificar nomes de tipo totalmente qualificados

Você deve especificar nomes de tipo para ter uma entrada válida para várias operações de reflexão. Um nome de tipo totalmente qualificado consiste em uma especificação de nome de assembly, uma especificação de namespace e um nome de tipo. Especificações de nome de tipo são usadas por métodos como Type.GetType, Module.GetType, ModuleBuilder.GetType e Assembly.GetType.

Gramática para nomes de tipo

A gramática define a sintaxe de linguagens formais. A tabela a seguir lista as regras lexicais que descrevem como reconhecer uma entrada válida. Terminais (elementos que não poder ser mais reduzidos) são mostrados em letras maiúsculas. Não terminais (elementos que ainda podem ser reduzidos) são mostrados em cadeias de caracteres combinando maiúsculas e minúsculas ou entre aspas simples, porém a aspa simples (') não faz parte da sintaxe em si. O caractere de barra vertical (|) indica regras que têm sub-regras.

TypeSpec
	: ReferenceTypeSpec
	| SimpleTypeSpec
	;

ReferenceTypeSpec
	: SimpleTypeSpec '&'
	;

SimpleTypeSpec
	: PointerTypeSpec
	| GenericTypeSpec
	| TypeName
	;

GenericTypeSpec
   : SimpleTypeSpec ` NUMBER

PointerTypeSpec
	: SimpleTypeSpec '*'
	;

ArrayTypeSpec
	: SimpleTypeSpec '[ReflectionDimension]'
	| SimpleTypeSpec '[ReflectionEmitDimension]'
	;

ReflectionDimension
	: '*'
	| ReflectionDimension ',' ReflectionDimension
	| NOTOKEN
	;

ReflectionEmitDimension
	: '*'
	| Number '..' Number
	| Number '…'
	| ReflectionDimension ',' ReflectionDimension
	| NOTOKEN
	;

Number
	: [0-9]+
	;

TypeName
	: NamespaceTypeName
	| NamespaceTypeName ',' AssemblyNameSpec
	;

NamespaceTypeName
	: NestedTypeName
	| NamespaceSpec '.' NestedTypeName
	;

NestedTypeName
	: IDENTIFIER
	| NestedTypeName '+' IDENTIFIER
	;

NamespaceSpec
	: IDENTIFIER
	| NamespaceSpec '.' IDENTIFIER
	;

AssemblyNameSpec
	: IDENTIFIER
	| IDENTIFIER ',' AssemblyProperties
	;

AssemblyProperties
	: AssemblyProperty
	| AssemblyProperties ',' AssemblyProperty
	;

AssemblyProperty
	: AssemblyPropertyName '=' AssemblyPropertyValue
	;

Especifique caracteres especiais

Em um nome de tipo, IDENTIFIER é qualquer nome válido determinado pelas regras de uma linguagem.

Use a barra invertida (\) como caractere de escape para separar os seguintes tokens quando usados como parte do IDENTIFIER.

Em todos os componentes de TypeSpec, com exceção do AssemblyNameSpec, os espaços são relevantes. No AssemblyNameSpec, os espaços antes do separador ',' são relevantes, mas espaços depois do separador ',' são ignorados.

Classes de reflexão, como Type.FullName, retornam o nome danificado, de forma que o nome retornado pode ser usado em uma chamada para GetType, como em MyType.GetType(myType.FullName).

Por exemplo, o nome totalmente qualificado para um tipo pode ser Ozzy.OutBack.Kangaroo+Wallaby,MyAssembly.

Se o namespace fosse Ozzy.Out+Back, o sinal de adição deve ser precedido por uma barra invertida. Caso contrário, o analisador o interpretaria como um separador de aninhamento. A reflexão emite essa cadeia de caracteres como Ozzy.Out\+Back.Kangaroo+Wallaby,MyAssembly.

Especificar nomes de assembly

A informação mínima necessária em uma especificação de nome do assembly é o nome textual (IDENTIFIER) do assembly. Você pode seguir o IDENTIFIER de uma lista separada por vírgulas de pares propriedade/valor, conforme descrito na tabela a seguir. A nomenclatura do IDENTIFIER deve seguir as regras de nomenclatura de arquivo. O IDENTIFIER não diferencia maiúsculas de minúsculas.

A exemplo a seguir mostra um AssemblyName para um assembly de nome simples com cultura padrão.

com.microsoft.crypto, Culture=""

O exemplo a seguir mostra uma referência totalmente especificada para um assembly de nome forte com a cultura “en”.

com.microsoft.crypto, Culture=en, PublicKeyToken=a5d015c7d5a0b012,
    Version=1.0.0.0

Todos os exemplos a seguir mostram AssemblyName parcialmente especificado, que pode ser atendido por um assembly de nome forte ou simples.

com.microsoft.crypto
com.microsoft.crypto, Culture=""
com.microsoft.crypto, Culture=en

Todos os exemplos a seguir mostram um AssemblyName parcialmente especificado, que deve ser atendido por um assembly de nome simples.

com.microsoft.crypto, Culture="", PublicKeyToken=null
com.microsoft.crypto, Culture=en, PublicKeyToken=null

Todos os exemplos a seguir mostram um AssemblyName parcialmente especificado, que deve ser atendido por um assembly de nome forte.

com.microsoft.crypto, Culture="", PublicKeyToken=a5d015c7d5a0b012
com.microsoft.crypto, Culture=en, PublicKeyToken=a5d015c7d5a0b012,
    Version=1.0.0.0

Especificar tipos genéricos

SimpleTypeSpec`NUMBER representa um tipo genérico aberto de 1 a n parâmetros do tipo genérico. Por exemplo, para obter uma referência ao tipo genérico aberto List<T> ou ao tipo genérico fechado List<String>, use Type.GetType("System.Collections.Generic.List`1"). Para obter uma referência do tipo genérico Dictionary<TKey,TValue>, use Type.GetType("System.Collections.Generic.Dictionary`2").

Especificar ponteiros

SimpleTypeSpec* representa um ponteiro não gerenciado. Por exemplo, para obter um ponteiro para o tipo MyType, use Type.GetType("MyType*"). Para obter um ponteiro para o tipo MyType, use Type.GetType("MyType**").

Especificar referências

SimpleTypeSpec & representa um ponteiro ou referência gerenciado. Por exemplo, para obter uma referência ao tipo MyType, use Type.GetType("MyType &"). Ao contrário dos ponteiros, as referências são limitadas a um nível.

Especificar matrizes

Na Gramática BNF, ReflectionEmitDimension só se aplica às definições de tipo incompletas recuperadas usando ModuleBuilder.GetType. As definições de tipo incompletas são objetos TypeBuilder construídos usando System.Reflection.Emit, mas no qual TypeBuilder.CreateType não foi chamado. É possível usar ReflectionDimension para recuperar qualquer definição de tipo que foi concluída, ou seja, um tipo que foi carregado.

Matrizes são acessadas na reflexão ao especificar a classificação da matriz:

• Type.GetType("MyArray[]") obtém uma matriz de dimensão única com o limite inferior 0.
• Type.GetType("MyArray[*]") obtém uma matriz de dimensão única com limite inferior desconhecido.
• Type.GetType("MyArray[][]") recebe uma matriz bidimensional.
• Type.GetType("MyArray[*,*]") e Type.GetType("MyArray[,]") obtém uma matriz bidimensional retangular com limites inferiores desconhecidos.

Do ponto de vista do runtime, MyArray[] != MyArray[*], mas para matrizes multidimensionais, as duas notações são equivalentes. Ou seja, Type.GetType("MyArray [,]") == Type.GetType("MyArray[*,*]") é avaliada como true.

Para o ModuleBuilder.GetType, MyArray[0..5] indica uma matriz de uma única dimensão de tamanho 6, limite inferior 0. MyArray[4…] indica uma matriz de dimensão única de tamanho desconhecido e limite inferior 4.

Confira também

• AssemblyName
• ModuleBuilder
• TypeBuilder
• Type.FullName
• Type.GetType
• Type.AssemblyQualifiedName
• Ver informações de tipo