Type.GetType Méthode

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Obtient un objet Type qui représente le type spécifié.

Surcharges

GetType()	Obtient le Type actuel.
GetType(String)	Obtient le Type avec le nom spécifié, effectuant une recherche qui respecte la casse.
GetType(String, Boolean)	Obtient le Type portant le nom spécifié, en effectuant une recherche respectant la casse et en spécifiant s'il faut lever une exception si le type est introuvable.
GetType(String, Boolean, Boolean)	Obtient le Type portant le nom spécifié, indiquant s'il faut lever une exception si le type est introuvable et s'il faut effectuer une recherche respectant la casse.
GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>)	Obtient le type avec le nom spécifié et éventuellement des méthodes personnalisées permettant de résoudre l'assembly et le type.
GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean)	Obtient le type portant le nom spécifié, en indiquant s'il faut lever une exception si le type est introuvable et, éventuellement, en fournissant des méthodes personnalisées qui permettent de résoudre l'assembly et le type.
GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean)	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.

GetType()

Obtient le Type actuel.

public:
 Type ^ GetType();

public:
 virtual Type ^ GetType();

public Type GetType ();

override this.GetType : unit -> Type

Public Function GetType () As Type

Retours

Type

Type actuel.

Implémente

GetType()

Exceptions

TargetInvocationException

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

Voir aussi

S’applique à

GetType(String)

Obtient le Type avec le nom spécifié, effectuant une recherche qui respecte la casse.

public:
 static Type ^ GetType(System::String ^ typeName);

public static Type GetType (string typeName);

public static Type? GetType (string typeName);

static member GetType : string -> Type

Public Shared Function GetType (typeName As String) As Type

Paramètres

typeName: String

Nom qualifié d'assembly du type à obtenir. Consultez AssemblyQualifiedName. Si le type se trouve dans l’assembly en cours d’exécution ou dans mscorlib.dll/System.Private.CoreLib.dll, il suffit de fournir le nom du type qualifié par son espace de noms.

Retours

Type

Type présentant le nom spécifié, s'il est trouvé ; sinon, null.

Exceptions

ArgumentNullException

typeName a la valeur null.

TargetInvocationException

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

ArgumentException

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.

TypeLoadException

typeName représente un tableau de TypedReference.

FileLoadException

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

Remarque : dans .NET pour les applications Windows Store ou la bibliothèque de classes portables, interceptez l’exception de classe de base, IOExceptionà la place.

BadImageFormatException

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

ou -

La version 2.0 ou ultérieure du Common Language Runtime est actuellement chargée, et l’assembly a été compilé avec une version ultérieure.

Exemples

L’exemple suivant récupère le type d’objet de System.Int32 type et utilise cet objet de type pour afficher la FullName propriété de System.Int32.

using namespace System;

int main()
{
   try {
      // Get the type of a specified class.
      Type^ myType1 = Type::GetType( "System.Int32" );
      Console::WriteLine( "The full name is {0}.\n", myType1->FullName );
   }
   catch ( TypeLoadException^ e ) {
       Console::WriteLine("{0}: Unable to load type System.Int32",
                          e->GetType()->Name);
   }

   try {
      // Since NoneSuch does not exist in this assembly, GetType throws a TypeLoadException.
      Type^ myType2 = Type::GetType( "NoneSuch", true );
      Console::WriteLine( "The full name is {0}.", myType2->FullName );
   }
   catch ( TypeLoadException^ e ) {
       Console::WriteLine("{0}: Unable to load type NoneSuch",
                          e->GetType()->Name);
   }

}
// The example displays the following output:
//       The full name is System.Int32.
//
//       TypeLoadException: Unable to load type NoneSuch

using System;

class Example
{
     public static void Main()
     {
         try {
             // Get the type of a specified class.
             Type myType1 = Type.GetType("System.Int32");
             Console.WriteLine("The full name is {0}.\n", myType1.FullName);
         }
         catch (TypeLoadException e)
         {
            Console.WriteLine("{0}: Unable to load type System.Int32", e.GetType().Name);
         }

         try {
             // Since NoneSuch does not exist in this assembly, GetType throws a TypeLoadException.
             Type myType2 = Type.GetType("NoneSuch", true);
             Console.WriteLine("The full name is {0}.", myType2.FullName);
         }
         catch(TypeLoadException e) {
            Console.WriteLine("{0}: Unable to load type NoneSuch", e.GetType().Name);
         }
     }
}
// The example displays the following output:
//       The full name is System.Int32.
//
//       TypeLoadException: Unable to load type NoneSuch

open System

try
    // Get the type of a specified class.
    let myType1 = Type.GetType "System.Int32"
    printfn $"The full name is {myType1.FullName}.\n"
with :? TypeLoadException as e ->
    printfn $"{e.GetType().Name}: Unable to load type System.Int32"

try
    // Since NoneSuch does not exist in this assembly, GetType throws a TypeLoadException.
    let myType2 = Type.GetType("NoneSuch", true)
    printfn $"The full name is {myType2.FullName}."
with :? TypeLoadException as e ->
    printfn $"{e.GetType().Name}: Unable to load type NoneSuch"
// The example displays the following output:
//       The full name is System.Int32.
//
//       TypeLoadException: Unable to load type NoneSuch

Class Example
     Public Shared Sub Main()
         Try
             ' Get the type of the specified class.
             Dim myType1 As Type = Type.GetType("System.Int32")
             Console.WriteLine("The full name is {0}.", myType1.FullName)
         Catch e As TypeLoadException
             Console.WriteLine("{0}: Unable to load type System.Int32",
                               e.GetType().Name)
         End Try

         Console.WriteLine()

         Try
             ' Since NoneSuch does not exist in this assembly, GetType throws a TypeLoadException.
             Dim myType2 As Type = Type.GetType("NoneSuch", True)
             Console.WriteLine("The full name is {0}.", myType2.FullName)
         Catch e As TypeLoadException
             Console.WriteLine("{0}: Unable to load type NoneSuch", e.GetType().Name)
         End Try
     End Sub
End Class
' The example displays the following output:
'       The full name is System.Int32.
'
'       TypeLoadException: Unable to load type NoneSuch

Remarques

Vous pouvez utiliser la GetType méthode pour obtenir un Type objet pour un type dans un autre assembly si vous connaissez son nom qualifié d’assembly, qui peut être obtenu à partir de AssemblyQualifiedName. GetType entraîne le chargement de l’assembly spécifié dans typeName. Vous pouvez également charger un assembly à l’aide de la Assembly.Load méthode, puis utiliser la ou Assembly.GetTypes la Assembly.GetType méthode pour obtenir Type des objets. Si un type se trouve dans un assembly connu de votre programme au moment de la compilation, il est plus efficace d’utiliser typeof en C# ou l’opérateur GetType dans Visual Basic.

Notes

S’il typeName est introuvable, l’appel à la GetType(String) méthode retourne null. Elle ne lève pas d’exception. Pour contrôler si une exception est levée, appelez une surcharge de la GetType méthode qui a un throwOnError paramètre.

