Partager via

Spécifier des noms de types complets

Vous devez spécifier des noms de type pour avoir une entrée valide pour 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 nom de type sont utilisées par des méthodes telles que Type.GetType, , Module.GetTypeModuleBuilder.GetType, et Assembly.GetType.

Grammaire pour les noms de types

La grammaire définit la syntaxe des langages formels. Le tableau suivant répertorie les règles lexicales qui décrivent comment reconnaître une entrée valide. Les terminaux (ces éléments qui ne sont pas réductibles) sont affichés dans toutes les lettres 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, IDENTIFICATEUR est un nom valide déterminé par les règles d’une langue.

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

Jeton Sens
\, séparateur d'assemblage.
\+ Séparateur de type imbriqué.
\& Type de référence.
\* Type de pointeur.
\[ Délimiteur de dimension du tableau.
\] Délimiteur de dimension du tableau.
\. Utilisez la barre oblique inverse avant un point uniquement si celui-ci est utilisé dans une spécification de tableau. Les points de NamespaceSpec ne sont pas précédés d’une barre oblique inverse.
\\ Barre oblique inverse nécessaire en tant que littéral de chaîne.

Dans tous les composants TypeSpec, à l’exception d’AssemblyNameSpec, les espaces sont pertinents. Dans AssemblyNameSpec, les espaces avant le séparateur « », sont pertinents, mais les espaces après le séparateur « », sont ignorés.

Les classes de réflexion, telles que Type.FullName, renvoient le nom manglé afin que le nom retourné puisse ê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'assemblage

Au minimum, vous devez fournir le nom textuel (IDENTIFIER) de l’assembly comme spécification du nom d’assembly. Vous pouvez suivre l’IDENTIFICATEUR par une liste séparée par des virgules de paires propriété/valeur, comme décrit dans le tableau suivant. L’affectation d’un nom d’identificateur doit respecter les règles d’affectation de noms de fichiers. IDENTIFIER ne respecte pas la casse.

Nom de la propriété Descriptif Valeurs autorisées
Version Numéro de version de l’assembly Major.Minor.Build.Revision, où Major, Minor, Build et Revision sont des entiers compris entre 0 et 65535 inclus.
PublicKey Clé publique complète Valeur de chaîne de la clé publique complète au format hexadécimal. Spécifiez une référence Null (Nothing en Visual Basic) pour indiquer explicitement un assembly privé.
PublicKeyToken Jeton de clé publique (hachage de 8 octets de la clé publique complète) Valeur de chaîne du jeton de clé publique au format hexadécimal. Spécifiez une référence Null (Nothing en Visual Basic) pour indiquer explicitement un assembly privé.
Culture Culture de l'assemblée Culture de l’assembly au format RFC-1766 ou « neutre » pour les assemblys indépendants du langage (non-satellites).
Personnalisée Objet binaire volumineux (BLOB) personnalisé. Cela est actuellement utilisé uniquement dans les assemblys générés par le générateur d’images natives (Ngen). Chaîne personnalisée utilisée par l’outil Générateur d’images natives pour informer le cache d’assembly que l’assembly en cours d’installation est une image native et doit donc être installé dans le cache d’images native. Également appelée chaîne zap.

L’exemple suivant montre un AssemblyName pour un assembly simplement nommé avec la 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 être satisfait par un assembly simplement nommé.

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 de 1 à n paramètres de type générique. Par exemple, pour obtenir une référence au type List<T> générique ouvert ou au type List<String>générique fermé, utilisez Type.GetType("System.Collections.Generic.List`1") Pour obtenir une référence au type Dictionary<TKey,TValue>générique, 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 pour taper 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 managé ou une référence. 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 seul niveau.

Spécifier des tableaux

Dans la grammaire BNF, ReflectionEmitDimension s’applique uniquement aux définitions de type 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 toute définition de type qui a été terminé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 à dimension unique avec une limite inférieure de 0.
  • Type.GetType("MyArray[*]") obtient un tableau à dimension unique avec une limite inférieure inconnue.
  • Type.GetType("MyArray[][]") obtient un tableau contenant un tableau à deux dimensions.
  • Type.GetType("MyArray[*,*]") et Type.GetType("MyArray[,]") obtiennent un tableau rectangulaire à deux dimensions avec des limites inférieures inconnues.

Du point de vue du runtime, MyArray[] != MyArray[*]mais pour les tableaux multidimensionnels, les deux notations sont équivalentes. Cela signifie que Type.GetType("MyArray [,]") == Type.GetType("MyArray[*,*]") évalue à vrai.

Pour ModuleBuilder.GetType, MyArray[0..5] indique un tableau à dimension unique avec la taille 6, limite inférieure 0. MyArray[4…] indique un tableau à dimension unique de taille inconnue et une limite inférieure 4.

Voir aussi