Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Type.GetType méthode (String, Func<AssemblyName, Assembly>, Func<Assembly, String, Boolean, Type>, Boolean, Boolean)

.NET Framework (current version)
 

Date de publication : novembre 2016

Obtient le type portant le nom spécifié, en indiquant s'il faut effectuer une recherche qui respecte la casse et si une exception doit être levée si le type est introuvable, et éventuellement, en fournissant des méthodes personnalisées qui permettent de résoudre l'assembly et le type.

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)

public static Type GetType(
	string typeName,
	Func<AssemblyName, Assembly> assemblyResolver,
	Func<Assembly, string, bool, Type> typeResolver,
	bool throwOnError,
	bool ignoreCase
)

Paramètres

typeName
Type: System.String

Nom du type à obtenir. Si le paramètre typeResolver est fourni, le nom de type peut être n'importe quelle chaîne pouvant être résolue par typeResolver. Si le paramètre assemblyResolver est fourni ou si la résolution de type standard est utilisée, typeName doit être un nom d'assembly complet (consultez AssemblyQualifiedName), à moins que le type ne se trouve dans l'assembly en cours d'exécution ou dans Mscorlib.dll, cas dans lequel il suffit de fournir le nom de type qualifié par son espace de noms.

assemblyResolver
Type: System.Func<AssemblyName, Assembly>

Méthode qui trouve et retourne l'assembly spécifié dans typeName. Le nom de l'assembly est passé à assemblyResolver en tant qu'objet AssemblyName. Si typeName ne contient pas le nom d'un assembly, assemblyResolver n'est pas appelé. Si assemblyResolver n'est pas fourni, une résolution d'assembly standard est effectuée.

Attention   Ne passez pas de méthodes provenant d'appelants inconnus ou non fiables. Vous risqueriez d'élever les privilèges du code malveillant. Utilisez uniquement les méthodes que vous fournissez ou avec lesquelles vous êtes familiarisé.

typeResolver
Type: System.Func<Assembly, String, Boolean, Type>

Méthode qui trouve et retourne le type spécifié par typeName à partir de l'assembly retourné par assemblyResolver ou par la résolution d'assembly standard. Si aucun assembly n'est fourni, la méthode peut en fournir un. La méthode prend également un paramètre qui spécifie s'il faut exécuter une recherche non sensible à la casse ; la valeur de ignoreCase est passée à ce paramètre.

Attention   Ne passez pas de méthodes provenant d'appelants inconnus ou non fiables.

throwOnError
Type: System.Boolean

true pour lever une exception si le type est introuvable ; false pour retourner null. false supprime également d'autres conditions d'exception, mais pas toutes. Consultez la section Exceptions.

ignoreCase
Type: System.Boolean

true pour effectuer une recherche qui ne respecte pas la casse de typeName et false pour effectuer une recherche qui respecte la casse de typeName.

Valeur de retour

Type: System.Type

Type portant le nom spécifié. Si le type est introuvable, le paramètre throwOnError spécifie si null est retourné ou bien une exception est levée. Dans certains cas, une exception est levée indépendamment de la valeur de throwOnError. Consultez la section Exceptions.

Exception Condition
ArgumentNullException

typeName a la valeur null.

TargetInvocationException

Un initialiseur de classe est appelé et lève une exception.

TypeLoadException

throwOnError a la valeur true et le type est introuvable.

ou

throwOnError a la valeur true et typeName contient des caractères non valides, tels qu’une tabulation incorporée.

ou

throwOnError a la valeur true et typeName est une chaîne vide.

ou

throwOnError a la valeur true et typeName représente un type de tableau avec une taille non valide.

ou

typeName représente un tableau de TypedReference.

ArgumentException

Une erreur se produit quand typeName est analysé dans un nom de type et un nom d’assembly (par exemple, quand le nom de type simple inclut un caractère spécial sans séquence d’échappement).

ou

throwOnError a la valeur true et typeName contient une syntaxe non valide (par exemple, « MyType[,*,] »).

ou

typeName représente un type générique qui a un type pointeur, un type ByRef ou Void comme l’un de ses arguments de type.

ou

typeName représente un type générique qui a un nombre incorrect d’arguments de type.

ou

typeName représente un type générique, et un de ses arguments de type ne satisfait pas aux contraintes pour le paramètre de type correspondant.

FileNotFoundException

throwOnError a la valeur true, et l’assembly ou l’une de ses dépendances est introuvable.

FileLoadException

L’assembly ou l’une de ses dépendances a été trouvé, mais n’a pas pu être chargé.

ou

typeName contient un nom d’assembly non valide.