GetType fonctionne uniquement sur les assemblys chargés à partir du disque. Si vous appelez GetType pour rechercher un type défini dans un assembly dynamique défini à l’aide des System.Reflection.Emit services, vous risquez d’obtenir un comportement incohérent. Le comportement varie selon que l’assembly dynamique est persistant, c’est-à-dire créé à l’aide des RunAndSave modes d’accès ou Save de l’énumération System.Reflection.Emit.AssemblyBuilderAccess . Si l’assembly dynamique est persistant et a été écrit sur le disque avant GetType d’être appelé, le chargeur recherche l’assembly enregistré sur le disque, charge cet assembly et récupère le type de cet assembly. Si l’assembly n’a pas été enregistré sur le disque quand il GetType est appelé, la méthode retourne null. GetType ne comprend pas les assemblys dynamiques temporaires ; par conséquent, l’appel GetType pour récupérer un type dans un assembly dynamique temporaire retourne null.

Pour utiliser GetType un module dynamique, abonnez-vous à l’événement et appelez-le GetType avant d’enregistrerAppDomain.AssemblyResolve. Sinon, vous obtiendrez deux copies de l’assembly en mémoire.

Le tableau suivant montre quels membres d’une classe de base sont retournés par les Get méthodes lors de la réflexion sur un type.

Type de membre	statique	Non statique
Constructeur	Non	Non
Champ	Non	Oui. Un champ est toujours masqué par nom et signature.
Événement	Non applicable	La règle système de type commun est que l’héritage est identique à celui des méthodes qui implémentent la propriété. La réflexion traite les propriétés comme masquage par nom et signature. Voir la note 2 ci-dessous.
Méthode	Non	Oui. Une méthode (virtuelle et non virtuelle) peut être masquée par nom ou masquer par nom et signature.
Type imbriqué	Non	Non
Propriété	Non applicable	La règle système de type commun est que l’héritage est identique à celui des méthodes qui implémentent la propriété. La réflexion traite les propriétés comme masquage par nom et signature. Voir la note 2 ci-dessous.

Hide-by-name-and-signature prend en compte toutes les parties de la signature, y compris les modificateurs personnalisés, les types de retour, les types de paramètres, les sentinelles et les conventions d’appel non managées. Il s’agit d’une comparaison binaire.
Pour la réflexion, les propriétés et les événements sont masqués par nom et signature. Si vous avez une propriété avec un accesseur get et un accesseur set dans la classe de base, mais que la classe dérivée n’a qu’un accesseur get, la propriété de classe dérivée masque la propriété de classe de base et vous ne pourrez pas accéder au setter sur la classe de base.
Les attributs personnalisés ne font pas partie du système de type commun.

Les tableaux ou types COM ne sont pas recherchés, sauf s’ils ont déjà été chargés dans la table des classes disponibles.

typeName peut être le nom de type qualifié par son espace de noms ou un nom qualifié d’assembly qui inclut une spécification de nom d’assembly. Consultez AssemblyQualifiedName.

Si typeName elle inclut l’espace de noms, mais pas le nom de l’assembly, cette méthode recherche uniquement l’assembly de l’objet appelant et mscorlib.dll/System.Private.CoreLib.dll, dans cet ordre. Si typeName est complet avec le nom d’assembly partiel ou complet, cette méthode recherche dans l’assembly spécifié. Si l’assembly a un nom fort, un nom d’assembly complet est requis.

La AssemblyQualifiedName propriété retourne un nom de type complet, y compris les types imbriqués, le nom de l’assembly et les arguments de type générique. Tous les compilateurs qui prennent en charge le Common Language Runtime émettent le nom simple d’une classe imbriquée, et la réflexion construit un nom de bascule lorsqu’ils sont interrogés, conformément aux conventions suivantes.

Notes

Dans la .NET Framework version 2.0, l’architecture du processeur est ajoutée à l’identité d’assembly et peut être spécifiée dans le cadre des chaînes de nom d’assembly. Par exemple, « ProcessorArchitecture=msil ». Toutefois, elle n’est pas incluse dans la chaîne retournée par la AssemblyQualifiedName propriété, pour des raisons de compatibilité. Vous pouvez également charger des types en créant un AssemblyName objet et en le transmettant à une surcharge appropriée de la Load méthode. Vous pouvez ensuite utiliser la Assembly.GetType méthode pour charger des types à partir de l’assembly. Voir aussi AssemblyName.ProcessorArchitecture.

