Especificar nomes de tipo totalmente qualificadoSpecifying fully qualified type names

Você deve especificar nomes de tipo para ter uma entrada válida para várias operações de reflexão.You must specify type names to have valid input to various reflection operations. 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.A fully qualified type name consists of an assembly name specification, a namespace specification, and a type name. Especificações de nome de tipo são usadas por métodos como Type.GetType, Module.GetType, ModuleBuilder.GetType e Assembly.GetType.Type name specifications are used by methods such as Type.GetType, Module.GetType, ModuleBuilder.GetType, and Assembly.GetType.

Gramática para nomes de tipoGrammar for type names

A gramática define a sintaxe de linguagens formais.The grammar defines the syntax of formal languages. A tabela a seguir lista as regras lexicais que descrevem como reconhecer uma entrada válida.The following table lists lexical rules that describe how to recognize a valid input. Terminais (elementos que não poder ser mais reduzidos) são mostrados em letras maiúsculas.Terminals (those elements that are not further reducible) are shown in all uppercase letters. 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.Nonterminals (those elements that are further reducible) are shown in mixed-case or singly quoted strings, but the single quote (') is not a part of the syntax itself. O caractere de barra vertical (|) indica que as regras que têm sub-regras.The pipe character (|) denotes rules that have subrules.

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 especiaisSpecifying special characters

Em um nome de tipo, IDENTIFIER é qualquer nome válido determinado pelas regras de uma linguagem.In a type name, IDENTIFIER is any valid name determined by the rules of a language.

Use a barra invertida (\) como um caractere de escape para separar os seguintes tokens quando usados como parte do IDENTIFIER.Use the backslash (\) as an escape character to separate the following tokens when used as part of IDENTIFIER.

TokenToken SignificadoMeaning
\,\, Separador de assembly.Assembly separator.
\+ Separador de tipo aninhado.Nested type separator.
\& Tipo de referência.Reference type.
\* Tipo do ponteiro.Pointer type.
\[\[ Delimitador de dimensão da matriz.Array dimension delimiter.
\]\] Delimitador de dimensão da matriz.Array dimension delimiter.
\\. Use a barra invertida antes de um ponto somente se ele for usado em uma especificação de matriz.Use the backslash before a period only if the period is used in an array specification. Os pontos em NamespaceSpec não usam a barra invertida.Periods in NamespaceSpec do not take the backslash.
\|Barra invertida quando for necessária como uma cadeia de caracteres literal.\|Backslash when needed as a string literal.

Observe que, em todos os componentes de TypeSpec, exceto AssemblyNameSpec, os espaços são relevantes.Note that in all TypeSpec components except AssemblyNameSpec, spaces are relevant. No AssemblyNameSpec, os espaços antes do separador ',' são relevantes, mas espaços depois do separador ',' são ignorados.In the AssemblyNameSpec, spaces before the ',' separator are relevant, but spaces after the ',' separator are ignored.

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).Reflection classes, such as Type.FullName, return the mangled name so that the returned name can be used in a call to GetType, as in MyType.GetType(myType.FullName).

Por exemplo, o nome totalmente qualificado para um tipo pode ser Ozzy.OutBack.Kangaroo+Wallaby,MyAssembly.For example, the fully qualified name for a type might be Ozzy.OutBack.Kangaroo+Wallaby,MyAssembly.

Se o namespace fosse Ozzy.Out+Back, o sinal de adição deve ser precedido por uma barra invertida.If the namespace were Ozzy.Out+Back, then the plus sign must be preceded by a backslash. Caso contrário, o analisador o interpretaria como um separador de aninhamento.Otherwise, the parser would interpret it as a nesting separator. A reflexão emite essa cadeia de caracteres como Ozzy.Out\+Back.Kangaroo+Wallaby,MyAssembly.Reflection emits this string as Ozzy.Out\+Back.Kangaroo+Wallaby,MyAssembly.

Especificar nomes de assemblySpecifying assembly names

