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. As especificações de nome de tipo são usadas por métodos como Type.GetType, , Module.GetTypee ModuleBuilder.GetTypeAssembly.GetType.

Gramática para nomes de tipo

A gramática define a sintaxe das linguagens formais. A tabela a seguir lista regras léxicos 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 pipe (|) denota 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
	;

Especificar caracteres especiais

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

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

Em todos os componentes do TypeSpec, exceto AssemblyNameSpec, os espaços são relevantes. No AssemblyNameSpec, os espaços antes do separador ',' são relevantes, mas os espaços após o separador ''são ignorados.

Classes de reflexão, como Type.FullName, retornam o nome modificado para que o nome retornado possa ser usado em chamada a 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 por uma lista separada por vírgulas de pares de propriedade/valor, conforme descrito na tabela a seguir. A nomenclatura do IDENTIFICADOR deve seguir as regras para nomes de arquivos. O IDENTIFIER não diferencia maiúsculas de minúsculas.

O exemplo a seguir apresenta um AssemblyName para um assembly com nome simples e 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 com de 1 a n parâmetros de tipo genérico. Por exemplo, para fazer referência ao tipo List<T> genérico aberto ou ao tipo List<String>genérico fechado, use Type.GetType("System.Collections.Generic.List`1") Para obter uma referência ao tipo Dictionary<TKey,TValue>genérico, 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 gerenciado ou uma referência. 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 a definições de tipo incompletas recuperadas usando ModuleBuilder.GetType. Definições de tipo incompletas são TypeBuilder objetos construídos usando System.Reflection.Emit, mas nos quais TypeBuilder.CreateType não foi chamado. ReflectionDimension pode ser usado para recuperar qualquer definição de tipo que tenha sido concluída, ou seja, um tipo que tenha sido 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 0 limite inferior.
• 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[*,*]") é avaliado como verdadeiro.

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

Consulte também

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