Délimiteur	Signification
Barre oblique inverse (\)	Caractère d’échappement.
Backtick (')	Précède un ou plusieurs chiffres représentant le nombre de paramètres de type, situés à la fin du nom d’un type générique.
Crochets ([])	Placez une liste d’arguments de type générique pour un type générique construit ; dans une liste d’arguments de type, placez un type qualifié d’assembly.
Virgule (,)	Précède le nom de l’assembly.
Période (.)	Désigne les identificateurs d’espace de noms.
Signe plus (+)	Précède une classe imbriquée.

Par exemple, le nom complet d’une classe peut ressembler à ceci :

TopNamespace.SubNameSpace.ContainingClass+NestedClass,MyAssembly

Si l’espace de noms était TopNamespace.Sub+Namespace, la chaîne doit précéder le signe plus (+) avec un caractère d’échappement (\) pour l’empêcher d’être interprétée comme un séparateur d’imbrication. La réflexion émet cette chaîne comme suit :

TopNamespace.Sub\+Namespace.ContainingClass+NestedClass,MyAssembly

Un « ++ » devient «\+\ + », et un «\ » devient «\\ ».

Ce nom qualifié peut être conservé et utilisé ultérieurement pour charger le Type. Pour rechercher et charger un Type, utilisez GetType le nom du type uniquement ou avec le nom de type qualifié d’assembly. GetType avec le nom de type uniquement recherche l’assembly Type de l’appelant, puis dans l’assembly système. GetType avec le nom de type qualifié d’assembly recherche le Type contenu dans n’importe quel assembly.

Les noms de types peuvent inclure des caractères de fin qui indiquent des informations supplémentaires sur le type, telles que si le type est un type référence, un type pointeur ou un type de tableau. Pour récupérer le nom de type sans ces caractères de fin, utilisez t.GetElementType().ToString(), où t est le type.

Les espaces sont pertinents dans tous les composants de nom de type, à l’exception du nom de l’assembly. Dans le nom de l’assembly, les espaces avant le séparateur « , » sont pertinents, mais les espaces après le séparateur « », sont ignorés.

Le nom d’un type générique se termine par un backtick (`) suivi de chiffres représentant le nombre d’arguments de type générique. L’objectif de ce mangling de nom est de permettre aux compilateurs de prendre en charge les types génériques portant le même nom, mais avec différents nombres de paramètres de type, qui se produisent dans la même étendue. Par exemple, la réflexion retourne les noms Tuple`1 bascules et Tuple`2 à partir des méthodes Tuple(Of T) génériques et Tuple(Of T0, T1) dans Visual Basic, ou Tuple<T> Tuple<T0, T1> dans Visual C#.

Pour les types génériques, la liste d’arguments de type est placée entre crochets et les arguments de type sont séparés par des virgules. Par exemple, un générique Dictionary<TKey,TValue> a deux paramètres de type. Un Dictionary<TKey,TValue> des MyType clés de type String peut être représenté comme suit :

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

Pour spécifier un type qualifié d’assembly dans une liste d’arguments de type, placez le type qualifié d’assembly entre crochets. Sinon, les virgules qui séparent les parties du nom qualifié d’assembly sont interprétées comme limitant les arguments de type supplémentaires. Par exemple, un Dictionary<TKey,TValue> fromMyAssembly.dll MyType , avec des clés de type String, peut être spécifié comme suit :

Type.GetType("System.Collections.Generic.Dictionary`2[System.String,[MyType,MyAssembly]]")

Notes

Un type qualifié d’assembly peut être placé entre crochets uniquement lorsqu’il apparaît dans une liste de paramètres de type. Les règles de recherche d’assemblys pour les types qualifiés et non qualifiés dans les listes de paramètres de type sont identiques aux règles pour les types non génériques qualifiés et non qualifiés.

Les types Nullables sont un cas spécial de types génériques. Par exemple, une valeur Nullable Int32 est représentée par la chaîne « System.Nullable'1[System.Int32] ».

Notes

En C#, C++ et Visual Basic vous pouvez également obtenir des types nullables à l’aide d’opérateurs de type. Par exemple, le type nullable Boolean est retourné par typeof(Nullable<bool>) C#, en Nullable<Boolean>::typeid C++, et par GetType(Nullable(Of Boolean)) Visual Basic.

Le tableau suivant montre la syntaxe que GetType vous utilisez pour différents types.

Pour obtenir	Utiliser
Nullable Int32	Type.GetType("System.Nullable`1[System.Int32]")
Pointeur non managé vers `MyType`	`Type.GetType("MyType*")`
Pointeur non managé vers un pointeur vers `MyType`	`Type.GetType("MyType**")`
Pointeur managé ou référence à `MyType`	`Type.GetType("MyType&")`. Notez que contrairement aux pointeurs, les références sont limitées à un niveau.
Classe parente et classe imbriquée	`Type.GetType("MyParentClass+MyNestedClass")`
Tableau unidimensionnel avec une limite inférieure de 0	`Type.GetType("MyType[]")`
Tableau unidimensionnel avec une limite inférieure inconnue	`Type.GetType("MyType[*]")`
Tableau ndimensionnel	Virgule (,) entre crochets un total de n-1 fois. Par exemple, `System.Object[,,]` représente un tableau tridimensionnel `Object` .
Tableau de tableaux unidimensionnels	`Type.GetType("MyType[][]")`
Tableau rectangulaire à deux dimensions avec des limites inférieures inconnues	`Type.GetType("MyType[,]")`
Type générique avec un argument de type	Type.GetType("MyGenericType`1[MyType]")
Type générique avec deux arguments de type	Type.GetType("MyGenericType`2[MyType,AnotherType]")
Type générique avec deux arguments de type qualifiés d’assembly	Type.GetType("MyGenericType`2[[MyType,MyAssembly],[AnotherType,AnotherAssembly]]")
Type générique qualifié d’assembly avec un argument de type qualifié d’assembly	Type.GetType("MyGenericType`1[[MyType,MyAssembly]],MyGenericTypeAssembly")
Type générique dont l’argument de type est un type générique avec deux arguments de type	Type.GetType("MyGenericType`1[AnotherGenericType`2[MyType,AnotherType]]")

Voir aussi

S’applique à

GetType(String, Boolean)

Obtient le Type portant le nom spécifié, en effectuant une recherche respectant la casse et en spécifiant s'il faut lever une exception si le type est introuvable.

public:
 static Type ^ GetType(System::String ^ typeName, bool throwOnError);

public static Type GetType (string typeName, bool throwOnError);

public static Type? GetType (string typeName, bool throwOnError);

static member GetType : string * bool -> Type

Public Shared Function GetType (typeName As String, throwOnError As Boolean) As Type

Paramètres

typeName: String

throwOnError: 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.

Retours

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.

Exceptions

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

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 une de ses dépendances a été trouvé, mais n’a pas pu être chargé.

Remarque : Dans .NET pour les applications Windows Store ou la bibliothèque de classes portables, interceptez l’exception de classe de base, IOExceptionà la place.

BadImageFormatException

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

ou -

La version 2.0 ou ultérieure du Common Language Runtime est actuellement chargée, et l’assembly a été compilé avec une version ultérieure.

Exemples

L’exemple suivant récupère le type d’objet System.Int32 de type et utilise cet objet de type pour afficher la FullName propriété de System.Int32. Si un objet de type fait référence à un assembly qui n’existe pas, cet exemple lève une exception.

using namespace System;

int main()
{
   try {
      // Get the type of a specified class.
      Type^ myType1 = Type::GetType( "System.Int32" );
      Console::WriteLine( "The full name is {0}.\n", myType1->FullName );
   }
   catch ( TypeLoadException^ e ) {
       Console::WriteLine("{0}: Unable to load type System.Int32",
                          e->GetType()->Name);
   }

   try {
      // Since NoneSuch does not exist in this assembly, GetType throws a TypeLoadException.
      Type^ myType2 = Type::GetType( "NoneSuch", true );
      Console::WriteLine( "The full name is {0}.", myType2->FullName );
   }
   catch ( TypeLoadException^ e ) {
       Console::WriteLine("{0}: Unable to load type NoneSuch",
                          e->GetType()->Name);
   }

}
// The example displays the following output:
//       The full name is System.Int32.
//
//       TypeLoadException: Unable to load type NoneSuch

using System;

class Example
{
     public static void Main()
     {
         try {
             // Get the type of a specified class.
             Type myType1 = Type.GetType("System.Int32");
             Console.WriteLine("The full name is {0}.\n", myType1.FullName);
         }
         catch (TypeLoadException e)
         {
            Console.WriteLine("{0}: Unable to load type System.Int32", e.GetType().Name);
         }

         try {
             // Since NoneSuch does not exist in this assembly, GetType throws a TypeLoadException.
             Type myType2 = Type.GetType("NoneSuch", true);
             Console.WriteLine("The full name is {0}.", myType2.FullName);
         }
         catch(TypeLoadException e) {
            Console.WriteLine("{0}: Unable to load type NoneSuch", e.GetType().Name);
         }
     }
}
// The example displays the following output:
//       The full name is System.Int32.
//
//       TypeLoadException: Unable to load type NoneSuch

open System

try
    // Get the type of a specified class.
    let myType1 = Type.GetType "System.Int32"
    printfn $"The full name is {myType1.FullName}.\n"
with :? TypeLoadException as e ->
    printfn $"{e.GetType().Name}: Unable to load type System.Int32"

try
    // Since NoneSuch does not exist in this assembly, GetType throws a TypeLoadException.
    let myType2 = Type.GetType("NoneSuch", true)
    printfn $"The full name is {myType2.FullName}."
with :? TypeLoadException as e ->
    printfn $"{e.GetType().Name}: Unable to load type NoneSuch"
// The example displays the following output:
//       The full name is System.Int32.
//
//       TypeLoadException: Unable to load type NoneSuch

Class Example
     Public Shared Sub Main()
         Try
             ' Get the type of the specified class.
             Dim myType1 As Type = Type.GetType("System.Int32")
             Console.WriteLine("The full name is {0}.", myType1.FullName)
         Catch e As TypeLoadException
             Console.WriteLine("{0}: Unable to load type System.Int32",
                               e.GetType().Name)
         End Try

         Console.WriteLine()

         Try
             ' Since NoneSuch does not exist in this assembly, GetType throws a TypeLoadException.
             Dim myType2 As Type = Type.GetType("NoneSuch", True)
             Console.WriteLine("The full name is {0}.", myType2.FullName)
         Catch e As TypeLoadException
             Console.WriteLine("{0}: Unable to load type NoneSuch", e.GetType().Name)
         End Try
     End Sub
End Class
' The example displays the following output:
'       The full name is System.Int32.
'
'       TypeLoadException: Unable to load type NoneSuch

Remarques

GetType fonctionne uniquement sur les assemblys chargés à partir du disque. Si vous appelez GetType pour rechercher un type défini dans un assembly dynamique défini à l’aide des System.Reflection.Emit services, vous risquez d’obtenir un comportement incohérent. Le comportement varie selon que l’assembly dynamique est persistant, c’est-à-dire créé à l’aide des RunAndSave modes d’accès ou Save de l’énumération System.Reflection.Emit.AssemblyBuilderAccess . Si l’assembly dynamique est persistant et a été écrit sur le disque avant GetType d’être appelé, le chargeur recherche l’assembly enregistré sur le disque, charge cet assembly et récupère le type de cet assembly. Si l’assembly n’a pas été enregistré sur le disque quand il GetType est appelé, la méthode retourne null. GetType ne comprend pas les assemblys dynamiques temporaires ; par conséquent, l’appel GetType pour récupérer un type dans un assembly dynamique temporaire retourne null.

Le throwOnError paramètre spécifie ce qui se passe lorsque le type est introuvable et supprime également certaines autres conditions d’exception, comme décrit dans la section Exceptions. Certaines exceptions sont levées indépendamment de la valeur de throwOnError. Par exemple, si le type est trouvé mais ne peut pas être chargé, un TypeLoadException est levée même si throwOnError c’est le cas false.

Le tableau suivant montre quels membres d’une classe de base sont retournés par les Get méthodes lors de la réflexion sur un type.

Type de membre	statique	Non statique
Constructeur	Non	Non
Champ	Non	Oui. Un champ est toujours masqué par nom et signature.
Événement	Non applicable	La règle système de type commun est que l’héritage est identique à celui des méthodes qui implémentent la propriété. La réflexion traite les propriétés comme masquage par nom et signature. Voir la note 2 ci-dessous.
Méthode	Non	Oui. Une méthode (virtuelle et non virtuelle) peut être masquée par nom ou masquer par nom et signature.
Type imbriqué	Non	Non
Propriété	Non applicable	La règle système de type commun est que l’héritage est identique à celui des méthodes qui implémentent la propriété. La réflexion traite les propriétés comme masquage par nom et signature. Voir la note 2 ci-dessous.

Hide-by-name-and-signature prend en compte toutes les parties de la signature, y compris les modificateurs personnalisés, les types de retour, les types de paramètres, les sentinelles et les conventions d’appel non managées. Il s’agit d’une comparaison binaire.
Pour la réflexion, les propriétés et les événements sont masqués par nom et signature. Si vous avez une propriété avec un accesseur get et un accesseur set dans la classe de base, mais que la classe dérivée n’a qu’un accesseur get, la propriété de classe dérivée masque la propriété de classe de base et vous ne pourrez pas accéder au setter sur la classe de base.
Les attributs personnalisés ne font pas partie du système de type commun.

Les tableaux ou types COM ne sont pas recherchés, sauf s’ils ont déjà été chargés dans la table des classes disponibles.

typeName peut être le nom de type qualifié par son espace de noms ou un nom qualifié d’assembly qui inclut une spécification de nom d’assembly. Consultez AssemblyQualifiedName.

La AssemblyQualifiedName propriété retourne un nom de type complet, y compris les types imbriqués, le nom de l’assembly et les arguments génériques. Tous les compilateurs qui prennent en charge le Common Language Runtime émettent le nom simple d’une classe imbriquée, et la réflexion construit un nom de bascule lorsqu’ils sont interrogés, conformément aux conventions suivantes.

Notes

Délimiteur	Signification
Barre oblique inverse (\)	Caractère d’échappement.
Backtick (')	Précède un ou plusieurs chiffres représentant le nombre de paramètres de type, situés à la fin du nom d’un type générique.
Crochets ([])	Placez une liste d’arguments de type générique pour un type générique construit ; dans une liste d’arguments de type, placez un type qualifié d’assembly.
Virgule (,)	Précède le nom de l’assembly.
Période (.)	Désigne les identificateurs d’espace de noms.
Signe plus (+)	Précède une classe imbriquée.

Par exemple, le nom complet d’une classe peut ressembler à ceci :

TopNamespace.SubNameSpace.ContainingClass+NestedClass,MyAssembly

TopNamespace.Sub\+Namespace.ContainingClass+NestedClass,MyAssembly

Un « ++ » devient «\+\ + », et un «\ » devient «\\ ».

Ce nom qualifié peut être conservé et utilisé ultérieurement pour charger le Type. Pour rechercher et charger un Type, utilisez GetType uniquement le nom de type ou le nom de type qualifié d’assembly. GetType avec le nom de type uniquement recherche l’assembly Type de l’appelant, puis dans l’assembly système. GetType avec le nom de type qualifié d’assembly recherche le Type dans n’importe quel assembly.

Les noms de type peuvent inclure des caractères de fin qui indiquent des informations supplémentaires sur le type, comme si le type est un type de référence, un type de pointeur ou un type de tableau. Pour récupérer le nom de type sans ces caractères de fin, utilisez t.GetElementType().ToString(), où t est le type.

Les espaces sont pertinents dans tous les composants de nom de type, sauf le nom de l’assembly. Dans le nom de l’assembly, les espaces avant le séparateur « », sont pertinents, mais les espaces après le séparateur « », sont ignorés.

Le nom d’un type générique se termine par un backtick (`) suivi de chiffres représentant le nombre d’arguments de type générique. L’objectif de ce nom est d’autoriser les compilateurs à prendre en charge les types génériques portant le même nom, mais avec différents nombres de paramètres de type, se produisant dans la même étendue. Par exemple, la réflexion retourne les noms Tuple`1 bascules et à partir des méthodes Tuple(Of T) génériques et Tuple`2 Tuple(Of T0, T1) dans Visual Basic, ou dans Tuple<T> Tuple<T0, T1> Visual C#.

Pour les types génériques, la liste d’arguments de type est placée entre crochets et les arguments de type sont séparés par des virgules. Par exemple, un générique Dictionary<TKey,TValue> a deux paramètres de type. Une Dictionary<TKey,TValue> des MyType clés de type String peut être représentée comme suit :

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

Pour spécifier un type qualifié d’assembly dans une liste d’arguments de type, placez le type qualifié d’assembly entre crochets. Sinon, les virgules qui séparent les parties du nom qualifié d’assembly sont interprétées comme limitant les arguments de type supplémentaires. Par exemple, une Dictionary<TKey,TValue> de MyType MyAssembly.dll, avec des clés de type String, peut être spécifiée comme suit :

Type.GetType("System.Collections.Generic.Dictionary`2[System.String,[MyType,MyAssembly]]")

Notes

Les types nullables sont un cas spécial de types génériques. Par exemple, une valeur Nullable Int32 est représentée par la chaîne « System.Nullable'1[System.Int32] ».

Notes

En C#, C++et Visual Basic vous pouvez également obtenir des types nullables à l’aide d’opérateurs de type. Par exemple, le type nullable Boolean est retourné par typeof(Nullable<bool>) C#, par Nullable<Boolean>::typeid C++, et par GetType(Nullable(Of Boolean)) Visual Basic.

Le tableau suivant montre la syntaxe que GetType vous utilisez pour différents types.

Pour obtenir	Utiliser
Nullable Int32	Type.GetType("System.Nullable`1[System.Int32]")
Pointeur non managé vers `MyType`	`Type.GetType("MyType*")`
Pointeur non managé vers un pointeur vers un pointeur vers `MyType`	`Type.GetType("MyType**")`
Pointeur managé ou référence à `MyType`	`Type.GetType("MyType&")`. Notez que contrairement aux pointeurs, les références sont limitées à un niveau.
Classe parente et classe imbriquée	`Type.GetType("MyParentClass+MyNestedClass")`
Tableau unidimensionnel avec une limite inférieure de 0	`Type.GetType("MyArray[]")`
Tableau unidimensionnel avec une limite inférieure inconnue	`Type.GetType("MyArray[*]")`
Tableau ndimensionnel	Virgule (,) entre crochets un total de n-1 fois. Par exemple, `System.Object[,,]` représente un tableau à trois dimensions `Object` .
Tableau d’un tableau à deux dimensions	`Type.GetType("MyArray[][]")`
Tableau à deux dimensions rectangulaire avec des limites inférieures inconnues	`Type.GetType("MyArray[,]")`
Type générique avec un argument de type	Type.GetType("MyGenericType`1[MyType]")
Type générique avec deux arguments de type	Type.GetType("MyGenericType`2[MyType,AnotherType]")
Type générique avec deux arguments de type qualifiés d’assembly	Type.GetType("MyGenericType`2[[MyType,MyAssembly],[AnotherType,AnotherAssembly]]")
Type générique qualifié d’assembly avec un argument de type qualifié d’assembly	Type.GetType("MyGenericType`1[[MyType,MyAssembly]],MyGenericTypeAssembly")
Type générique dont l’argument de type est un type générique avec deux arguments de type	Type.GetType("MyGenericType`1[AnotherGenericType`2[MyType,AnotherType]]")

Voir aussi

S’applique à

GetType(String, Boolean, Boolean)

Obtient le Type portant le nom spécifié, indiquant s'il faut lever une exception si le type est introuvable et s'il faut effectuer une recherche respectant la casse.

public:
 static Type ^ GetType(System::String ^ typeName, bool throwOnError, bool ignoreCase);

public static Type GetType (string typeName, bool throwOnError, bool ignoreCase);

public static Type? GetType (string typeName, bool throwOnError, bool ignoreCase);

static member GetType : string * bool * bool -> Type

Public Shared Function GetType (typeName As String, throwOnError As Boolean, ignoreCase As Boolean) As Type

Paramètres

typeName: String

throwOnError: Boolean

ignoreCase: 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.

Retours

Type

Exceptions

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

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 une de ses dépendances a été trouvé, mais n’a pas pu être chargé.

BadImageFormatException

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

ou -

La version 2.0 ou ultérieure du Common Language Runtime est actuellement chargée, et l’assembly a été compilé avec une version ultérieure.

Remarques

Vous pouvez utiliser la GetType méthode pour obtenir un Type objet pour un type dans un autre assembly si vous connaissez son nom qualifié d’assembly, qui peut être obtenu à partir de AssemblyQualifiedName. GetType entraîne le chargement de l’assembly spécifié dans typeName. Vous pouvez également charger un assembly à l’aide de la Assembly.Load méthode, puis utiliser le ou Assembly.GetTypes la Assembly.GetType méthode pour obtenir des Type objets. Si un type se trouve dans un assembly connu pour votre programme au moment de la compilation, il est plus efficace d’utiliser typeof en C# ou l’opérateur GetType dans Visual Basic.

GetType fonctionne uniquement sur les assemblys chargés à partir du disque. Si vous appelez GetType pour rechercher un type défini dans un assembly dynamique défini à l’aide des System.Reflection.Emit services, vous pouvez obtenir un comportement incohérent. Le comportement dépend du fait que l’assembly dynamique est persistant, c’est-à-dire créé à l’aide des RunAndSave modes d’accès ou Save de l’énumération System.Reflection.Emit.AssemblyBuilderAccess . Si l’assembly dynamique est persistant et a été écrit sur le disque avant GetType d’être appelé, le chargeur recherche l’assembly enregistré sur le disque, charge cet assembly et récupère le type de cet assembly. Si l’assembly n’a pas été enregistré sur le disque lorsqu’il GetType est appelé, la méthode retourne null. GetType ne comprend pas les assemblys dynamiques temporaires ; par conséquent, l’appel GetType pour récupérer un type dans un assembly dynamique temporaire retourne null.

Pour l’utiliser GetType sur un module dynamique, inscrivez-vous à l’événement et appelez GetType avant d’enregistrerAppDomain.AssemblyResolve. Sinon, vous obtiendrez deux copies de l’assembly en mémoire.

Le throwOnError paramètre spécifie ce qui se passe lorsque le type est introuvable et supprime également certaines autres conditions d’exception, comme décrit dans la section Exceptions. Certaines exceptions sont levées, quelle que soit la valeur de throwOnError. Par exemple, si le type est trouvé mais ne peut pas être chargé, un TypeLoadException est levée même si throwOnError c’est false.

Le tableau suivant montre les membres d’une classe de base retournés par les méthodes lors de la Get réflexion sur un type.

Type de membre	statique	Non statique
Constructeur	Non	Non
Champ	Non	Oui. Un champ est toujours masqué par nom et signature.
Événement	Non applicable	La règle système de type commune est que l’héritage est identique à celui des méthodes qui implémentent la propriété. La réflexion traite les propriétés comme masquage par nom et signature. Voir la note 2 ci-dessous.
Méthode	Non	Oui. Une méthode (virtuelle et non virtuelle) peut être masquer par nom ou masquer par nom et signature.
Type imbriqué	Non	Non
Propriété	Non applicable	La règle système de type commune est que l’héritage est identique à celui des méthodes qui implémentent la propriété. La réflexion traite les propriétés comme masquage par nom et signature. Voir la note 2 ci-dessous.

Masquer par nom et signature considère toutes les parties de la signature, notamment les modificateurs personnalisés, les types de retour, les types de paramètres, les sentinelles et les conventions d’appel non managées. Il s’agit d’une comparaison binaire.
Pour la réflexion, les propriétés et les événements sont masqués par nom et signature. Si vous avez une propriété avec un accesseur get et un accesseur set dans la classe de base, mais que la classe dérivée n’a qu’un accesseur get, la propriété de classe dérivée masque la propriété de classe de base et vous ne pourrez pas accéder au setter sur la classe de base.
Les attributs personnalisés ne font pas partie du système de type commun.

Les tableaux ou types COM ne sont pas recherchés, sauf s’ils ont déjà été chargés dans la table des classes disponibles.

typeName peut être le nom de type qualifié par son espace de noms ou un nom qualifié d’assembly qui inclut une spécification de nom d’assembly. Consultez AssemblyQualifiedName.

La AssemblyQualifiedName propriété retourne un nom de type complet, y compris les types imbriqués, le nom de l’assembly et les arguments de type. Tous les compilateurs qui prennent en charge le common language runtime émettent le nom simple d’une classe imbriquée et la réflexion construit un nom bascule lorsqu’ils sont interrogés, conformément aux conventions suivantes.

Notes

Dans la .NET Framework version 2.0, l’architecture du processeur est ajoutée à l’identité d’assembly et peut être spécifiée dans le cadre des chaînes de nom d’assembly. Par exemple, « ProcessorArchitecture=msil ». Toutefois, il n’est pas inclus dans la chaîne retournée par la AssemblyQualifiedName propriété, pour des raisons de compatibilité. Vous pouvez également charger des types en créant un AssemblyName objet et en le transmettant à une surcharge appropriée de la Load méthode. Vous pouvez ensuite utiliser la Assembly.GetType méthode pour charger des types à partir de l’assembly. Voir aussi AssemblyName.ProcessorArchitecture.

Délimiteur	Signification
Barre oblique inverse (\)	Caractère d’échappement.
Backtick (')	Précède un ou plusieurs chiffres représentant le nombre de paramètres de type, situés à la fin du nom d’un type générique.
Crochets ([])	Placer une liste d’arguments de type générique, pour un type générique construit ; dans une liste d’arguments de type, placez un type qualifié d’assembly.
Virgule (,)	Précède le nom de l’assembly.
Période (.)	Indique les identificateurs d’espace de noms.
Signe plus (+)	Précède une classe imbriquée.

Par exemple, le nom complet d’une classe peut ressembler à ceci :

TopNamespace.SubNameSpace.ContainingClass+NestedClass,MyAssembly

Si l’espace de noms était TopNamespace.Sub+Namespace, la chaîne doit précéder le signe plus (+) avec un caractère d’échappement (\) pour éviter qu’il ne soit interprété comme un séparateur d’imbrication. La réflexion émet cette chaîne comme suit :

TopNamespace.Sub\+Namespace.ContainingClass+NestedClass,MyAssembly

Un « ++ » devient «\+\ + », et un « » devient «\\\ ».

Pour les types génériques, la liste d’arguments de type est placée entre crochets et les arguments de type sont séparés par des virgules. Par exemple, un générique Dictionary<TKey,TValue> a deux paramètres de type. Une Dictionary<TKey,TValue> des MyType clés de type String peut être représentée comme suit :

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

Pour spécifier un type qualifié d’assembly dans une liste d’arguments de type, placez le type qualifié d’assembly entre crochets. Sinon, les virgules qui séparent les parties du nom qualifié d’assembly sont interprétées comme limitant les arguments de type supplémentaires. Par exemple, une Dictionary<TKey,TValue> de MyType MyAssembly.dll, avec des clés de type String, peut être spécifiée comme suit :

Type.GetType("System.Collections.Generic.Dictionary`2[System.String,[MyType,MyAssembly]]")

Notes

Les types nullables sont un cas spécial de types génériques. Par exemple, une valeur Nullable Int32 est représentée par la chaîne « System.Nullable'1[System.Int32] ».

Notes

En C#, C++et Visual Basic vous pouvez également obtenir des types nullables à l’aide d’opérateurs de type. Par exemple, le type nullable Boolean est retourné par typeof(Nullable<bool>) C#, par Nullable<Boolean>::typeid C++, et par GetType(Nullable(Of Boolean)) Visual Basic.

Le tableau suivant montre la syntaxe que GetType vous utilisez pour différents types.

Pour obtenir	Utiliser
Nullable Int32	Type.GetType("System.Nullable`1[System.Int32]")
Pointeur non managé vers `MyType`	`Type.GetType("MyType*")`
Pointeur non managé vers un pointeur vers un pointeur vers `MyType`	`Type.GetType("MyType**")`
Pointeur managé ou référence à `MyType`	`Type.GetType("MyType&")`. Notez que contrairement aux pointeurs, les références sont limitées à un niveau.
Classe parente et classe imbriquée	`Type.GetType("MyParentClass+MyNestedClass")`
Tableau unidimensionnel avec une limite inférieure de 0	`Type.GetType("MyArray[]")`
Tableau unidimensionnel avec une limite inférieure inconnue	`Type.GetType("MyArray[*]")`
Tableau ndimensionnel	Virgule (,) entre crochets un total de n-1 fois. Par exemple, `System.Object[,,]` représente un tableau tridimensionnel `Object` .
Tableau à deux dimensions	`Type.GetType("MyArray[][]")`
Tableau rectangulaire à deux dimensions avec des limites inférieures inconnues	`Type.GetType("MyArray[,]")`
Type générique avec un argument de type	Type.GetType("MyGenericType`1[MyType]")
Type générique avec deux arguments de type	Type.GetType("MyGenericType`2[MyType,AnotherType]")
Type générique avec deux arguments de type qualifiés d’assembly	Type.GetType("MyGenericType`2[[MyType,MyAssembly],[AnotherType,AnotherAssembly]]")
Type générique qualifié d’assembly avec un argument de type qualifié d’assembly	Type.GetType("MyGenericType`1[[MyType,MyAssembly]],MyGenericTypeAssembly")
Type générique dont l’argument de type est un type générique avec deux arguments de type	Type.GetType("MyGenericType`1[AnotherGenericType`2[MyType,AnotherType]]")

Voir aussi

S’applique à

GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>)

Obtient le type avec le nom spécifié et éventuellement des méthodes personnalisées permettant de résoudre l'assembly et le type.

public:
 static Type ^ GetType(System::String ^ typeName, Func<System::Reflection::AssemblyName ^, System::Reflection::Assembly ^> ^ assemblyResolver, Func<System::Reflection::Assembly ^, System::String ^, bool, Type ^> ^ typeResolver);

public static Type? GetType (string typeName, Func<System.Reflection.AssemblyName,System.Reflection.Assembly?>? assemblyResolver, Func<System.Reflection.Assembly?,string,bool,Type?>? typeResolver);

public static Type GetType (string typeName, Func<System.Reflection.AssemblyName,System.Reflection.Assembly> assemblyResolver, Func<System.Reflection.Assembly,string,bool,Type> typeResolver);

static member GetType : string * Func<System.Reflection.AssemblyName, System.Reflection.Assembly> * Func<System.Reflection.Assembly, string, bool, Type> -> Type

Public Shared Function GetType (typeName As String, assemblyResolver As Func(Of AssemblyName, Assembly), typeResolver As Func(Of Assembly, String, Boolean, Type)) As Type

Paramètres

typeName: 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/System.Private.CoreLib.dll, auquel cas il suffit de fournir le nom de type qualifié par son espace de noms.

assemblyResolver: 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: 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 typeResolver 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 ; false est passé à ce paramètre.

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

Retours

Type

Type portant le nom spécifié, ou null si le type est introuvable.

Exceptions

ArgumentNullException

typeName a la valeur null.

TargetInvocationException

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

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

TypeLoadException

typeName représente un tableau de TypedReference.

FileLoadException

L’assembly ou 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.

Remarques

Les scénarios d’utilisation de cette méthode et des détails sur les paramètres et typeResolver les assemblyResolver paramètres sont disponibles dans la surcharge de GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) méthode.

Notes

S’il typeName est introuvable, l’appel à la GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>) méthode retourne null. Elle ne lève pas d’exception. Pour contrôler si une exception est levée, appelez une surcharge de la GetType méthode qui a un throwOnError paramètre.

L’appel de cette surcharge de méthode est le même que l’appel de la GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) surcharge de méthode et la false spécification pour les paramètres et ignoreCase les throwOnError paramètres.

S’applique à

GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean)

Obtient le type portant le nom spécifié, en indiquant s'il faut lever une exception si le type est introuvable et, éventuellement, en fournissant des méthodes personnalisées qui permettent de résoudre l'assembly et le type.

public:
 static Type ^ GetType(System::String ^ typeName, Func<System::Reflection::AssemblyName ^, System::Reflection::Assembly ^> ^ assemblyResolver, Func<System::Reflection::Assembly ^, System::String ^, bool, Type ^> ^ typeResolver, bool throwOnError);

public static Type? GetType (string typeName, Func<System.Reflection.AssemblyName,System.Reflection.Assembly?>? assemblyResolver, Func<System.Reflection.Assembly?,string,bool,Type?>? typeResolver, bool throwOnError);

public static Type GetType (string typeName, Func<System.Reflection.AssemblyName,System.Reflection.Assembly> assemblyResolver, Func<System.Reflection.Assembly,string,bool,Type> typeResolver, bool throwOnError);

static member GetType : string * Func<System.Reflection.AssemblyName, System.Reflection.Assembly> * Func<System.Reflection.Assembly, string, bool, Type> * bool -> Type

Public Shared Function GetType (typeName As String, assemblyResolver As Func(Of AssemblyName, Assembly), typeResolver As Func(Of Assembly, String, Boolean, Type), throwOnError As Boolean) As Type

Paramètres

typeName: String

assemblyResolver: Func<AssemblyName,Assembly>

typeResolver: 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 ; false est passé à ce paramètre.

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

throwOnError: Boolean

Retours

Type

Exceptions

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

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.

ou - typeName contient un nom d’assembly non valide.
ou - typeName est un nom d’assembly valide sans nom de type.

FileLoadException

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

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.

Remarques

S’applique à

GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean)

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.

public:
 static Type ^ GetType(System::String ^ typeName, Func<System::Reflection::AssemblyName ^, System::Reflection::Assembly ^> ^ assemblyResolver, Func<System::Reflection::Assembly ^, System::String ^, bool, Type ^> ^ typeResolver, bool throwOnError, bool ignoreCase);

public static Type? GetType (string typeName, Func<System.Reflection.AssemblyName,System.Reflection.Assembly?>? assemblyResolver, Func<System.Reflection.Assembly?,string,bool,Type?>? typeResolver, bool throwOnError, bool ignoreCase);

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

static member GetType : string * Func<System.Reflection.AssemblyName, System.Reflection.Assembly> * Func<System.Reflection.Assembly, string, bool, Type> * bool * bool -> Type

Public Shared Function GetType (typeName As String, assemblyResolver As Func(Of AssemblyName, Assembly), typeResolver As Func(Of Assembly, String, Boolean, Type), throwOnError As Boolean, ignoreCase As Boolean) As Type

Paramètres

typeName: String

assemblyResolver: Func<AssemblyName,Assembly>

typeResolver: 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: Boolean

ignoreCase: 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.

Retours

Type

Exceptions

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

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

Remarques

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 par des implémentations plus flexibles. En fournissant vos propres méthodes qui résolvent les noms de type et les noms des assemblys qui les contiennent, vous pouvez effectuer les opérations suivantes :

Contrôlez la version d’un assembly à partir duquel un type est chargé.
Fournissez un autre emplacement pour rechercher un nom de type qui n’inclut pas de nom d’assembly.
Chargez des assemblys à l’aide de noms d’assembly partiels.
Retourne les sous-classes de System.Type ce qui ne sont pas créées par le Common Language Runtime (CLR).

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

D’autres implémentations du système de type peuvent avoir besoin de retourner des sous-classes qui System.Type ne sont pas créées par le CLR; tous les types retournés par d’autres surcharges de la GetType méthode sont des types d’exécution.

Notes d’utilisation

Cette surcharge de méthode et ses surcharges associées analysent typeName le nom d’un type et le nom d’un assembly, puis résolvent les noms. La 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.

Notes

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

Si typeName ce n’est pas un nom qualifié d’assembly, la résolution d’assembly est ignorée. Les noms de types non qualifiés peuvent être résolus dans le contexte de mscorlib.dll/System.Private.CoreLib.dll ou de l’assembly en cours d’exécution, ou vous pouvez éventuellement fournir un assembly dans le typeResolver paramètre. Les effets de l’inclusion ou de l’omission du nom d’assembly pour différents types de résolution de noms s’affichent sous forme de tableau dans la section Résolution de noms mixte .

Notes d’utilisation générales :

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

Attention

L’utilisation de méthodes provenant d’appelants inconnus ou non approuvés peut entraîner une élévation de privilèges pour le code malveillant.
Si vous omettez les paramètres et/ou typeResolver les assemblyResolver paramètres, la valeur du throwOnError paramètre est transmise aux méthodes qui effectuent la résolution par défaut.
Si throwOnError c’est truele cas, cette méthode lève un TypeLoadException moment de retournull, et une FileNotFoundException fois typeResolver assemblyResolver retournée null.
Cette méthode ne intercepte pas les exceptions levées et assemblyResolver typeResolver. Vous êtes responsable des exceptions levées par les méthodes du programme de résolution.

Résolution des assemblys

La assemblyResolver méthode reçoit un AssemblyName objet, qui est produit en analysant le nom de l’assembly de chaîne inclus dans typeName. S’il typeName ne contient pas de nom d’assembly, assemblyResolver n’est pas appelé et null est passé à typeResolver.

S’il assemblyResolver n’est pas fourni, la détection d’assembly standard est utilisée pour localiser l’assembly. Si assemblyResolver elle est fournie, la GetType méthode ne fait pas de test standard ; dans ce cas, vous devez vous assurer que vous assemblyResolver pouvez gérer tous les assemblys que vous transmettez.

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

Si celui-ci AssemblyName est passé à assemblyResolver un nom partiel, une ou plusieurs de ses parties sont null. Par exemple, s’il n’a pas de version, la Version propriété est null. Si la propriété, la Version CultureInfo propriété et la GetPublicKeyToken méthode retournent nulltous, seul le nom simple de l’assembly a été fourni. La assemblyResolver méthode peut utiliser ou ignorer toutes les parties du nom de l’assembly.

Les effets des différentes options de résolution d’assembly sont affichés sous forme de tableau dans la section Résolution de noms mixte , pour les noms de types simples et qualifiés d’assembly.

Résolution des types

S’il typeName ne spécifie pas de nom d’assembly, typeResolver est toujours appelé. Si typeName elle spécifie un nom d’assembly, typeResolver elle est appelée uniquement lorsque le nom de l’assembly est correctement résolu. Si assemblyResolver ou le contrôle d’assembly standard retourne null, typeResolver n’est pas appelé.

La typeResolver méthode reçoit trois arguments :

Assembly à rechercher ou null s’il typeName ne contient pas de nom d’assembly.
Nom simple du type. Dans le cas d’un type imbriqué, il s’agit du type le plus externe contenant. 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 le cas de noms de type doit être ignoré.

L’implémentation détermine la façon dont ces arguments sont utilisés. La typeResolver méthode doit retourner null s’il ne peut pas résoudre le type. Si typeResolver retourne null et throwOnError est true, cette surcharge de GetType levées a TypeLoadException.

Les effets des différentes options de résolution de type sont affichés sous forme de tableau dans la section Résolution de noms mixte , pour les noms de types simples et qualifiés d’assembly.

Résolution des types imbriqués

S’il typeName s’agit d’un type imbriqué, seul le nom du type contenant le plus externe est passé à typeResolver. Lorsque typeResolver cette propriété renvoie ce type, la GetNestedType méthode est appelée de façon récursive jusqu’à ce que le type imbriqué le plus interne ait été résolu.

Résolution des types génériques

Appelé GetType récursivement pour résoudre les types génériques : commencez par 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é récursivement pour résoudre ses arguments de type, et ainsi de suite.

La combinaison de assemblyResolver et typeResolver de ce que vous fournissez doit être capable de résoudre tous les niveaux de cette récursivité. Par exemple, supposons que vous fournissez un assemblyResolver contrôle du chargement de MyAssembly. Supposons que vous souhaitez résoudre le type Dictionary<string, MyType> générique (Dictionary(Of String, MyType)dans 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 c’est le seul argument de type qualifié d’assembly. Les noms des classes et String des Dictionary<TKey,TValue> classes ne sont pas qualifiés par l’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 se trouvent dans mscorlib.dll/System.Private.CoreLib.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)
                     );

let t =
    Type.GetType(test,
        (fun aName ->
            if aName.Name = "MyAssembly" then
                Assembly.LoadFrom @".\MyPath\v5.0\MyAssembly.dll"
            else null),
        fun assem name ignr ->
            if assem = null then
                Type.GetType(name, false, ignr)
            else
                assem.GetType(name, false, ignr))

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

Supposons maintenant que, 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]]"

Comme cet assembly n’est ni mscorlib.dll/System.Private.CoreLib.dll ni l’assembly en cours d’exécution, vous ne pouvez pas résoudre YourType sans nom qualifié d’assembly. Comme votre assemblyResolve sera appelé récursivement, il doit être en mesure de gérer ce cas. Au lieu de retourner null des assemblys autres que MyAssembly, il effectue désormais une charge d’assembly à l’aide de l’objet fourni AssemblyName .

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

let t2 =
    Type.GetType(test,
        (fun aName ->
            if aName.Name = "MyAssembly" then
                Assembly.LoadFrom @".\MyPath\v5.0\MyAssembly.dll"
            else Assembly.Load aName),
        (fun assem name ignr ->
            if assem = null then
                Type.GetType(name, false, ignr)
            else
                assem.GetType(name, false, ignr)), true)

Retour aux notes d’utilisation.

Résolution des noms de types avec des caractères spéciaux

Certains caractères ont des significations spéciales 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 échapper aux caractères spéciaux avec une barre oblique inverse avant de pouvoir transmettre le nom qualifié d’assembly à la GetType méthode. Par exemple, si un type est nomméStrange]Type, le caractère d’échappement doit être ajouté avant le crochet comme suit : Strange\]Type

Notes

Les noms avec ces caractères spéciaux ne peuvent pas être créés dans Visual Basic ou C#, mais peuvent être créés à l’aide du langage intermédiaire Microsoft (MSIL) ou en émettant des assemblys dynamiques.

Le tableau suivant montre 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 paire de suffixes, indique un type de tableau ; en tant que paire délimiteur, place les listes d’arguments génériques et les noms qualifiés d’assembly.
`&` (esperluette)	En tant que suffixe, indique qu’un type est un type de référence.
`*` (astérisque)	En tant que suffixe, indique qu’un type est un type de pointeur.
`+` (plus)	Délimiteur pour les types imbriqués.
`\` (barre oblique inverse)	Caractère d’échappement.

Propriétés telles que AssemblyQualifiedName les chaînes retournées correctement échapées. Vous devez passer correctement les chaînes d’échappement à la GetType méthode. À son tour, la GetType méthode passe correctement les noms d’échappement vers typeResolver et vers les méthodes de résolution de type par défaut. Si vous devez comparer un nom à un nom non boucté, typeResolvervous devez supprimer les caractères d’échappement.

Retour aux notes d’utilisation.

Résolution de noms mixte

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

Contenu du nom de type	Méthode de résolution d’assembly	Méthode de résolution de type	Résultat
type, assembly	null	null	Équivalent à l’appel de la Type.GetType(String, Boolean, Boolean) surcharge de méthode.
type, assembly	Fourni	null	`assemblyResolver` retourne l’assembly ou retourne `null` s’il ne peut pas résoudre l’assembly. Si l’assembly est résolu, la 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ésolution du type.
type, assembly	null	Fourni	Équivalent à la conversion du nom de AssemblyName l’assembly en objet et à l’appel de la 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é et il n’y a aucune tentative supplémentaire de résoudre le type.
type, assembly	Fourni	Fourni	`assemblyResolver` retourne l’assembly ou retourne `null` s’il ne peut pas résoudre l’assembly. Si l’assembly est résolu, il est passé à `typeResolver`; sinon, `typeResolver` n’est pas appelé et il n’y a aucune tentative supplémentaire de résoudre le type.
type	Null, fourni	null	Équivalent à l’appel de la Type.GetType(String, Boolean, Boolean) surcharge de méthode. Comme le nom de l’assembly n’est pas fourni, seuls mscorlib.dll/System.Private.CoreLib.dll et l’assembly en cours d’exécution sont recherchés. Si `assemblyResolver` elle est fournie, elle est ignorée.
type	Null, fourni	Fourni	`typeResolver` est appelé, et `null` est passé pour l’assembly. `typeResolver` peut fournir un type à partir de n’importe quel assembly, y compris les assemblys qu’il charge à des fins. Si `assemblyResolver` elle est fournie, elle est ignorée.
assembly	Null, fourni	Null, fourni	Un 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.

Retour à : Notes d’utilisation, résolution d’assemblys, résolution de types.

S’applique à

Type.GetType Méthode

Cette page est-elle utile ?

Définition

Surcharges

GetType()

Retours

Implémente

Exceptions

Voir aussi

S’applique à

GetType(String)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

GetType(String, Boolean)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

GetType(String, Boolean, Boolean)

Paramètres

Retours

Exceptions

Remarques

Voir aussi

S’applique à

GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>)

Paramètres

Retours

Exceptions

Remarques

S’applique à

GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean)

Paramètres

Retours

Exceptions

Remarques

S’applique à

GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean)

Paramètres

Retours

Exceptions

Remarques

Notes d’utilisation

Résolution des assemblys

Résolution des types

Résolution des types imbriqués

Résolution des types génériques

Résolution des noms de types avec des caractères spéciaux

Résolution de noms mixte

S’applique à