Especificar nombres de tipo completosSpecifying fully qualified type names

Debe especificar nombres de tipo para tener entradas válidas en varias operaciones de reflexión.You must specify type names to have valid input to various reflection operations. Un nombre de tipo completo consiste en una especificación de nombre de ensamblado, una especificación de espacio de nombres y un nombre de tipo.A fully qualified type name consists of an assembly name specification, a namespace specification, and a type name. Las especificaciones de nombre de tipo las usan métodos como Type.GetType, Module.GetType, ModuleBuilder.GetType y Assembly.GetType.Type name specifications are used by methods such as Type.GetType, Module.GetType, ModuleBuilder.GetType, and Assembly.GetType.

Gramática de los nombres de tipoGrammar for type names

La gramática define la sintaxis de los lenguajes formales.The grammar defines the syntax of formal languages. En la tabla siguiente se muestran las reglas léxicas que describen cómo reconocer una entrada válida.The following table lists lexical rules that describe how to recognize a valid input. Los terminales (es decir, los elementos que no se pueden reducir más) se muestran en mayúsculas.Terminals (those elements that are not further reducible) are shown in all uppercase letters. Los no terminales (es decir, los elementos que se pueden reducir más) se muestran en cadenas con mayúsculas y minúsculas mezcladas o en cadenas entre comillas simples, pero la comilla simple (') no forma parte de la sintaxis en sí.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. El carácter de canalización (|) indica las reglas que tienen subreglas.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
    ;

Especificación de caracteres especialesSpecifying special characters

En un nombre de tipo, IDENTIFIER es cualquier nombre válido determinado por las reglas de un lenguaje.In a type name, IDENTIFIER is any valid name determined by the rules of a language.

Use la barra diagonal inversa (\) como carácter de escape para separar los tokens siguientes cuando se usan como parte de IDENTIFIER.Use the backslash (\) as an escape character to separate the following tokens when used as part of IDENTIFIER.

TokenToken SignificadoMeaning
\,\, Separador de ensamblados.Assembly separator.
\+ Separador de tipos anidados.Nested type separator.
\& Tipo de referencia.Reference type.
\* Tipo de puntero.Pointer type.
\[\[ Delimitador de dimensión de matriz.Array dimension delimiter.
\]\] Delimitador de dimensión de matriz.Array dimension delimiter.
\.\. Use la barra diagonal inversa delante de un punto únicamente si el punto se usa en una especificación de matriz.Use the backslash before a period only if the period is used in an array specification. Los puntos de NamespaceSpec no llevan barra diagonal inversa.Periods in NamespaceSpec do not take the backslash.
\|Barra diagonal inversa cuando es necesaria como cadena literal.\|Backslash when needed as a string literal.

Tenga en cuenta que los espacios son relevantes en todos los componentes de TypeSpec, salvo en AssemblyNameSpec.Note that in all TypeSpec components except AssemblyNameSpec, spaces are relevant. En AssemblyNameSpec, los espacios delante del separador "," son relevantes, pero los espacios detrás del separador "," se omiten.In the AssemblyNameSpec, spaces before the ',' separator are relevant, but spaces after the ',' separator are ignored.

Las clases de reflexión, como Type.FullName, devuelven el nombre alterado para que el nombre devuelto pueda usarse en una llamada a GetType, como en 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 ejemplo, el nombre completo de un tipo podría ser Ozzy.OutBack.Kangaroo+Wallaby,MyAssembly.For example, the fully qualified name for a type might be Ozzy.OutBack.Kangaroo+Wallaby,MyAssembly.

Si el espacio de nombres fuera Ozzy.Out+Back, el signo más debería ir precedido de una barra diagonal inversa.If the namespace were Ozzy.Out+Back, then the plus sign must be preceded by a backslash. De lo contrario, el analizador lo interpretaría como un separador de anidamiento.Otherwise, the parser would interpret it as a nesting separator. La reflexión emite esta cadena como Ozzy.Out\+Back.Kangaroo+Wallaby,MyAssembly.Reflection emits this string as Ozzy.Out\+Back.Kangaroo+Wallaby,MyAssembly.

Especificación de nombres de ensambladoSpecifying assembly names

La información mínima necesaria en una especificación de nombre de ensamblado es el nombre textual (IDENTIFIER) del ensamblado.The minimum information required in an assembly name specification is the textual name (IDENTIFIER) of the assembly. Puede seguir el IDENTIFIER mediante una lista separada por comas de pares de propiedad-valor, como se describe en la tabla siguiente.You can follow the IDENTIFIER by a comma-separated list of property/value pairs as described in the following table. La nomenclatura de IDENTIFIER debe seguir las reglas de la nomenclatura de archivos.IDENTIFIER naming should follow the rules for file naming. IDENTIFIER no distingue mayúsculas de minúsculas.The IDENTIFIER is case-insensitive.

Nombre de la propiedadProperty name DESCRIPCIÓNDescription Valores permitidosAllowable values
VersiónVersion Número de versión del ensambladoAssembly version number Major.Minor.Build.Revision, donde Major, Minor, Build y Revision son números enteros entre 0 y 65535, ambos incluidos.Major.Minor.Build.Revision, where Major, Minor, Build, and Revision are integers between 0 and 65535 inclusive.
PublicKeyPublicKey Clave pública completaFull public key Valor de cadena de la clave pública completa en formato hexadecimal.String value of full public key in hexadecimal format. Especifique una referencia nula (Nothing en Visual Basic) para indicar explícitamente un ensamblado privado.Specify a null reference (Nothing in Visual Basic) to explicitly indicate a private assembly.
PublicKeyTokenPublicKeyToken Token de clave pública (hash de 8 bytes de la clave pública completa)Public key token (8-byte hash of the full public key) Valor de cadena del token de clave pública en formato hexadecimal.String value of public key token in hexadecimal format. Especifique una referencia nula (Nothing en Visual Basic) para indicar explícitamente un ensamblado privado.Specify a null reference (Nothing in Visual Basic) to explicitly indicate a private assembly.
Referencia culturalCulture Referencia cultural del ensambladoAssembly culture Referencia cultural del ensamblado en formato RFC-1766, o "neutral" para los ensamblados independientes del lenguaje (no satélite).Culture of the assembly in RFC-1766 format, or "neutral" for language-independent (nonsatellite) assemblies.
CustomCustom Objeto binario grande personalizado (BLOB).Custom binary large object (BLOB). Actualmente esto solo se usa en los ensamblados generados por el Generador de imágenes nativas (Ngen).This is currently used only in assemblies generated by the Native Image Generator (Ngen). Cadena personalizada que la herramienta Generador de imágenes nativas usa para notificar a la caché de ensamblados que el ensamblado que se está instalando es una imagen nativa y, por tanto, se tiene que instalar en la caché de imágenes 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. También se denomina cadena ZAP.Also called a zap string.

En el ejemplo siguiente se muestra un AssemblyName para un ensamblado de nombre simple con una referencia cultural predeterminada.The following example shows an AssemblyName for a simply named assembly with default culture.

com.microsoft.crypto, Culture=""

En el ejemplo siguiente se muestra una referencia completa para un ensamblado con nombre seguro con la referencia cultural "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

En los ejemplos siguientes se muestra un AssemblyName parcialmente especificado, que se puede resolver mediante un ensamblado con un nombre simple o seguro.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

En los ejemplos siguientes se muestra un AssemblyName parcialmente especificado, que se debe resolver mediante un ensamblado con un nombre simple.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

En los ejemplos siguientes se muestra un AssemblyName parcialmente especificado, que se debe resolver mediante un ensamblado con un nombre seguro.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

Especificación de tipos genéricosSpecifying generic types

SimpleTypeSpec`NUMBER representa un tipo genérico abierto de 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 ejemplo, para obtener la referencia al tipo genérico abierto List<T> o el tipo genérico cerrado List<String>, use Type.GetType("System.Collections.Generic.List`1"); para obtener una referencia al tipo genérico Dictionary<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").