ou

typeName est un nom d’assembly valide sans nom de type.

BadImageFormatException

L’assembly ou une de ses dépendances n’est pas valide.

ou

L’assembly a été compilé avec une version du Common Language Runtime postérieure à la version actuellement chargée.

Utilisez cette surcharge de méthode et ses surcharges associées (GetType(String, Func<AssemblyName, Assembly>, Func<Assembly, String, Boolean, Type>) et GetType(String, Func<AssemblyName, Assembly>, Func<Assembly, String, Boolean, Type>, Boolean)) pour remplacer l’implémentation par défaut de la GetType méthode avec des implémentations plus flexibles. En fournissant vos propres méthodes pour résoudre les noms de type et les noms des assemblys qui contiennent les, vous pouvez procédez comme suit :

  • Contrôler la version d’un assembly d’un type est chargé à partir de.

  • Fournissez un autre emplacement pour rechercher un nom de type qui n’inclut pas un nom d’assembly.

  • Charger des assemblys à l’aide des noms d’assemblys partiels.

  • Retournez les sous-classes de System.Type qui ne sont pas créés par le common language runtime (CLR).

Par exemple, sérialisation avec tolérance de version de cette méthode vous permet de rechercher un assembly « ajustement optimal » à l’aide d’un nom partiel. D’autres surcharges de la GetType méthode requiert un nom de type qualifié d’assembly, qui inclut le numéro de version.

Les implémentations alternatives du système de type devra peut-être retourner des sous-classes de System.Type qui ne sont pas créés par le CLR ; tous les types qui sont retournées par les autres surcharges de la GetType méthode sont des types de runtime.

Cette surcharge de méthode et ses surcharges associées analysent typeName dans le nom d’un type et le nom d’un assembly, puis pour résoudre les noms. Résolution du nom de l’assembly se produit avant la résolution du nom de type, car un nom de type doit être résolu dans le contexte d’un assembly.

System_CAPS_noteRemarque

Si vous n’êtes pas familiarisé avec le concept de noms de type qualifié d’assembly, consultez la AssemblyQualifiedName propriété.

Si typeName n’est pas un nom qualifié d’assembly et résolution de l’assembly est ignorée. Les noms de type non qualifiés peuvent être résolus dans le contexte de Mscorlib.dll ou l’assembly en cours d’exécution, ou vous pouvez éventuellement fournir un assembly dans le typeResolver paramètre. Les effets d’inclure ou d’omettre le nom de l’assembly pour différents types de résolution de noms sont affichés sous la forme d’une table dans le résolution des noms mixtes section.

Remarques d’utilisation générales :

  • Ne passez pas de méthodes à assemblyResolver ou typeResolver si elles proviennent d’appelants inconnus ou non approuvés. Utilisez uniquement les méthodes que vous fournissez ou avec lesquelles vous êtes familiarisé.

    System_CAPS_cautionAttention

    À l’aide de méthodes provenant d’appelants inconnus ou non fiables peut entraîner une élévation de privilèges pour le code malveillant.

  • Si vous omettez le assemblyResolver et/ou typeResolver paramètres, la valeur de le throwOnError paramètre est passé aux méthodes qui effectuent la résolution par défaut.

  • Si throwOnError est true, cette méthode lève un TypeLoadException lorsque typeResolver retourne nullet un FileNotFoundException lorsque assemblyResolver retourne null.

  • Cette méthode n’intercepte pas les exceptions levées par assemblyResolver et typeResolver. Vous êtes responsable de toutes les exceptions levées par les méthodes de résolution.

Le assemblyResolver méthode reçoit un AssemblyName objet, qui est généré en analysant le nom d’assembly de chaîne qui est inclus dans typeName. Si typeName ne contient pas de nom d’assembly, assemblyResolver n’est pas appelée et null est passé à typeResolver.

Si assemblyResolver n’est pas fourni, standard assembly détection permet de localiser l’assembly. Si assemblyResolver est fourni, le GetType méthode n’effectue pas la détection standard ; dans ce cas vous devez vous assurer que votre assemblyResolver peut gérer tous les assemblys que vous passez à celui-ci.

Le assemblyResolver méthode doit retourner null si l’assembly ne peut pas être résolu. Si assemblyResolver retourne null, typeResolver n’est pas appelée et qu’aucun traitement supplémentaire se produit ; en outre, si throwOnError est true, un FileNotFoundException est levée.

