Type, classe

Type est la racine de la fonctionnalité System.Reflection et représente le principal moyen d'accéder aux métadonnées. Utilisez les membres de Type pour obtenir les informations concernant une déclaration de type, tel que les constructeurs, méthodes, champs, propriétés et événements d'une classe, ainsi que le module et l'assembly dans lesquels la classe est déployée.

L'opérateur C# typeof (opérateur GetType en Visual Basic, opérateur typeid en Visual C++) retourne un objet Type.

Un objet Type qui représente un type est unique ; en d'autres termes, deux références d'objet Type font référence au même objet si et seulement s'ils représentent le même type. Cela permet de comparer des objets Type à l'aide de l'égalité des références.

Aucune autorisation n'est requise pour que le code puisse utiliser la réflexion pour obtenir des informations à propos des types et de leurs membres, indépendamment de leurs niveaux d'accès. Aucune autorisation n'est requise pour que le code puisse utiliser la réflexion pour accéder aux membres publics ou à d'autres membres dont les niveaux d'accès les rendraient visibles pendant la compilation normale. Toutefois, pour que votre code utilise la réflexion pour accéder à des membres qui seraient normalement inaccessibles, tels que les méthodes privées ou internes ou les champs protégés d'un type dont votre classe n'hérite pas, votre code doit avoir ReflectionPermission. Consultez Considérations sur la sécurité de la réflexion.

Type est une classe de base abstraite qui permet des implémentations multiples. Le système fournira toujours la classe dérivée RuntimeType. Dans la réflexion, toutes les classes commençant par le mot Runtime sont créées une seule fois par objet dans le système et prennent en charge les opérations de comparaison.

Remarque
Dans des scénarios multithread, ne verrouillez pas les objets Type pour synchroniser l'accès à des données static. Un autre code, sur lequel vous n'avez aucun contrôle, pourrait également verrouiller votre type de classe. Cela pourrait provoquer un interblocage. Il est préférable de synchroniser l'accès à des données statiques en verrouillant un objet static privé.

Cette classe est thread-safe ; plusieurs threads peuvent procéder à une lecture simultanée à partir d'une instance de ce type. Une instance de Type peut représenter l'un des types suivants :

• Classes

• Types valeur

• Tableaux

• Interfaces

• Pointeurs

• Énumérations

• Types génériques construits et définitions de types génériques

• Arguments et paramètres de type des types génériques construits, définitions de types génériques et définitions des méthodes génériques

Une référence à l'objet Type associé à un type peut être obtenue des différentes manières indiquées ci-dessous :

• La méthode Object.GetType retourne un objet Type qui représente le type d'une instance.

• Les méthodes GetType statiques retournent un objet Type qui représente un type spécifié par son nom qualifié complet.

• Les méthodes Module.GetTypes, Module.GetType et Module.FindTypes retournent des objets Type qui représentent les types définis dans un module. La première méthode peut être utilisée pour obtenir un tableau d'objets Type pour tous les types publics et privés définis dans un module. (Vous pouvez obtenir une instance de Module via la méthode Assembly.GetModule ou Assembly.GetModules, ou via la propriété Type.Module.)

• L'objet System.Reflection.Assembly contient plusieurs méthodes pour extraire les classes définies dans un assembly, notamment Assembly.GetType, Assembly.GetTypeset Assembly.GetExportedTypes.

• La méthode FindInterfaces retourne une liste filtrée de types interface pris en charge par un type.

• La méthode GetElementType retourne un objet Type qui représente l'élément.

• Les méthodes GetInterfaces et GetInterface retournent des objets Type représentant les types interface pris en charge par un type.

• La méthode GetTypeArray retourne un tableau d'objets Type représentant les types spécifiés par un ensemble arbitraire d'objets. Les objets sont spécifiés avec un tableau de type Object.

• Les méthodes GetTypeFromProgID et GetTypeFromCLSID sont fournies pour l'interopérabilité COM. Elles retournent un objet Type qui représente le type spécifié par ProgID ou CLSID.