A informação mínima necessária em uma especificação de nome do assembly é o nome textual (IDENTIFIER) do assembly.The minimum information required in an assembly name specification is the textual name (IDENTIFIER) of the assembly. Você pode seguir o IDENTIFIER de uma lista separada por vírgulas de pares propriedade/valor, conforme descrito na tabela a seguir.You can follow the IDENTIFIER by a comma-separated list of property/value pairs as described in the following table. A nomenclatura do IDENTIFIER deve seguir as regras de nomenclatura de arquivo.IDENTIFIER naming should follow the rules for file naming. O IDENTIFIER não diferencia maiúsculas de minúsculas.The IDENTIFIER is case-insensitive.

Property nameProperty name DescriçãoDescription Valores permitidosAllowable values
VersãoVersion Número de versão do assemblyAssembly version number Major.Minor.Build.Revision, em que Major, Minor, Build e Revision são inteiro entre 0 e 65535, inclusive.Major.Minor.Build.Revision, where Major, Minor, Build, and Revision are integers between 0 and 65535 inclusive.
PublicKeyPublicKey Chave pública completaFull public key O valor da cadeia de caracteres da chave pública completa em formato hexadecimal.String value of full public key in hexadecimal format. Especifique uma referência nula (Nothing no Visual Basic) para indicar explicitamente um assembly particular.Specify a null reference (Nothing in Visual Basic) to explicitly indicate a private assembly.
PublicKeyTokenPublicKeyToken Token de chave pública (hash de 8 bytes da chave pública completa)Public key token (8-byte hash of the full public key) Valor da cadeia de caracteres do token de chave pública em formato hexadecimal.String value of public key token in hexadecimal format. Especifique uma referência nula (Nothing no Visual Basic) para indicar explicitamente um assembly particular.Specify a null reference (Nothing in Visual Basic) to explicitly indicate a private assembly.
CulturaCulture Cultura do assemblyAssembly culture A cultura do assembly no formato RFC-1766 ou “neutra” para assemblies independente de linguagem (não satélite).Culture of the assembly in RFC-1766 format, or "neutral" for language-independent (nonsatellite) assemblies.
PersonalizadoCustom BLOB (objeto binário grande) personalizado.Custom binary large object (BLOB). No momento, isso é usado apenas em assemblies gerados pelo Ngen (Gerador de Imagens Nativas).This is currently used only in assemblies generated by the Native Image Generator (Ngen). A cadeia de caracteres personalizada usada pela ferramenta do Gerador de Imagens Nativas para notificar o cache de assembly que o assembly que está sendo instalado é uma imagem nativa e, portanto, deve ser instalada no cache de imagens nativas.Custom string used by the Native Image Generator tool to notify the assembly cache that the assembly being installed is a native image, and is therefore to be installed in the native image cache. Também chamado de cadeia de caracteres zap.Also called a zap string.

A exemplo a seguir mostra um AssemblyName para um assembly de nome simples com cultura padrão.The following example shows an AssemblyName for a simply named assembly with default culture.

com.microsoft.crypto, Culture=""

O exemplo a seguir mostra uma referência totalmente especificada para um assembly de nome forte com a cultura “en”.The following example shows a fully specified reference for a strongly named assembly with culture "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.The following examples each show a partially specified AssemblyName, which can be satisfied by either a strong or a simply named assembly.

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.The following examples each show a partially specified AssemblyName, which must be satisfied by a simply named assembly.

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.The following examples each show a partially specified AssemblyName, which must be satisfied by a strongly named assembly.

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

Especificar tipos genéricosSpecifying generic types

