Spécifier des noms de types complets

Vous devez spécifier des noms de types pour pouvoir valider l’entrée servant aux diverses opérations de réflexion. Un nom de type complet se compose d’une spécification de nom d’assembly, d’une spécification d’espace de noms et d’un nom de type. Les spécifications de noms de types sont utilisées par les méthodes telles que Type.GetType, Module.GetType, ModuleBuilder.GetType et Assembly.GetType.

Grammaire pour les noms de types

La grammaire définit la syntaxe des langages formels. Le tableau suivant décrit les règles lexicales permettant de reconnaître une entrée valide. Les éléments terminaux (qui ne peuvent pas être réduits davantage) sont affichés en majuscules. Les éléments non terminaux (qui peuvent être réduits davantage) sont affichés dans une casse mixte ou entre des guillemets simples ; toutefois, le guillemet simple (') ne fait pas partie de la syntaxe proprement dite. La barre verticale (|) signale des règles qui ont des sous-règles.

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
	;

Spécifier des caractères spéciaux

Dans un nom de type, IDENTIFIER correspond à n’importe quel nom valide déterminé par les règles d’un langage.

Utilisez la barre oblique inverse (\) comme caractère d’échappement pour séparer les jetons suivants quand ils sont utilisés avec IDENTIFIER.

Dans tous les composants TypeSpec à l’exception d’AssemblyNameSpec, les espaces sont pertinents. Dans AssemblyNameSpec, les espaces précédant le séparateur « , » peuvent être utilisés, mais ceux situés après le séparateur « , » sont ignorés.

Les classes Reflection, telles que Type.FullName, retournent le nom tronqué, lequel peut être utilisé dans un appel à GetType, comme dans MyType.GetType(myType.FullName).

Par exemple, le nom complet d’un type peut être Ozzy.OutBack.Kangaroo+Wallaby,MyAssembly.

Si l’espace de noms est Ozzy.Out+Back, le signe plus (+) doit être précédé d’une barre oblique inverse. Sinon, l’analyseur l’interprète comme un séparateur d’imbrication. La réflexion génère cette chaîne comme suit : Ozzy.Out\+Back.Kangaroo+Wallaby,MyAssembly.

Spécifier des noms d’assembly

Au minimum, vous devez fournir le nom textuel (IDENTIFIER) de l’assembly comme spécification du nom d’assembly. Vous pouvez faire suivre IDENTIFIER d’une liste de paires de propriétés/valeurs avec la virgule comme séparateur, comme l’illustre le tableau suivant. L’affectation d’un nom à IDENTIFIER doit se conformer aux règles d’attribution de noms de fichiers. IDENTIFIER ne respecte pas la casse.

L’exemple suivant illustre un AssemblyName pour un assembly nommé simplement avec une culture par défaut.

com.microsoft.crypto, Culture=""

L’exemple suivant illustre une référence complète pour un assembly utilisant un nom fort et la culture « en ».

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

Les exemples suivants montrent chacun un AssemblyName partiellement spécifié, qui peut correspondre à un assembly portant un nom fort ou nommé simplement.

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

Les exemples suivants montrent chacun un AssemblyName partiellement spécifié, qui doit correspondre à un assembly nommé simplement.

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

Les exemples suivants montrent chacun un AssemblyName partiellement spécifié, qui doit correspondre à un assembly portant un nom fort.

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

Spécifier des types génériques

SimpleTypeSpec`NUMBER représente un type générique ouvert avec entre 1 et n paramètres de type générique. Par exemple, pour obtenir la référence au type générique ouvert ListeList<T> ou au type générique fermé List<String>, utilisez Type.GetType("System.Collections.Generic.List`1") Pour obtenir une référence au type générique Dictionary<TKey,TValue>, utilisez Type.GetType("System.Collections.Generic.Dictionary`2").

Spécifier des pointeurs

SimpleTypeSpec* représente un pointeur non managé. Par exemple, pour obtenir un pointeur vers le type MyType, utilisez Type.GetType("MyType*"). Pour obtenir un pointeur vers un autre pointeur vers le type MyType, utilisez Type.GetType("MyType**").

Spécifier des références

SimpleTypeSpec & représente un pointeur ou une référence managé. Par exemple, pour obtenir une référence au type MyType, utilisez Type.GetType("MyType &"). Contrairement aux pointeurs, les références sont limitées à un niveau.

Spécifier des tableaux

Dans la syntaxe BNF, ReflectionEmitDimension ne s’applique qu’aux définitions de types incomplètes récupérées à l’aide de ModuleBuilder.GetType. Les définitions de types incomplètes sont des objets TypeBuilder construits à l’aide de System.Reflection.Emit, mais sur lesquels TypeBuilder.CreateType n’a pas été appelé. ReflectionDimension peut être utilisé pour récupérer une définition de type achevée, c’est-à-dire un type qui a été chargé.

Les tableaux sont accessibles dans la réflexion en spécifiant le rang du tableau :

• Type.GetType("MyArray[]") obtient un tableau unidimensionnel dont la limite inférieure est égale à 0.
• Type.GetType("MyArray[*]") obtient un tableau unidimensionnel dont la limite inférieure est inconnue.
• Type.GetType("MyArray[][]") obtient un tableau contenant un tableau à deux dimensions.
• Type.GetType("MyArray[*,*]") etType.GetType("MyArray[,]") obtiennent un tableau rectangulaire à deux dimensions dont les limites inférieures sont inconnues.

Du point de vue du runtime, MyArray[] != MyArray[*], mais pour les tableaux multidimensionnels, les deux notations sont équivalentes. En d’autres termes, Type.GetType("MyArray [,]") == Type.GetType("MyArray[*,*]") prend la valeur true.

Pour ModuleBuilder.GetType, MyArray[0..5] indique un tableau unidimensionnel dont la taille est égale à 6 et la limite inférieure à 0. MyArray[4…] indique un tableau unidimensionnel dont la taille est inconnue et dont la limite inférieure est égale à 4.

Voir aussi

• AssemblyName
• ModuleBuilder
• TypeBuilder
• Type.FullName
• Type.GetType
• Type.AssemblyQualifiedName
• Afficher les informations de type