• La méthode GetTypeFromHandle est fournie pour l'interopérabilité. Elle retourne un objet Type qui représente le type spécifié par un handle de classe.

• L'opérateur typeof C#, l'opérateur typeid C++ et l'opérateur GetType Visual Basic obtiennent l'objet Type d'un type.

• La méthode MakeGenericType retourne un objet Type qui représente un type générique construit, lequel est un type construit ouvert si sa propriété ContainsGenericParameters retourne true ; sinon, c'est un type construit fermé. Un type générique peut être instancié uniquement s'il est fermé.

• Les méthodes MakeArrayType, MakePointerType et MakeByRefType retournent les objets Type qui représentent, respectivement, un tableau d'un type spécifié, un pointeur vers un type spécifié et le type d'un paramètre de référence (ref en C#, ByRef en Visual Basic).

Remarque
Une classe dérivée peut accéder à des membres protégés des classes de base du code appelant. L'accès est également autorisé aux membres d'assembly de l'assembly du code appelant. La règle est la suivante : si vous êtes autorisé à accéder à du code à liaison anticipée, vous êtes également autorisé à accéder à du code à liaison tardive.

Remarque
Les interfaces qui développent d'autres interfaces n'héritent pas des méthodes définies dans les interfaces étendues.

Lorsque vous héritez de Type, vous devez substituer les membres suivants : GUID, InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]), Module, Assembly, TypeHandle, FullName, Namespace, AssemblyQualifiedName, BaseType, GetConstructorImpl, GetConstructors(BindingFlags), GetMethodImpl, GetMethods(BindingFlags), GetField(String, BindingFlags), GetFields(BindingFlags), GetInterface(String, Boolean), GetInterfaces(), GetEvent(String, BindingFlags), GetEvents(BindingFlags), GetPropertyImpl, GetProperties(BindingFlags), GetNestedType(String, BindingFlags), GetNestedTypes(BindingFlags), GetAttributeFlagsImpl, IsArrayImpl, IsByRefImpl, IsPointerImpl, IsPrimitiveImpl, IsCOMObjectImpl, GetElementType(), HasElementTypeImpl, UnderlyingSystemType, MemberInfo.Name, MemberInfo.IsDefined, MemberInfo.GetCustomAttributes(Boolean) et GetCustomAttributes.

L'exemple de code suivant présente quelques fonctionnalités représentatives de Type. L'opérateur C# typeof (opérateur GetType en Visual Basic, opérateur typeid en Visual C++) permet d'obtenir un objet Type représentant String. À partir de cet objet Type, la méthode GetMethod permet d'obtenir un MethodInfo représentant la surcharge de Substring qui prend un emplacement de départ et une longueur.

Pour identifier la signature de surcharge, l'exemple de code crée un tableau temporaire contenant deux objets Type qui représentent int (Integer en Visual Basic).

Remarque
Pour être précis, le tableau contient deux références à l'instance de Type qui représente int dans le domaine d'application actuel. Pour tout type, il y a une seule instance de Type par domaine d'application.

L'exemple de code utilise MethodInfo pour appeler la méthode Substring sur la chaîne "Hello, World!", et affiche le résultat.

using System;
using System.Reflection;

class Example
{
    static void Main()
    {
        Type t = typeof(String);

        MethodInfo substr = t.GetMethod("Substring", 
            new Type[] { typeof(int), typeof(int) });

        Object result = 
            substr.Invoke("Hello, World!", new Object[] { 7, 5 });
        Console.WriteLine("{0} returned \"{1}\".", substr, result);
    }
}

/* This code example produces the following output:

System.String Substring(Int32, Int32) returned "World".
 */

.NET Framework

.NET Framework Client Profile

Bibliothèque de classes portable

.NET pour les applications du Windows Store

Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Ce type est thread-safe.

Référence

Autres ressources