Especificación de punterosSpecifying pointers

SimpleTypeSpec* representa un puntero no administrado.SimpleTypeSpec* represents an unmanaged pointer. Por ejemplo, para obtener un puntero al tipo MyType, use Type.GetType("MyType*").For example, to get a pointer to type MyType, use Type.GetType("MyType*"). Para obtener un puntero a un puntero al tipo MyType, use Type.GetType("MyType**").To get a pointer to a pointer to type MyType, use Type.GetType("MyType**").

Especificación de referenciasSpecifying references

SimpleTypeSpec & representa un puntero administrado o referencia.SimpleTypeSpec & represents a managed pointer or reference. Por ejemplo, para obtener una referencia al tipo MyType, use Type.GetType("MyType &").For example, to get a reference to type MyType, use Type.GetType("MyType &"). Tenga en cuenta que, a diferencia de los punteros, las referencias están limitadas a un nivel.Note that unlike pointers, references are limited to one level.

Especificación de matricesSpecifying arrays

En la gramática de BNF, ReflectionEmitDimension solo se aplica a las definiciones de tipo incompletas recuperadas mediante ModuleBuilder.GetType.In the BNF Grammar, ReflectionEmitDimension only applies to incomplete type definitions retrieved using ModuleBuilder.GetType. Las definiciones de tipo incompletas son objetos TypeBuilder construidos mediante System.Reflection.Emit, pero en los que no se ha llamado a TypeBuilder.CreateType.Incomplete type definitions are TypeBuilder objects constructed using System.Reflection.Emit but on which TypeBuilder.CreateType has not been called. Se puede usar ReflectionDimension para recuperar cualquier definición de tipo que se haya completado, es decir, un tipo que se haya cargado.ReflectionDimension can be used to retrieve any type definition that has been completed, that is, a type that has been loaded.

