Especificación de nombres de tipos completos

Debe especificar nombres de tipo para tener entradas válidas en varias operaciones de reflexión. 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. Las especificaciones de nombre de tipo las usan métodos como Type.GetType, Module.GetType, ModuleBuilder.GetType y Assembly.GetType.

Gramática de los nombres de tipo

La gramática define la sintaxis de los lenguajes formales. En la tabla siguiente se muestran las reglas léxicas que describen cómo reconocer una entrada válida. Los terminales (es decir, los elementos que no se pueden reducir más) se muestran en mayúsculas. 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í. El carácter de canalización (|) indica las reglas que tienen subreglas.

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 especiales

En un nombre de tipo, IDENTIFIER es cualquier nombre válido determinado por las reglas de un lenguaje.

Use la barra diagonal inversa (\) como carácter de escape para separar los tokens siguientes cuando se usan como parte de IDENTIFIER.

Los espacios son relevantes en todos los componentes de TypeSpec, salvo en AssemblyNameSpec. En AssemblyNameSpec, los espacios delante del separador "," son relevantes, pero los espacios detrás del separador "," se omiten.

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).

Por ejemplo, el nombre completo de un tipo podría ser 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. De lo contrario, el analizador lo interpretaría como un separador de anidamiento. La reflexión emite esta cadena como Ozzy.Out\+Back.Kangaroo+Wallaby,MyAssembly.

Especificación de nombres de ensamblado

La información mínima necesaria en una especificación de nombre de ensamblado es el nombre textual (IDENTIFIER) del ensamblado. Puede seguir el IDENTIFIER mediante una lista separada por comas de pares de propiedad-valor, como se describe en la tabla siguiente. La nomenclatura de IDENTIFIER debe seguir las reglas de la nomenclatura de archivos. IDENTIFIER no distingue mayúsculas de minúsculas.

En el ejemplo siguiente se muestra un AssemblyName para un ensamblado de nombre simple con una referencia cultural predeterminada.

com.microsoft.crypto, Culture=""

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

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.

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.

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

Especificación de tipos genéricos

SimpleTypeSpec`NUMBER representa un tipo genérico abierto de 1 a n parámetros de tipo genérico. Por ejemplo, para obtener la referencia al tipo genérico abierto List<T> o al 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").

Especificación de punteros

SimpleTypeSpec* representa un puntero no administrado. Por ejemplo, para obtener un puntero al tipo MyType, use Type.GetType("MyType*"). Para obtener un puntero a un puntero al tipo MyType, use Type.GetType("MyType**").

Especificación de referencias

SimpleTypeSpec & representa un puntero administrado o referencia. Por ejemplo, para obtener una referencia al tipo MyType, use Type.GetType("MyType &"). A diferencia de los punteros, las referencias están limitadas a un nivel.

Especificación de matrices

En la gramática de BNF, ReflectionEmitDimension solo se aplica a las definiciones de tipo incompletas recuperadas mediante 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. Se puede usar ReflectionDimension para recuperar cualquier definición de tipo que se haya completado, es decir, un tipo que se haya cargado.

Para obtener acceso a las matrices en la reflexión, se debe especificar el rango de la matriz:

• Type.GetType("MyArray[]") obtiene una matriz unidimensional con límite inferior 0.
• Type.GetType("MyArray[*]") obtiene una matriz unidimensional con límite inferior desconocido.
• Type.GetType("MyArray[][]") obtiene una matriz de la matriz bidimensional.
• Type.GetType("MyArray[*,*]") y Type.GetType("MyArray[,]") obtienen una matriz bidimensional rectangular con límites inferiores desconocidos.

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. Es decir, Type.GetType("MyArray [,]") == Type.GetType("MyArray[*,*]") se evalúa como true.

Para ModuleBuilder.GetType, MyArray[0..5] indica una matriz de una sola dimensión con el tamaño 6, límite inferior 0. MyArray[4…] indica una matriz unidimensional de tamaño desconocido y límite inferior 4.

Consulte también

• AssemblyName
• ModuleBuilder
• TypeBuilder
• Type.FullName
• Type.GetType
• Type.AssemblyQualifiedName
• Ver información de tipo