Type.GetType, méthode (String) (System)

Vous pouvez utiliser la méthode GetType pour obtenir un objet Type pour un type dans un autre assembly, si vous connaissez son nom qualifié par espace de noms. GetType provoque le chargement de l'assembly spécifié dans typeName. Vous pouvez également charger un assembly à l'aide de la méthode Load, puis utiliser les méthodes GetType ou GetTypes de la classe Assembly pour obtenir des objets Type. 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#, GetType en Visual Basic ou typeid en C++.

GetType ne fonctionne que 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 services System.Reflection.Emit, vous pouvez obtenir un comportement incohérent. Le comportement dépend de la persistance ou non de l'assembly dynamique, c'est-à-dire de sa création ou non à l'aide des modes d'accès RunAndSave ou Save de l'énumération System.Reflection.Emit.AssemblyBuilderAccess. Si l'assembly dynamique est persistant et s'il a été écrit sur le disque avant l'appel de GetType, le chargeur trouve alors l'assembly enregistré sur le disque, charge l'assembly et récupère le type de cet assembly. Si l'assembly n'a pas été enregistré sur le disque lors de l'appel de GetType, la méthode retourne null. GetType ne reconnaissant pas les assemblys dynamiques transitoires, l'appel de GetType pour récupérer un type dans un assembly dynamique transitoire retourne null.

Pour utiliser GetType sur un module dynamique, abonnez-vous à l'événement AppDomain.AssemblyResolve et appelez GetType avant de procéder à l'enregistrement. Sinon, vous obtiendrez deux copies de l'assembly dans la mémoire.

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

1. Masquer-par-nom-et-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.

2. Pour la réflexion, les propriétés et événements sont masqués-par-nom-et-signature. Si une propriété a un accesseur get et set dans la classe de base, mais si la classe dérivée n'a qu'un accesseur get, la propriété de la classe dérivée masque la propriété de la classe de base et vous ne pourrez pas accéder à l'accesseur Set sur la classe de base.

3. Les attributs personnalisés ne font pas partie du système de type commun (CTS, Common Type System).

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 inclut l'espace de noms mais pas le nom de l'assembly, cette méthode effectue des recherches uniquement dans l'assembly de l'objet appelant et dans Mscorlib.dll, dans cet ordre. Si typeName est un nom qualifié complet comprenant le nom d'assembly partiel ou complet, la méthode effectue la recherche dans l'assembly spécifié. Si l'assembly possède un nom fort, un nom d'assembly complet est requis.

La propriété AssemblyQualifiedName peut retourner un nom de type qualifié complet incluant des types imbriqués, le nom de l'assembly et des arguments de type générique. Tous les compilateurs qui prennent en charge le Common Language Runtime émettront le nom simple d'une classe imbriquée et la réflexion construit un nom tronqué sur demande, conformément aux conventions suivantes.

Remarque

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

Par exemple, le nom qualifié complet d'une classe peut ressembler à ceci :

TopNamespace.SubNameSpace.ContainingClass+NestedClass,MyAssembly

Si l'espace de noms était TopNamespace.Sub+Namespace, la chaîne devrait faire précéder le signe plus (+) d'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

"++" devient "\+\+" et "\" devient "\\".

Ce nom qualifié peut être persistant et utilisé ultérieurement pour charger Type. Pour rechercher et charger un Type, utilisez GetType avec le nom de type ou avec le nom de type qualifié d'assembly. GetType avec le nom de type recherchera seulement le Type dans l'assembly de l'appelant puis dans l'assembly System. GetType avec le nom de type qualifié de l'assembly recherchera le Type dans tous les assemblys.

Les noms de types peuvent présenter des caractères de fin qui apportent des précisions sur le type, indiquant notamment s'il s'agit d'un type référence, d'un type pointeur ou d'un type tableau. Pour récupérer le nom de type sans ces caractères de fin, utilisez t.GetElementType().ToString(), où t est le type.

Des espaces peuvent être appliqués dans tous les composants de nom de type, sauf dans le nom d'assembly. Dans le nom d'assembly, des espaces peuvent être appliqués avant le séparateur ",", mais les espaces situés 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ériques. Le but de cette réduction des noms est de permettre aux compilateurs de prendre en charge des types génériques portant le même nom mais ayant un nombre de paramètres de type différent, le tout dans la même portée. Par exemple, la réflexion retourne les noms tronqués Tuple`1 et Tuple`2 à partir des méthodes génériques Tuple(Of T) et Tuple(Of T0, T1) en Visual Basic, ou Tuple<T> et Tuple<T0, T1> en Visual C#.

Pour les types génériques, la liste des arguments de type est entre crochets et les arguments de type sont séparés par des virgules. Par exemple, un Dictionary<TKey, TValue> générique possède deux paramètres de type. Un Dictionary<TKey, TValue> de type MyType avec des 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, mettez entre crochets le type qualifié d'assembly. Sinon, les virgules qui séparent les parties du nom qualifié d'assembly sont interprétées comme si elles délimitaient des arguments de type supplémentaires. Par exemple, un Dictionary<TKey, TValue> de type MyType issu de MyAssembly.dll, avec des clés de type String, peut être spécifié comme suit :

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

Remarque
Un type qualifié par un assembly peut être placé entre crochets uniquement lorsqu'il apparaît dans une liste de paramètre de type. Les règles de recherche d'assemblys de types qualifiés et non qualifiés dans des listes de paramètres de types sont les mêmes que les règles pour les types non génériques qualifiés et non qualifiés.

Les types nullables sont des types génériques particuliers. Par exemple, un Int32 nullable est représenté par la chaîne "System.Nullable`1[System.Int32]".

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

Le tableau suivant indique la syntaxe à utiliser avec GetType pour divers types.

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

Imports System
Namespace MyTypeNameSpace
    Class MyClass1
        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)
                ' 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(e.Message.ToString())
            Catch e As Exception
                Console.WriteLine(e.Message.ToString())
            End Try
        End Sub 'Main
    End Class 'MyClass1
End Namespace 'MyTypeNameSpace

using System;
namespace MyTypeNameSpace
{
    class MyClass
    {
        public static void Main(string[] arg)
        {
            try
            {
                // Get the type of a specified class.
                Type myType1 = Type.GetType("System.Int32");
                Console.WriteLine("The full name is {0}.", myType1.FullName);
                // 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(e.Message);
            }
            catch(Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

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}.", myType1->FullName );

      // 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( e->Message );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( e->Message );
   }

}

.NET Framework

.NET Framework Client Profile

Windows 7, Windows Vista SP1 ou ultérieur, Windows XP SP3, Windows XP SP2 Édition x64, Windows Server 2008 (installation minimale non prise en charge), Windows Server 2008 R2 (installation minimale prise en charge avec SP1 ou version ultérieure), Windows Server 2003 SP2

Référence

Autres ressources