Si le AssemblyName qui est passé à assemblyResolver est un partiel nom, un ou plusieurs de ses parties sont null. Par exemple, si elle dispose d’une version sans le Version propriété est null. Si le Version propriété, le CultureInfo propriété et le GetPublicKeyToken tout retour de la méthode null, alors seulement le nom simple de l’assembly a été fourni. Le assemblyResolver méthode peut utiliser ou ignorer toutes les parties du nom de l’assembly.

Les effets des options de résolution d’assembly différents sont affichés sous la forme d’une table dans le résolution des noms mixtes section, pour les noms de types simples et qualifiés d’assembly.

Si typeName ne spécifie pas de nom d’assembly, typeResolver est toujours appelée. Si typeName Spécifie le nom d’assembly, typeResolver est appelée uniquement lorsque le nom de l’assembly est résolu avec succès. Si assemblyResolver ou retourne de détection d’assembly standard null, typeResolver n’est pas appelée.

Le typeResolver méthode reçoit les trois arguments :

  • L’assembly à rechercher ou null si typeName ne contient pas un nom d’assembly.

  • Nom du type simple. Dans le cas d’un type imbriqué, il s’agit du type conteneur extérieur. Dans le cas d’un type générique, il s’agit du nom simple du type générique.

  • Valeur booléenne qui est true si la casse des noms de type doit être ignoré.

L’implémentation de détermine la manière dont ces arguments sont utilisées. Le typeResolver méthode doit retourner null si elle ne peut pas résoudre le type. Si typeResolver retourne null et throwOnError est true, cette surcharge de GetType lève une TypeLoadException.

Les effets des options de résolution de type différent sont affichés sous la forme d’une table dans le résolution des noms mixtes section, pour les noms de types simples et qualifiés d’assembly.

Si typeName est un type imbriqué, seul le nom de l’extérieur qui contient le type est passé à typeResolver. Lorsque typeResolver retourne ce type, le GetNestedType méthode est appelée de manière récursive jusqu'à ce que le plus profond type imbriqué a été résolu.

Le GetType est appelée de manière récursive pour résoudre les types génériques : pour résoudre le type générique lui-même, puis pour résoudre ses arguments de type. Si un argument de type est générique, GetType est appelée de manière récursive pour résoudre ses arguments de type et ainsi de suite.

La combinaison de assemblyResolver et typeResolver que vous fournissez doit être capable de résoudre tous les niveaux de cette récursivité. Par exemple, supposez que vous fournissez un assemblyResolver qui contrôle le chargement de MyAssembly. Supposons que vous souhaitez résoudre le type générique Dictionary<string, MyType> (Dictionary(Of String, MyType) en Visual Basic). Vous pouvez passer le nom de type générique suivant :

"System.Collections.Generic.Dictionary`2[System.String,[MyNamespace.MyType, MyAssembly]]"

Notez que MyType est l’argument de type qualifié d’assembly uniquement. Les noms de la Dictionary<TKey, TValue> et String classes ne sont pas qualifiés d’assembly. Votre typeResolver doit être en mesure de gérer un assembly ou null, car il recevra null pour Dictionary<TKey, TValue> et String. Il peut gérer ce cas en appelant une surcharge de la GetType méthode qui prend une chaîne, car les deux noms de type non qualifiés sont dans Mscorlib.dll :

Type t = Type.GetType(test,
                      (aName) => aName.Name == "MyAssembly" ? 
                          Assembly.LoadFrom(@".\MyPath\v5.0\MyAssembly.dll") : null,
                      (assem, name, ignore) => assem == null ? 
                          Type.GetType(name, false, ignore) : 
                              assem.GetType(name, false, ignore)
                     ); 

Le assemblyResolver méthode n’est pas appelée pour le type de dictionnaire et le type de chaîne, car ces noms de types ne sont pas qualifiés d’assembly.

Supposons maintenant qu’au lieu de System.String, le premier type d’argument générique est YourType, à partir de YourAssembly:

"System.Collections.Generic.Dictionary`2[[YourNamespace.YourType, YourAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null], [MyNamespace.MyType, MyAssembly]]"

Étant donné que cet assembly n’est ni Mscorlib.dll, ni l’assembly en cours d’exécution, vous ne peut pas résoudre YourType sans un nom qualifié d’assembly. Étant donné que votre assemblyResolve sera appelé de manière récursive, il doit être en mesure de gérer ce cas. Au lieu de retourner null pour les assemblys autres que MyAssembly, elle s’exécute maintenant le chargement d’un assembly à l’aide de l’élément AssemblyName objet.