Para obtener acceso a las matrices en la reflexión, se debe especificar el rango de la matriz:Arrays are accessed in reflection by specifying the rank of the array:

  • Type.GetType("MyArray[]") obtiene una matriz unidimensional con límite inferior 0.Type.GetType("MyArray[]") gets a single-dimension array with 0 lower bound.

  • Type.GetType("MyArray[*]") obtiene una matriz unidimensional con límite inferior desconocido.Type.GetType("MyArray[*]") gets a single-dimension array with unknown lower bound.

  • Type.GetType("MyArray[][]") obtiene una matriz de la matriz bidimensional.Type.GetType("MyArray[][]") gets a two-dimensional array's array.

  • Type.GetType("MyArray[*,*]") y Type.GetType("MyArray[,]") obtienen una matriz bidimensional rectangular con límites inferiores desconocidos.Type.GetType("MyArray[*,*]") and Type.GetType("MyArray[,]") gets a rectangular two-dimensional array with unknown lower bounds.

Tenga en cuenta que, desde el punto de vista del tiempo de ejecución, MyArray[] != MyArray[*], pero en el caso de las matrices multidimensionales, las dos notaciones son equivalentes.Note that from a runtime point of view, MyArray[] != MyArray[*], but for multidimensional arrays, the two notations are equivalent. Es decir, Type.GetType("MyArray [,]") == Type.GetType("MyArray[*,*]") se evalúa como true.That is, Type.GetType("MyArray [,]") == Type.GetType("MyArray[*,*]") evaluates to true.

Para ModuleBuilder.GetType, MyArray[0..5] indica una matriz unidimensional de tamaño 6 y límite inferior 0.For ModuleBuilder.GetType, MyArray[0..5] indicates a single-dimension array with size 6, lower bound 0. MyArray[4…] indica una matriz unidimensional de tamaño desconocido y límite inferior 4.MyArray[4…] indicates a single-dimension array of unknown size and lower bound 4.

Vea tambiénSee also