SimpleTypeSpec`NÚMERO representa um tipo genérico aberto com 1 a n parâmetros de tipo genérico.SimpleTypeSpec`NUMBER represents an open generic type with from 1 to n generic type parameters. Por exemplo, para obter a referência para a Lista de tipo genérico aberto<T>, ou para a lista de tipo genérico fechado<Cadeia de caracteres>, use Type.GetType("System.Collections.Generic.List`1") para obter uma referência para o Dicionário de tipo genérico<TKey, TValue>, use Type.GetType("System.Collections.Generic.Dictionary`2").For example, to get reference to the open generic type List<T> or the closed generic type List<String>, use Type.GetType("System.Collections.Generic.List`1") To get a reference to the generic type Dictionary<TKey,TValue>, use Type.GetType("System.Collections.Generic.Dictionary`2").

Especificar ponteirosSpecifying pointers

SimpleTypeSpec* representa um ponteiro não gerenciado.SimpleTypeSpec* represents an unmanaged pointer. Por exemplo, para obter um ponteiro para o tipo MyType, use Type.GetType("MyType*").For example, to get a pointer to type MyType, use Type.GetType("MyType*"). Para obter um ponteiro para o tipo MyType, use Type.GetType("MyType**").To get a pointer to a pointer to type MyType, use Type.GetType("MyType**").

Especificar referênciasSpecifying references

SimpleTypeSpec & representa um ponteiro ou referência gerenciado.SimpleTypeSpec & represents a managed pointer or reference. Por exemplo, para obter uma referência ao tipo MyType, use Type.GetType("MyType &").For example, to get a reference to type MyType, use Type.GetType("MyType &"). Observe que, ao contrário dos ponteiros, as referências são limitadas a um nível.Note that unlike pointers, references are limited to one level.

Especificar matrizesSpecifying arrays

Na Gramática BNF, ReflectionEmitDimension só se aplica às definições de tipo incompletas recuperadas usando ModuleBuilder.GetType.In the BNF Grammar, ReflectionEmitDimension only applies to incomplete type definitions retrieved using 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.Incomplete type definitions are TypeBuilder objects constructed using System.Reflection.Emit but on which TypeBuilder.CreateType has not been called. É possível usar ReflectionDimension para recuperar qualquer definição de tipo que foi concluída, ou seja, um tipo que foi carregado.ReflectionDimension can be used to retrieve any type definition that has been completed, that is, a type that has been loaded.

Matrizes são acessadas na reflexão ao especificar a classificação da matriz:Arrays are accessed in reflection by specifying the rank of the array:

  • Type.GetType("MyArray[]") obtém uma matriz de dimensão única com o limite inferior 0.Type.GetType("MyArray[]") gets a single-dimension array with 0 lower bound.

  • Type.GetType("MyArray[*]") obtém uma matriz de dimensão única com limite inferior desconhecido.Type.GetType("MyArray[*]") gets a single-dimension array with unknown lower bound.

  • Type.GetType("MyArray[][]") recebe uma matriz bidimensional.Type.GetType("MyArray[][]") gets a two-dimensional array's array.

  • Type.GetType("MyArray[*,*]") e Type.GetType("MyArray[,]") obtém uma matriz bidimensional retangular com limites inferiores desconhecidos.Type.GetType("MyArray[*,*]") and Type.GetType("MyArray[,]") gets a rectangular two-dimensional array with unknown lower bounds.

Observe que, do ponto de vista do tempo de execução, MyArray[] != MyArray[*], mas para matrizes multidimensionais, as duas notações são equivalentes.Note that from a runtime point of view, MyArray[] != MyArray[*], but for multidimensional arrays, the two notations are equivalent. Ou seja, Type.GetType("MyArray [,]") == Type.GetType("MyArray[*,*]") é avaliada como true.That is, Type.GetType("MyArray [,]") == Type.GetType("MyArray[*,*]") evaluates to true.

Para ModuleBuilder.GetType, MyArray[0..5] indica uma matriz de dimensão única com tamanho 6 e limite inferior 0.For ModuleBuilder.GetType, MyArray[0..5] indicates a single-dimension array with size 6, lower bound 0. MyArray[4…] indica uma matriz de dimensão única de tamanho desconhecido e limite inferior 4.MyArray[4…] indicates a single-dimension array of unknown size and lower bound 4.

Consulte tambémSee also