Type t2 = Type.GetType(test,
                       (aName) => aName.Name == "MyAssembly" ? 
                           Assembly.LoadFrom(@".\MyPath\v5.0\MyAssembly.dll") : 
                           Assembly.Load(aName),
                       (assem, name, ignore) => assem == null ? 
                           Type.GetType(name, false, ignore) : 
                               assem.GetType(name, false, ignore), true
                      ); 

Retour au Notes d’utilisation.

Certains caractères ont une signification particulière dans les noms qualifiés d’assembly. Si un nom de type simple contient ces caractères, les caractères provoquent des erreurs d’analyse lorsque le nom simple fait partie d’un nom qualifié d’assembly. Pour éviter les erreurs d’analyse, vous devez isoler les caractères spéciaux par une barre oblique inverse avant de pouvoir passer le nom qualifié d’assembly pour le GetType (méthode). Par exemple, si un type est nommé Strange]Type, le caractère d’échappement doit être ajouté avant les crochets comme suit : Strange\]Type.

System_CAPS_noteRemarque

Les noms de ces caractères spéciaux ne peut pas être créés en Visual Basic ou c#, mais peuvent être créés à l’aide du langage intermédiaire Microsoft (MSIL) ou par l’émission d’assemblys dynamiques.

Le tableau suivant présente les caractères spéciaux pour les noms de type.

Caractère

Signification

, (virgule)

Délimiteur pour les noms qualifiés d’assembly.

[] (crochets)

En tant que suffixe paire, indique un type de tableau ; comme une paire de séparateurs, englobe les listes d’arguments génériques et les noms qualifiés d’assembly.

& (et commercial)

En guise de suffixe, indique qu’un type est un type référence.

* (astérisque)

En guise de suffixe, indique qu’un type est un type pointeur.

+ (plus)

Délimiteur pour les types imbriqués.

\ (barre oblique inverse)

Caractère d’échappement.

Propriétés, telles que AssemblyQualifiedName retour correctement d’échappement de chaînes. Vous devez passer des chaînes correctement échappées à le GetType (méthode). À son tour, le GetType méthode passe les noms correctement échappées à typeResolver et aux méthodes de résolution de type par défaut. Si vous devez comparer un nom à un nom sans séquence d’échappement dans typeResolver, vous devez supprimer les caractères d’échappement.

Retour au Notes d’utilisation.

Le tableau suivant récapitule les interactions entre assemblyResolver, typeResolveret la résolution de noms par défaut, pour toutes les combinaisons de nom de type et le nom de l’assembly dans typeName:

Contenu du nom de type

Méthode de programme de résolution d’assembly

Méthode de programme de résolution de type

Résultat

type, l’assembly

null

null

Équivalent à l’appel du Type.GetType(String, Boolean, Boolean) surcharge de méthode.

type, l’assembly

fourni

null

assemblyResolverRetourne l’assembly ou null si elle ne peut pas résoudre l’assembly. Si l’assembly est résolu, le Assembly.GetType(String, Boolean, Boolean) surcharge de méthode est utilisée pour charger le type à partir de l’assembly ; sinon, il n’existe aucune tentative de résoudre le type.

type, l’assembly

null

fourni

Équivalent à la conversion du nom de l’assembly à un AssemblyName objet et en appelant le Assembly.Load(AssemblyName) surcharge de méthode pour obtenir l’assembly. Si l’assembly est résolu, il est passé à typeResolver; sinon, typeResolver n’est pas appelée et il n’existe aucune autre tentative de résoudre le type.

type, l’assembly

fourni

fourni

assemblyResolverRetourne l’assembly ou null si elle ne peut pas résoudre l’assembly. Si l’assembly est résolu, il est passé à typeResolver; sinon, typeResolver n’est pas appelée et il n’existe aucune autre tentative de résoudre le type.

type

NULL, fourni

null

Équivalent à l’appel du Type.GetType(String, Boolean, Boolean) surcharge de méthode. Étant donné que le nom de l’assembly n’est pas fourni, Mscorlib.dll et l’assembly en cours d’exécution sont recherchés. Si assemblyResolver est fourni, il est ignoré.

type

NULL, fourni

fourni

typeResolverest appelée, et null est passé pour l’assembly. typeResolverpeut de fournir un type à partir de n’importe quel assembly, y compris les assemblys qu’il charge à cet effet. Si assemblyResolver est fourni, il est ignoré.

assembly

NULL, fourni

NULL, fourni

A FileLoadException est levée, car le nom de l’assembly est analysé comme s’il s’agissait d’un nom de type qualifié d’assembly. Cela entraîne un nom d’assembly non valide.

À : Notes d’utilisation, résolution d’assemblys, résoudre les Types.

.NET Framework
Disponible depuis 4.0
Retour au début
Afficher: