Type.GetType Méthode

Source:

Type.cs

Source:

Type.cs

Source:

Type.cs

Source:

Type.cs

Source:

Type.cs

public:
 Type ^ GetType();

public:
 virtual Type ^ GetType();

public Type GetType();

override this.GetType : unit -> Type

Public Function GetType () As Type

Retours

En cours Type.

Implémente

Exceptions

Voir aussi

• TypeLoadException
• Spécification de noms de types complets

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

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

public static Type GetType(string typeName);

[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")]
public static Type? GetType(string typeName);

public static Type? GetType(string typeName);

static member GetType : string -> Type

[<System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")>]
static member GetType : string -> Type

Public Shared Function GetType (typeName As String) As Type

Paramètres

Retours

Type portant le nom spécifié, s’il est trouvé ; sinon, null.

Attributs

RequiresUnreferencedCodeAttribute

Exceptions

Exemples

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

using System;

class GetTypeExample
{
     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.GetType la Assembly.GetTypes 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.

.NET Framework uniquement : 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.

Dans .NET Framework, pour utiliser GetType sur un module dynamique, abonnez-vous à l’événement AppDomain.AssemblyResolve et appelez GetType avant l’enregistrement. Sinon, vous obtiendrez deux copies de l’assembly en mémoire.

Sur .NET Core 3.0 et versions ultérieures, les chargements d’assembly déclenchés par cette API sont affectés par la valeur actuelle de AssemblyLoadContext.CurrentContextualReflectionContext.

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	Static	Non statique
Constructor	Non	Non
Champ	Non	Yes. Un champ est toujours masqué par nom et signature.
Event	Sans objet	La règle du système de type courant 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	Yes. Une méthode (virtuelle et non virtuelle) peut être masquée par nom ou par nom et signature.
Type imbriqué	Non	Non
Propriété	Sans objet	La règle du système de type courant 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.

1. Hide-by-name-and-signature prend en compte 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.

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

3. 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. Voir 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 bascule lorsqu’ils sont interrogés, conformément aux conventions suivantes.

Séparateur	Sens
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 Typefichier . 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 types peuvent inclure des caractères de fin qui indiquent des informations supplémentaires sur le type, par exemple si le type est un type référence, un type de pointeur ou un type de tableau. Pour récupérer le nom du 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, se produisant dans la même étendue. Par exemple, la réflexion retourne les noms bascules Tuple`1 et Tuple`2 des méthodes génériques Tuple(Of T) et Tuple(Of T0, T1) dans Visual Basic, ou Tuple<T> et 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, une Dictionary<TKey,TValue> fromMyAssembly.dllMyType , 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]]")

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

Le tableau suivant présente la syntaxe avec laquelle 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 seul 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 seul 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é 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

• String
• TypeLoadException
• AssemblyQualifiedName
• GetAssembly(Type)
• GetType(String)
• AssemblyName
• Spécification de noms de types complets

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

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

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

[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")]
public static Type? GetType(string typeName, bool throwOnError);

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

static member GetType : string * bool -> Type

[<System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")>]
static member GetType : string * bool -> Type

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

Paramètres

Retours

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

Attributs

RequiresUnreferencedCodeAttribute

Exceptions

Exemples

L’exemple suivant récupère le type de System.Int32 cet objet 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 System;

class GetTypeExample
{
     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.GetType la Assembly.GetTypes 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.

.NET Framework uniquement : 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.

Dans .NET Framework, pour utiliser GetType sur un module dynamique, abonnez-vous à l’événement AppDomain.AssemblyResolve et appelez GetType avant l’enregistrement. Sinon, vous obtiendrez deux copies de l’assembly en mémoire.

Sur .NET Core 3.0 et versions ultérieures, les chargements d’assembly déclenchés par cette API sont affectés par la valeur actuelle de AssemblyLoadContext.CurrentContextualReflectionContext.

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 c’est throwOnErrorfalse.

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	Static	Non statique
Constructor	Non	Non
Champ	Non	Yes. Un champ est toujours masqué par nom et signature.
Event	Sans objet	La règle du système de type courant 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	Yes. Une méthode (virtuelle et non virtuelle) peut être masquée par nom ou par nom et signature.
Type imbriqué	Non	Non
Propriété	Sans objet	La règle du système de type courant 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.

1. Hide-by-name-and-signature prend en compte 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.

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

3. 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. Voir 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 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 bascule lorsqu’ils sont interrogés, conformément aux conventions suivantes.

Séparateur	Sens
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 Typefichier . 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 types peuvent inclure des caractères de fin qui indiquent des informations supplémentaires sur le type, par exemple si le type est un type référence, un type de pointeur ou un type de tableau. Pour récupérer le nom du 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, se produisant dans la même étendue. Par exemple, la réflexion retourne les noms bascules Tuple`1 et Tuple`2 des méthodes génériques Tuple(Of T) et Tuple(Of T0, T1) dans Visual Basic, ou Tuple<T> et 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, 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]]")

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

Le tableau suivant présente la syntaxe avec laquelle 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 seul 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 d’un 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 seul 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é 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

• String
• TypeLoadException
• AssemblyQualifiedName
• GetAssembly(Type)
• GetType(String)
• AssemblyName
• Spécification de noms de types complets

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

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

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

[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")]
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

[<System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")>]
static member GetType : string * bool * bool -> Type

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

Paramètres

Retours

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

Attributs

RequiresUnreferencedCodeAttribute

Exceptions

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.GetType la Assembly.GetTypes 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.

.NET Framework uniquement : 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.

Dans .NET Framework, pour utiliser GetType sur un module dynamique, abonnez-vous à l’événement AppDomain.AssemblyResolve et appelez GetType avant l’enregistrement. Sinon, vous obtiendrez deux copies de l’assembly en mémoire.

Sur .NET Core 3.0 et versions ultérieures, les chargements d’assembly déclenchés par cette API sont affectés par la valeur actuelle de AssemblyLoadContext.CurrentContextualReflectionContext.

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 c’est throwOnErrorfalse.

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	Static	Non statique
Constructor	Non	Non
Champ	Non	Yes. Un champ est toujours masqué par nom et signature.
Event	Sans objet	La règle du système de type courant 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	Yes. Une méthode (virtuelle et non virtuelle) peut être masquée par nom ou par nom et signature.
Type imbriqué	Non	Non
Propriété	Sans objet	La règle du système de type courant 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.

1. Hide-by-name-and-signature prend en compte 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.

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

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

Séparateur	Sens
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 Typefichier . 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 types peuvent inclure des caractères de fin qui indiquent des informations supplémentaires sur le type, par exemple si le type est un type référence, un type de pointeur ou un type de tableau. Pour récupérer le nom du 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, se produisant dans la même étendue. Par exemple, la réflexion retourne les noms bascules Tuple`1 et Tuple`2 des méthodes génériques Tuple(Of T) et Tuple(Of T0, T1) dans Visual Basic, ou Tuple<T> et 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, 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]]")

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

Le tableau suivant présente la syntaxe avec laquelle 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 seul 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 d’un 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 seul 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é 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

• String
• TypeLoadException
• AssemblyQualifiedName
• GetAssembly(Type)
• GetType(String)
• AssemblyName
• Spécification de noms de types complets

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

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

[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")]
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);

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

[<System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")>]
static member GetType : string * Func<System.Reflection.AssemblyName, System.Reflection.Assembly> * Func<System.Reflection.Assembly, string, bool, Type> -> Type

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

Retours

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

Attributs

RequiresUnreferencedCodeAttribute

Exceptions

Remarques

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

L’appel de cette surcharge de méthode est identique à l’appel de la GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) surcharge de méthode et en spécifiant false pour les paramètres et throwOnError les ignoreCase paramètres.

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

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

[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")]
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);

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

[<System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")>]
static member GetType : string * Func<System.Reflection.AssemblyName, System.Reflection.Assembly> * Func<System.Reflection.Assembly, string, bool, Type> * bool -> Type

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

Retours

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

Attributs

RequiresUnreferencedCodeAttribute

Exceptions

Remarques

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

L’appel de cette surcharge de méthode est identique à 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 du ignoreCase paramètre.

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

Source:

Type.CoreCLR.cs

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

[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")]
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);

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

[<System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("The type might be removed")>]
static member GetType : string * Func<System.Reflection.AssemblyName, System.Reflection.Assembly> * Func<System.Reflection.Assembly, string, bool, Type> * bool * bool -> Type

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

Retours

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

Attributs

RequiresUnreferencedCodeAttribute

Exceptions

Remarques

Sur .NET Core 3.0 et versions ultérieures, si assemblyResolver est null, les chargements d’assembly déclenchés par cette API sont affectés par la valeur actuelle de AssemblyLoadContext.CurrentContextualReflectionContext.

Utilisez la GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) 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 de laquelle un type est chargé.
• Fournissez un emplacement supplémentaire pour rechercher un nom de type qui n'inclut pas de nom d'assemblage.
• Chargez des assemblies à l’aide de noms partiels d’assembly.
• Retourne les sous-classes de System.Type celles 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 « meilleur ajustement » à l’aide d’un nom partiel. D'autres surcharges de la méthode GetType 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 de System.Type qui ne sont pas créées par le CLR ; tous les types retournés par d'autres surcharges de la méthode GetType sont des types au moment de l'exécution.

Notes d’utilisation

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 résolvent les noms. La résolution du nom de l'assemblage se produit avant la résolution du nom de type, car un nom de type doit être résolu dans le contexte d'un assemblage.

Si typeName n'est pas un nom qualifié d'assembly, la résolution de l'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 paramètre typeResolver. Les effets de l’inclusion ou de l’omission du nom d’assembly pour différents types de résolution de noms sont affichés sous forme de tableau dans la section Résolution de noms mixte .

Notes d’utilisation générales :

• Ne transmettez 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 que vous connaissez bien.

  Avertissement

  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 le paramètre assemblyResolver et/ou le paramètre typeResolver, la valeur du paramètre throwOnError est transmise aux méthodes qui effectuent la résolution par défaut.

• Si throwOnError est true, cette méthode lève une TypeLoadException quand typeResolver retourne null, et une FileNotFoundException quand assemblyResolver retourne null.

• Cette méthode n’intercepte pas les exceptions levées par assemblyResolver et typeResolver. Vous êtes responsable des exceptions générées par les méthodes 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.

Si assemblyResolver n’est pas fourni, la recherche d'assemblage standard est utilisée pour localiser l'assemblage. Si assemblyResolver est fourni, la méthode GetType n’effectue pas de sondage standard ; dans ce cas, vous devez vous assurer que votre assemblyResolver peut gérer tous les assemblages que vous lui 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 est true, un FileNotFoundException est levé.

Si le AssemblyName qui est passé à assemblyResolver est 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 Version propriété, la 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 indiqués dans le tableau de la section Résolutions de noms mixtes, pour les noms de types simples et les noms de types qualifiés d'assembly.

Résolution des types

Si aucun nom d'assembly n'est spécifié pour typeName, typeResolver est toujours appelé. Si typeName spécifie un nom d’assembly, typeResolver est appelée uniquement lorsque le nom d’assembly est résolu avec succès. Si assemblyResolver ou le sondage d’assembly standard retourne null, typeResolver n’est pas appelé.

La typeResolver méthode reçoit trois arguments :

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

L’implémentation détermine la façon dont ces arguments sont utilisés. La typeResolver méthode doit retourner null si elle ne peut pas résoudre le type. Si typeResolver renvoie null et que throwOnError est true, cette surcharge de GetType lève une TypeLoadException.

Les effets des différents types de résolution d'assembly sont indiqués dans le tableau de la section Résolutions de noms mixtes, pour les noms de types simples et les noms de types qualifiés d'assembly.

Résolution des types imbriqués

Si typeName est un type imbriqué, seul le nom du type conteneur le plus extérieur est passé à typeResolver. Lorsqu'une méthode de type typeResolver retourne ce type, la méthode GetNestedType est appelée de manière récursive jusqu’à ce que le type imbriqué le plus interne ait été résolu.

Résolution des types génériques

Il GetType est appelé de manière récursive 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é 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, supposons que vous fournissez un assemblyResolver qui contrôle le chargement de MyAssembly. Supposons que vous souhaitez résoudre le type Dictionary<string, MyType> générique (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 le seul argument de type qualifié par assembly. Les noms des classes Dictionary<TKey,TValue> et String ne sont pas qualifiés par l’assembly. Votre typeResolver doit être capable de gérer un assemblage ou null, car il recevra null pour Dictionary<TKey,TValue> et String. Il peut gérer ce cas en appelant une surcharge de la méthode GetType qui prend une chaîne, car les deux noms de types 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 méthode assemblyResolver 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 par l’assembly.

Supposons maintenant que, au lieu de , le premier type d’argument System.Stringgé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/System.Private.CoreLib.dll ni l’assembly en cours d’exécution, vous ne pouvez pas résoudre YourType sans 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 des assemblies autres que MyAssembly, il effectue désormais un chargement d'assemblies à l'aide de l'objet AssemblyName fourni.

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)

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

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

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

Caractère	Sens
, (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 de délimiteurs, encadre 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.
\ (antislash)	Caractère d’échappement.

Les propriétés telles que AssemblyQualifiedName renvoient des chaînes correctement échappées. Vous devez passer des chaînes échappées correctement à la méthode GetType. À son tour, la méthode GetType transmet les noms correctement échappés aux méthodes typeResolver et aux méthodes de résolution de type par défaut. Si vous devez comparer un nom à un nom non échappé dans typeResolver, vous devez supprimer les caractères d'échappement.

Résolutions de noms mixtes

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

Contenu du nom de type	Méthode du résolveur d'assembly	Méthode du résolveur de type	Result
type, assemblage	zéro	zéro	Équivaut à appeler la surcharge de méthode Type.GetType(String, Boolean, Boolean) .
type, assemblage	fourni	zéro	assemblyResolver retourne l’assemblage ou retourne null s’il ne peut pas résoudre l’assemblage. Si l’assembly est résolu, la surcharge de méthode Assembly.GetType(String, Boolean, Boolean) est utilisée pour charger le type à partir de l’assembly ; sinon, il n'y a aucune tentative de résolution du type.
type, assemblage	zéro	fourni	Équivaut à convertir le nom de l'assembly en un objet AssemblyName et à appeler la surcharge de méthode Assembly.Load(AssemblyName) 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 pas d’autre tentative de résolution du type.
type, assemblage	fourni	fourni	assemblyResolver retourne l’assemblage ou retourne null s’il ne peut pas résoudre l’assemblage. Si l’assembly est résolu, il est passé à typeResolver; sinon, typeResolver n’est pas appelé et il n’y a pas d’autre tentative de résolution du type.
type	null, fourni	zéro	Équivaut à appeler la surcharge de méthode Type.GetType(String, Boolean, Boolean) . Étant donné que 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 est fourni, il est ignoré.
type	null, fourni	fourni	typeResolver est appelé et null est passé pour l’assemblage. typeResolver peut fournir un type à partir de n’importe quel assembly, y compris les assemblys qu’il charge à cette fin. Si assemblyResolver est fourni, il est ignoré.
assemblage	null, fourni	null, fourni	Une 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.