Type Classe

Définition

Représente les déclarations de types : types classe, types interface, types tableau, types valeur, types énumération, paramètres de type, définitions de type générique et types génériques construits ouverts ou fermés.

public ref class Type abstract
public ref class Type abstract : System::Reflection::MemberInfo, System::Reflection::IReflect
public ref class Type abstract : System::Reflection::MemberInfo, System::Reflection::IReflect, System::Runtime::InteropServices::_Type
public abstract class Type
public abstract class Type : System.Reflection.MemberInfo, System.Reflection.IReflect
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Serializable]
public abstract class Type : System.Reflection.MemberInfo, System.Reflection.IReflect, System.Runtime.InteropServices._Type
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Type : System.Reflection.MemberInfo, System.Reflection.IReflect, System.Runtime.InteropServices._Type
type Type = class
type Type = class
    inherit MemberInfo
    interface IReflect
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Serializable>]
type Type = class
    inherit MemberInfo
    interface _Type
    interface IReflect
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Type = class
    inherit MemberInfo
    interface _Type
    interface IReflect
Public MustInherit Class Type
Public MustInherit Class Type
Inherits MemberInfo
Implements IReflect
Public MustInherit Class Type
Inherits MemberInfo
Implements _Type, IReflect
Héritage
Type
Héritage
Dérivé
Attributs
Implémente

Exemples

L’exemple suivant montre quelques fonctionnalités représentatives de Type. L’opérateur C# typeof (GetTypeopérateur dans Visual Basic) est utilisé pour obtenir un Type objet représentant String. À partir de cet Type objet, la GetMethod méthode est utilisée pour obtenir une MethodInfo surcharge représentant la String.Substring surcharge 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 Type objets représentant int (Integerdans Visual Basic).

Notes

Pour être précis, le tableau contient deux références à l’instance qui Type représente int dans le domaine d’application actuel. Pour n’importe quel type, il n’existe qu’une seule instance par Type domaine d’application.

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

#using <System.dll>

using namespace System;
using namespace System::Reflection;

void main()
{
    // Get a Type object representing the System.String type.
    Type^ t = String::typeid;

    MethodInfo^ substr = t->GetMethod("Substring", 
        gcnew array<Type^> { int::typeid, int::typeid });

    Object^ result = 
        substr->Invoke("Hello, World!", gcnew array<Object^> { 7, 5 });
    Console::WriteLine("{0} returned \"{1}\".", substr, result);
}

/* This code example produces the following output:

System.String Substring(Int32, Int32) returned "World".
 */
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".
 */
open System

let t = typeof<String>

let substr = t.GetMethod("Substring", [| typeof<int>; typeof<int> |])

let result = substr.Invoke("Hello, World!", [| 7; 5 |])
printfn $"{substr} returned \"{result}\"."

(* This code example produces the following output:

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

Module Example
    
    Sub Main() 

        Dim t As Type = GetType(String)
        
        Dim substr As MethodInfo = t.GetMethod("Substring", _
            New Type() { GetType(Integer), GetType(Integer) })
        
        Dim result As Object = _ 
            substr.Invoke("Hello, World!", New Object() { 7, 5 })
        Console.WriteLine("{0} returned ""{1}"".", substr, result)
    
    End Sub 
End Module

' This code example produces the following output:
'
'System.String Substring(Int32, Int32) returned "World".

Remarques

Type est la racine de la System.Reflection fonctionnalité et constitue le moyen principal d’accéder aux métadonnées. Utilisez les membres d’obtenir Type des informations sur une déclaration de type, sur les membres d’un type (tels que les constructeurs, les méthodes, les champs, les propriétés et les événements d’une classe), ainsi que le module et l’assembly dans lequel la classe est déployée.

Aucune autorisation n’est requise pour que le code utilise la réflexion pour obtenir des informations sur les types et leurs membres, quel que soit leur niveau d’accès. Aucune autorisation n’est requise pour que le code utilise la réflexion pour accéder aux membres publics, ou d’autres membres dont les niveaux d’accès les rendent visibles pendant la compilation normale. Toutefois, pour que votre code utilise la réflexion pour accéder aux 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 relatives à la sécurité pour la réflexion.

Type est une classe de base abstraite qui autorise plusieurs implémentations. Le système fournit toujours la classe RuntimeTypedérivée. En réflexion, toutes les classes commençant par le mot Runtime ne sont créées qu’une seule fois par objet dans le système et prennent en charge les opérations de comparaison.

Notes

Dans les scénarios multithreading, ne verrouillez Type pas les objets pour synchroniser l’accès aux static données. D’autres codes, sur lesquels vous n’avez aucun contrôle, peuvent également verrouiller votre type de classe. Cela peut entraîner un interblocage. Au lieu de cela, synchronisez l’accès aux données statiques en verrouillant un objet privé static .

Notes

Une classe dérivée peut accéder aux membres protégés des classes de base du code appelant. En outre, l’accès est autorisé aux membres de l’assembly du code appelant. En règle générale, si vous êtes autorisé à accéder au code à liaison anticipée, vous êtes également autorisé à accéder dans le code lié tardivement.

Notes

Les interfaces qui étendent d’autres interfaces n’héritent pas des méthodes définies dans les interfaces étendues.

Dans cette section :

Quels types un objet Type représente-t-il ?
Récupération d’un objet Type
Comparaison des objets de type pour l’égalité

Quels types un objet Type représente-t-il ?

Cette classe est thread-safe ; plusieurs threads peuvent lire simultanément à partir d’une instance de ce type. Une instance de la Type classe peut représenter l’un des types suivants :

  • Classes

  • Types de valeur

  • Tableaux

  • Interfaces

  • Énumérations

  • Délégués

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

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

Récupération d’un objet Type

L’objet Type associé à un type particulier peut être obtenu de la manière suivante :

  • La méthode d’instance Object.GetType retourne un Type objet qui représente le type d’une instance. Étant donné que tous les types managés dérivent de Object, la GetType méthode peut être appelée sur une instance de n’importe quel type.

    L’exemple suivant appelle la Object.GetType méthode pour déterminer le type d’exécution de chaque objet dans un tableau d’objets.

    using namespace System;
    
    void main()
    {
       array<Object^>^ values = { "word", true, 120, 136.34 };
       for each (Object^ value in values)
          Console::WriteLine("{0} - type {1}", value, 
                            value->GetType()->Name);
    }
    // The example displays the following output:
    //       word - type String
    //       True - type Boolean
    //       120 - type Int32
    //       136.34 - type Double
    
    object[] values = { "word", true, 120, 136.34, 'a' };
    foreach (var value in values)
       Console.WriteLine("{0} - type {1}", value, 
                         value.GetType().Name);
    
    // The example displays the following output:
    //       word - type String
    //       True - type Boolean
    //       120 - type Int32
    //       136.34 - type Double
    //       a - type Char
    
    let values: obj[] = [| "word"; true; 120; 136.34; 'a' |]
    for value in values do
       printfn $"{value} - type {value.GetType().Name}"
    
    // The example displays the following output:
    //       word - type String
    //       True - type Boolean
    //       120 - type Int32
    //       136.34 - type Double
    //       a - type Char
    
    Module Example
       Public Sub Main()
          Dim values() As Object = { "word", True, 120, 136.34, "a"c }
          For Each value In values
             Console.WriteLine("{0} - type {1}", value, 
                               value.GetType().Name)
          Next
       End Sub
    End Module
    ' The example displays the following output:
    '       word - type String
    '       True - type Boolean
    '       120 - type Int32
    '       136.34 - type Double
    '       a - type Char
    
  • Les méthodes statiques Type.GetType retournent un Type objet qui représente un type spécifié par son nom complet.

  • Les Module.GetTypesobjets , Module.GetTypeet Module.FindTypes méthodes retournent Type des objets 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 du ou de Module la Assembly.GetModules Assembly.GetModule méthode ou de la Type.Module propriété.)

  • L’objet System.Reflection.Assembly contient un certain nombre de méthodes pour récupérer les classes définies dans un assembly, y compris Assembly.GetType, Assembly.GetTypeset Assembly.GetExportedTypes.

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

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

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

  • La GetTypeArray méthode 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 et GetTypeFromCLSID les GetTypeFromProgID méthodes sont fournies pour l’interopérabilité COM. Ils retournent un Type objet qui représente le type spécifié par un ProgID ou CLSID.

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

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

  • La MakeGenericType méthode retourne un Type objet représentant un type générique construit, qui est un type construit ouvert si sa ContainsGenericParameters propriété retourne true, et un type construit fermé dans le cas contraire. Un type générique ne peut être instancié que s’il est fermé.

  • Les MakeArrayTypeméthodes et les MakeByRefType objets MakePointerTyperetournent Type des objets 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 référence (ref en C#, 'byref' en F#, ByRef dans Visual Basic).

Comparaison des objets de type pour l’égalité

Un Type objet qui représente un type est unique ; autrement dit, deux Type références d’objet 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 à l’aide de l’égalité de Type référence. L’exemple suivant compare les Type objets qui représentent un certain nombre de valeurs entières pour déterminer s’ils sont du même type.

using namespace System;

void main()
{
   Int64 number1 = 1635429;
   Int32 number2 = 16203;
   double number3 = 1639.41;
   Int64 number4 = 193685412;
   
   // Get the type of number1.
   Type^ t = number1.GetType();
   
   // Compare types of all objects with number1.
   Console::WriteLine("Type of number1 and number2 are equal: {0}",
                      Object::ReferenceEquals(t, number2.GetType()));
   Console::WriteLine("Type of number1 and number3 are equal: {0}",
                      Object::ReferenceEquals(t, number3.GetType()));
   Console::WriteLine("Type of number1 and number4 are equal: {0}",
                      Object::ReferenceEquals(t, number4.GetType()));
}
// The example displays the following output:
//       Type of number1 and number2 are equal: False
//       Type of number1 and number3 are equal: False
//       Type of number1 and number4 are equal: True
long number1 = 1635429;
int number2 = 16203;
double number3 = 1639.41;
long number4 = 193685412;

// Get the type of number1.
Type t = number1.GetType();

// Compare types of all objects with number1.
Console.WriteLine("Type of number1 and number2 are equal: {0}",
                  Object.ReferenceEquals(t, number2.GetType()));
Console.WriteLine("Type of number1 and number3 are equal: {0}",
                  Object.ReferenceEquals(t, number3.GetType()));
Console.WriteLine("Type of number1 and number4 are equal: {0}",
                  Object.ReferenceEquals(t, number4.GetType()));

// The example displays the following output:
//       Type of number1 and number2 are equal: False
//       Type of number1 and number3 are equal: False
//       Type of number1 and number4 are equal: True
let number1 = 1635429L
let number2 = 16203
let number3 = 1639.41
let number4 = 193685412L

// Get the type of number1.
let t = number1.GetType()

// Compare types of all objects with number1.
printfn $"Type of number1 and number2 are equal: {Object.ReferenceEquals(t, number2.GetType())}"
printfn $"Type of number1 and number3 are equal: {Object.ReferenceEquals(t, number3.GetType())}"
printfn $"Type of number1 and number4 are equal: {Object.ReferenceEquals(t, number4.GetType())}"

// The example displays the following output:
//       Type of number1 and number2 are equal: False
//       Type of number1 and number3 are equal: False
//       Type of number1 and number4 are equal: True
Module Example
   Public Sub Main()
      Dim number1 As Long = 1635429
      Dim number2 As Integer = 16203
      Dim number3 As Double = 1639.41
      Dim number4 As Long = 193685412
      
      ' Get the type of number1.
      Dim t As Type = number1.GetType()
      
      ' Compare types of all objects with number1.
      Console.WriteLine("Type of number1 and number2 are equal: {0}",
                        Object.ReferenceEquals(t, number2.GetType()))
      Console.WriteLine("Type of number1 and number3 are equal: {0}",
                        Object.ReferenceEquals(t, number3.GetType()))
      Console.WriteLine("Type of number1 and number4 are equal: {0}",
                        Object.ReferenceEquals(t, number4.GetType()))
   End Sub
End Module
' The example displays the following output:
'       Type of number1 and number2 are equal: False
'       Type of number1 and number3 are equal: False
'       Type of number1 and number4 are equal: True

Notes pour les responsables de l’implémentation

Lorsque vous héritez de Type, vous devez substituer les membres suivants :

Constructeurs

Type()

Initialise une nouvelle instance de la classe Type.

Champs

Delimiter

Sépare les noms dans l'espace de noms de Type. Ce champ est en lecture seule.

EmptyTypes

Représente un tableau vide du type Type. Ce champ est en lecture seule.

FilterAttribute

Représente le filtre de membres utilisé avec les attributs. Ce champ est en lecture seule.

FilterName

Représente le filtre de membres, avec respect de la casse, utilisé sur les noms. Ce champ est en lecture seule.

FilterNameIgnoreCase

Représente le filtre de membres, sans respect de la casse, utilisé sur les noms. Ce champ est en lecture seule.

Missing

Représente une valeur manquante dans les informations Type. Ce champ est en lecture seule.

Propriétés

Assembly

Obtient le Assembly dans lequel le type est déclaré. Pour les types génériques, obtient le Assembly dans lequel le type générique est défini.

AssemblyQualifiedName

Obtient le nom qualifié d'assembly du type, y compris le nom de l'assembly à partir duquel l'objet Type a été chargé.

Attributes

Obtient les attributs associés à Type.

BaseType

Obtient le type dont le Type actuel hérite directement.

ContainsGenericParameters

Obtient une valeur indiquant si l'objet Type actuel a des paramètres de type qui n'ont pas été remplacés par des types spécifiques.

CustomAttributes

Obtient une collection qui contient les attributs personnalisés de ce membre.

(Hérité de MemberInfo)
DeclaringMethod

Obtient un MethodBase représentant la méthode de déclaration, si le Type actuel représente un paramètre de type d’une méthode générique.

DeclaringType

Obtient le type qui déclare le type imbriqué ou paramètre de type générique actuel.

DefaultBinder

Obtient une référence au binder par défaut, qui implémente les règles internes pour la sélection des membres appropriés appelés par InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]).

FullName

Obtient le nom qualifié complet du type, y compris son espace de noms, mais pas l'assembly.

GenericParameterAttributes

Obtient une combinaison d'indicateurs GenericParameterAttributes qui décrivent la covariance et des contraintes spéciales du paramètre de type générique actuel.

GenericParameterPosition

Obtient la position du paramètre de type dans la liste des paramètres de type du type générique ou de la méthode qui a déclaré le paramètre, quand l'objet Type représente un paramètre de type d'un type générique ou une méthode générique.

GenericTypeArguments

Obtient un tableau des arguments de type générique pour ce type.

GUID

Obtient le GUID associé à Type.

HasElementType

Obtient une valeur indiquant si le Type actuel englobe ou se réfère à un autre type, c'est-à-dire si le Type actuel est un tableau ou un pointeur ou encore s'il est passé par référence.

IsAbstract

Obtient une valeur indiquant si le Type est abstrait et doit être substitué.

IsAnsiClass

Obtient une valeur indiquant si l'attribut de format de chaîne AnsiClass est sélectionné pour Type.

IsArray

Obtient une valeur qui indique si le type est un tableau.

IsAutoClass

Obtient une valeur indiquant si l'attribut de format de chaîne AutoClass est sélectionné pour Type.

IsAutoLayout

Obtient une valeur qui indique si les champs du type actuel sont placés automatiquement par le Common Language Runtime.

IsByRef

Obtient une valeur indiquant si Type est passé par référence.

IsByRefLike

Obtient une valeur qui indique si le type est une structure de type byref.

IsClass

Obtient une valeur indiquant si le Type est une classe ou un délégué, c'est-à-dire ni un type valeur ni une interface.

IsCollectible

Obtient une valeur qui indique si cet objet MemberInfo fait partie d’un assembly contenu dans un AssemblyLoadContext pouvant être collecté.

(Hérité de MemberInfo)
IsCOMObject

Obtient une valeur indiquant si Type est un objet COM.

IsConstructedGenericType

Obtient une valeur qui indique si cet objet représente un type générique construit. Vous pouvez créer des instances d'un type générique construit.

IsContextful

Obtient une valeur indiquant si Type peut être hébergé dans un contexte.

IsEnum

Obtient une valeur indiquant si le Type actuel représente une énumération.

IsExplicitLayout

Obtient une valeur qui indique si les champs du type actuel sont placés aux offsets explicitement spécifiés.

IsGenericMethodParameter

Obtient une valeur indiquant si le Type actuel représente un paramètre de type dans la définition d’une méthode générique.

IsGenericParameter

Obtient une valeur indiquant si le Type actuel représente un paramètre de type d'une définition de type ou de méthode générique.

IsGenericType

Obtient une valeur indiquant si le type actuel est un type générique.

IsGenericTypeDefinition

Obtient une valeur qui indique si le Type actuel représente une définition de type générique, à partir de laquelle d'autres types génériques peuvent être construits.

IsGenericTypeParameter

Obtient une valeur indiquant si le Type actuel représente un paramètre de type dans la définition d’un type générique.

IsImport

Obtient une valeur qui indique si le Type a un attribut appliqué ComImportAttribute, indiquant qu'il a été importé d'une bibliothèque de types COM.

IsInterface

Obtient une valeur indiquant si le Type est une interface, c'est-à-dire ni une classe ni un type valeur.

IsLayoutSequential

Obtient une valeur qui indique si les champs du type actuel sont placés séquentiellement, en respectant l'ordre dans lequel ils ont été définis ou émis aux métadonnées.

IsMarshalByRef

Obtient une valeur indiquant si Type est marshalé par référence.

IsNested

Obtient une valeur indiquant si l'objet Type actuel représente un type dont la définition est imbriquée dans la définition d'un autre type.

IsNestedAssembly

Obtient une valeur indiquant si le Type est imbriqué et visible uniquement dans son propre assembly.

IsNestedFamANDAssem

Obtient une valeur indiquant si le Type est imbriqué et visible uniquement par rapport aux classes qui appartiennent à la fois à sa propre famille et à son propre assembly.

IsNestedFamily

Obtient une valeur indiquant si le Type est imbriqué et visible uniquement dans sa propre famille.

IsNestedFamORAssem

Obtient une valeur indiquant si le Type est imbriqué et visible uniquement par rapport aux classes qui appartiennent à sa propre famille ou à son propre assembly.

IsNestedPrivate

Obtient une valeur indiquant si le Type est imbriqué et déclaré privé.

IsNestedPublic

Obtient une valeur indiquant si une classe est imbriquée et déclarée publique.

IsNotPublic

Obtient une valeur indiquant si Type n'est pas déclaré public.

IsPointer

Obtient une valeur indiquant si Type est un pointeur.

IsPrimitive

Obtient une valeur indiquant si le Type est l'un des types primitifs.

IsPublic

Obtient une valeur indiquant si Type est déclaré public.

IsSealed

Obtient une valeur indiquant si Type est déclaré sealed.

IsSecurityCritical

Obtient une valeur qui indique si le type actuel est critique de sécurité (security-critical) ou critique sécurisé (security-safe-critical) au niveau de confiance actuel et peut donc exécuter des opérations critiques.

IsSecuritySafeCritical

Obtient une valeur qui indique si le type actuel est critique sécurisé au niveau de confiance actuel, autrement dit s'il peut exécuter des opérations critiques et être accessible par du code transparent.

IsSecurityTransparent

Obtient une valeur qui indique si le type actuel est transparent au niveau de confiance actuel et ne peut donc pas exécuter d'opérations critiques.

IsSerializable

Obtient une valeur indiquant si le Type est sérialisable.

IsSignatureType

Obtient une valeur qui indique si le type est un type de signature.

IsSpecialName

Obtient une valeur indiquant si le type a un nom qui nécessite un traitement spécial.

IsSZArray

Obtient une valeur qui indique si le type est un type tableau qui peut représenter uniquement un tableau unidimensionnel avec une limite inférieure à zéro.

IsTypeDefinition

Obtient une valeur qui indique si le type est une définition de type.

IsUnicodeClass

Obtient une valeur indiquant si l'attribut de format de chaîne UnicodeClass est sélectionné pour Type.

IsValueType

Obtient une valeur indiquant si le Type est un type valeur.

IsVariableBoundArray

Obtient une valeur qui indique si le type est un type tableau qui peut représenter uniquement un tableau multidimensionnel ou un tableau avec une limite inférieure arbitraire.

IsVisible

Obtient une valeur qui indique si Type est accessible par code à l'extérieur de l'assembly.

MemberType

Obtient une valeur MemberTypes qui indique que ce membre est un type ou un type imbriqué.

MetadataToken

Obtient une valeur qui identifie un élément de métadonnées.

(Hérité de MemberInfo)
Module

Obtient le module (la DLL) dans lequel le Type actuel est défini.

Name

En cas de substitution dans une classe dérivée, obtient le nom du type actuel.

Name

Obtient le nom du membre actuel.

(Hérité de MemberInfo)
Namespace

Obtient l'espace de noms de l'objet Type.

ReflectedType

Obtient l'objet de la classe qui a été utilisé pour obtenir ce membre.

StructLayoutAttribute

Obtient un StructLayoutAttribute qui décrit la disposition du type actuel.

TypeHandle

Obtient le handle pour le Type actuel.

TypeInitializer

Obtient l'initialiseur du type.

UnderlyingSystemType

Indique le type fourni par le Common Language Runtime qui représente ce type.

Méthodes

Equals(Object)

Détermine si le type de système sous-jacent de l’objet Type actuel est identique au type de système sous-jacent du Object spécifié.

Equals(Type)

Détermine si le type de système sous-jacent du Type actuel est identique au type de système sous-jacent du Type spécifié.

FindInterfaces(TypeFilter, Object)

Retourne un tableau d'objets Type représentant une liste filtrée d'interfaces implémentées ou héritées par le Type actuel.

FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)

Retourne un tableau filtré d'objets MemberInfo du type du membre spécifié.

GetArrayRank()

Obtient le nombre de dimensions dans un tableau.

GetAttributeFlagsImpl()

En cas de substitution dans une classe dérivée, implémente la propriété Attributes et obtient une combinaison de bits de valeurs d’énumération qui indique les attributs qui sont associés au Type.

GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Recherche un constructeur dont les paramètres correspondent aux types d’arguments et aux modificateurs spécifiés, en utilisant les contraintes de liaison et la convention d’appel indiquées.

GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])

Recherche un constructeur dont les paramètres correspondent aux types d’arguments et modificateurs spécifiés, à l’aide des contraintes de liaison spécifiées.

GetConstructor(BindingFlags, Type[])

Recherche un constructeur dont les paramètres correspondent aux types d’arguments spécifiés, à l’aide des contraintes de liaison spécifiées.

GetConstructor(Type[])

Recherche un constructeur d'instance public dont les paramètres correspondent aux types contenus dans le tableau spécifié.

GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

En cas de substitution dans une classe dérivée, recherche un constructeur dont les paramètres correspondent aux types d’arguments et modificateurs spécifiés, à l’aide des contraintes de liaison et de la convention d’appel spécifiées.

GetConstructors()

Retourne tous les constructeurs publics définis pour le Type actuel.

GetConstructors(BindingFlags)

En cas de substitution dans une classe dérivée, recherche les constructeurs définis pour le Type actuel, à l'aide du BindingFlags spécifié.

GetCustomAttributes(Boolean)

En cas de substitution dans une classe dérivée, retourne un tableau de tous les attributs personnalisés appliqués à ce membre.

(Hérité de MemberInfo)
GetCustomAttributes(Type, Boolean)

En cas de substitution dans une classe dérivée, retourne un tableau d’attributs personnalisés appliqués à ce membre et identifiés par Type.

(Hérité de MemberInfo)
GetCustomAttributesData()

Renvoie une liste d’objets CustomAttributeData représentant des données sur les attributs qui ont été appliqués au membre cible.

(Hérité de MemberInfo)
GetDefaultMembers()

Recherche les membres définis pour le Type actuel dont le DefaultMemberAttribute est défini.

GetElementType()

En cas de substitution dans une classe dérivée, retourne le Type de l'objet englobé ou de l'objet auquel le tableau, pointeur ou type référence actuel fait référence.

GetEnumName(Object)

Retourne le nom de la constante qui a la valeur spécifiée, pour le type énumération actuel.

GetEnumNames()

Retourne les noms des membres du type énumération actuel.

GetEnumUnderlyingType()

Retourne le type sous-jacent du type énumération actuel.

GetEnumValues()

Retourne un tableau des valeurs des constantes dans le type énumération actuel.

GetEvent(String)

Retourne l'objet EventInfo représentant l'événement public spécifié.

GetEvent(String, BindingFlags)

En cas de substitution dans une classe dérivée, retourne l'objet EventInfo représentant l'événement spécifié, à l'aide des contraintes de liaison spécifiées.

GetEvents()

Retourne tous les événements publics qui sont déclarés ou hérités par le Type actuel.

GetEvents(BindingFlags)

En cas de substitution dans une classe dérivée, recherche les événements qui sont déclarés ou hérités par le Type actuel, à l’aide des contraintes de liaison spécifiées.

GetField(String)

Recherche le champ public portant le nom spécifié.

GetField(String, BindingFlags)

Recherche le champ spécifié, à l’aide des contraintes de liaison spécifiées.

GetFields()

Retourne tous les champs publics du Type actuel.

GetFields(BindingFlags)

En cas de substitution dans une classe dérivée, recherche les champs définis pour le Type actuel, à l'aide des contraintes de liaison spécifiées.

GetGenericArguments()

Retourne un tableau d’objets Type qui représentent les arguments de type d’un type générique fermé ou les paramètres de type d’une définition de type générique.

GetGenericParameterConstraints()

Retourne un tableau d'objets Type qui représentent les contraintes qui s'exercent sur le paramètre de type générique actuel.

GetGenericTypeDefinition()

Retourne un objet Type qui représente une définition de type générique à partir de laquelle le type générique actuel peut être construit.

GetHashCode()

Retourne le code de hachage de cette instance.

GetInterface(String)

Recherche l'interface avec le nom spécifié.

GetInterface(String, Boolean)

En cas de substitution dans une classe dérivée, recherche l'interface spécifiée, en indiquant s'il faut faire une recherche qui ne respecte pas la casse pour le nom de l'interface.

GetInterfaceMap(Type)

Retourne un mappage d'interface pour le type interface spécifié.

GetInterfaces()

En cas de substitution dans une classe dérivée, obtient toutes les interfaces implémentées ou héritées par le Type actuel.

GetMember(String)

Recherche les membres publics portant le nom spécifié.

GetMember(String, BindingFlags)

Recherche les membres spécifiés, à l'aide des contraintes de liaison spécifiées.

GetMember(String, MemberTypes, BindingFlags)

Recherche les membres spécifiés du type de membre spécifié, à l’aide des contraintes de liaison spécifiées.

GetMembers()

Retourne tous les membres publics du Type actuel.

GetMembers(BindingFlags)

En cas de substitution dans une classe dérivée, recherche les membres définis pour le Type actuel, à l’aide des contraintes de liaison spécifiées.

GetMemberWithSameMetadataDefinitionAs(MemberInfo)

Recherche l’élément MemberInfo actif Type qui correspond à l’élément spécifié MemberInfo.

GetMethod(String)

Recherche la méthode publique avec le nom spécifié.

GetMethod(String, BindingFlags)

Recherche la méthode spécifiée, à l'aide des contraintes de liaison spécifiées.

GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Recherche la méthode spécifiée dont les paramètres correspondent aux types d'arguments et aux modificateurs spécifiés, en utilisant les contraintes de liaison et la convention d'appel indiquées.

GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])

Recherche la méthode spécifiée dont les paramètres correspondent aux types d'arguments et modificateurs spécifiés, à l'aide des contraintes de liaison spécifiées.

GetMethod(String, BindingFlags, Type[])

Recherche la méthode spécifiée dont les paramètres correspondent aux types d’arguments spécifiés, à l’aide des contraintes de liaison spécifiées.

GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Recherche la méthode spécifiée dont les paramètres correspondent au nombre de paramètres génériques, aux types d'arguments et aux modificateurs spécifiés, en utilisant les contraintes de liaison et la convention d'appel indiquées.

GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])

Recherche la méthode spécifiée dont les paramètres correspondent au nombre de paramètres génériques, aux types d'arguments et aux modificateurs spécifiés, à l'aide des contraintes de liaison spécifiées.

GetMethod(String, Int32, Type[])

Recherche la méthode publique spécifiée dont les paramètres correspondent au nombre d’arguments génériques et aux types d’arguments spécifiés.

GetMethod(String, Int32, Type[], ParameterModifier[])

Recherche la méthode publique spécifiée dont les paramètres correspondent au nombre d’arguments génériques, aux modificateurs et aux types d’arguments spécifiés.

GetMethod(String, Type[])

Recherche la méthode publique spécifiée dont les paramètres correspondent aux types d'arguments spécifiés.

GetMethod(String, Type[], ParameterModifier[])

Recherche la méthode publique spécifiée dont les paramètres correspondent aux types d’arguments et modificateurs spécifiés.

GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

En cas de substitution dans une classe dérivée, recherche la méthode spécifiée dont les paramètres correspondent aux types d'arguments et modificateurs spécifiés, à l'aide des contraintes de liaison et de la convention d'appel spécifiées.

GetMethodImpl(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

En cas de substitution dans une classe dérivée, recherche la méthode spécifiée dont les paramètres correspondent au nombre de paramètres, aux types d'arguments et aux modificateurs spécifiés, à l'aide des contraintes de liaison et de la convention d'appel spécifiées.

GetMethods()

Retourne toutes les méthodes publiques du Type actuel.

GetMethods(BindingFlags)

En cas de substitution dans une classe dérivée, recherche les méthodes définies pour le Type actuel, à l'aide des contraintes de liaison spécifiées.

GetNestedType(String)

Recherche le type imbriqué public avec le nom spécifié.

GetNestedType(String, BindingFlags)

En cas de substitution dans une classe dérivée, recherche le type imbriqué spécifié, à l'aide des contraintes de liaison spécifiées.

GetNestedTypes()

Retourne les types publics imbriqués dans le Type actuel.

GetNestedTypes(BindingFlags)

En cas de substitution dans une classe dérivée, recherche les types imbriqués dans le Type actuel, à l'aide des contraintes de liaison spécifiées.

GetProperties()

Retourne toutes les propriétés publiques du Type actuel.

GetProperties(BindingFlags)

En cas de substitution dans une classe dérivée, recherche les propriétés du Type actuel, à l’aide des contraintes de liaison spécifiées.

GetProperty(String)

Recherche la propriété publique avec le nom spécifié.

GetProperty(String, BindingFlags)

Recherche la propriété spécifiée, à l'aide des contraintes de liaison spécifiées.

GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

Recherche la propriété spécifiée dont les paramètres correspondent aux types d’arguments et aux modificateurs spécifiés, en utilisant les contraintes de liaison indiquées.

GetProperty(String, Type)

Recherche la propriété publique à l'aide du nom et du type de retour spécifiés.

GetProperty(String, Type, Type[])

Recherche la propriété publique spécifiée dont les paramètres correspondent aux types d’arguments spécifiés.

GetProperty(String, Type, Type[], ParameterModifier[])

Recherche la propriété publique spécifiée dont les paramètres correspondent aux types d'arguments et modificateurs spécifiés.

GetProperty(String, Type[])

Recherche la propriété publique spécifiée dont les paramètres correspondent aux types d’arguments spécifiés.

GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

En cas de substitution dans une classe dérivée, recherche la propriété spécifiée dont les paramètres correspondent aux types d'arguments et modificateurs spécifiés, en utilisant les contraintes de liaison indiquées.

GetType()

Obtient le Type actuel.

GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
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.

GetTypeArray(Object[])

Obtient les types des objets dans le tableau spécifié.

GetTypeCode(Type)

Obtient le code du type sous-jacent du Type spécifié.

GetTypeCodeImpl()

Retourne le code du type sous-jacent de cette instance Type.

GetTypeFromCLSID(Guid)

Obtient le type associé à l'identificateur de classe (CLSID) spécifié.

GetTypeFromCLSID(Guid, Boolean)

Obtient le type associé à l'identificateur de classe (CLSID) spécifié, indiquant s'il faut lever une exception en cas d'erreur pendant le chargement du type.

GetTypeFromCLSID(Guid, String)

Obtient le type associé à l'identificateur de classe (CLSID) spécifié à partir du serveur défini.

GetTypeFromCLSID(Guid, String, Boolean)

Obtient le type associé à l'identificateur de classe (CLSID) spécifié à partir du serveur défini, indiquant s'il faut lever une exception en cas d'erreur pendant le chargement du type.

GetTypeFromHandle(RuntimeTypeHandle)

Obtient le type référencé par le handle de type spécifié.

GetTypeFromProgID(String)

Obtient le type associé à l'identificateur de programme (ProgID) spécifié, retournant null en cas d'erreur pendant le chargement de Type.

GetTypeFromProgID(String, Boolean)

Obtient le type associé à l'identificateur de programme (ProgID) spécifié, indiquant s'il faut lever une exception en cas d'erreur pendant le chargement du type.

GetTypeFromProgID(String, String)

Obtient le type associé à l'identificateur de programme (ProgID) spécifié à partir du serveur défini, retournant null en cas d'erreur pendant le chargement du type.

GetTypeFromProgID(String, String, Boolean)

Obtient le type associé à l'identificateur de programme (ProgID) spécifié à partir du serveur défini, indiquant s'il faut lever une exception en cas d'erreur pendant le chargement du type.

GetTypeHandle(Object)

Obtient le handle pour le Type d'un objet spécifié.

HasElementTypeImpl()

En cas de substitution dans une classe dérivée, implémente la propriété HasElementType et détermine si le Type actuel englobe ou se réfère à un autre type ; c'est-à-dire si le Type actuel est un tableau ou un pointeur ou encore s'il est passé par référence.

HasSameMetadataDefinitionAs(MemberInfo) (Hérité de MemberInfo)
InvokeMember(String, BindingFlags, Binder, Object, Object[])

Appelle le membre défini, à l'aide des contraintes de liaison spécifiées et correspondant à la liste d'arguments spécifiée.

InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)

Appelle le membre spécifié, à l'aide des contraintes de liaison spécifiées et correspondant à la liste d'arguments et à la culture spécifiées.

InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])

En cas de substitution dans une classe dérivée, appelle le membre défini, à l'aide des contraintes de liaison spécifiées et correspondant à la liste d'arguments, aux modificateurs et à la culture spécifiés.

IsArrayImpl()

En cas de substitution dans une classe dérivée, implémente la propriété IsArray et détermine si Type est un tableau.

IsAssignableFrom(Type)

Détermine si une instance d’un type spécifié c peut être affectée à une variable du type actuel.

IsAssignableTo(Type)

Détermine si un type actuel peut être affecté à une variable du type targetType spécifié.

IsByRefImpl()

En cas de substitution dans une classe dérivée, implémente la propriété IsByRef et détermine si le Type est passé par référence.

IsCOMObjectImpl()

En cas de substitution dans une classe dérivée, implémente la propriété IsCOMObject et détermine si le Type est un objet COM.

IsContextfulImpl()

Implémente la propriété IsContextful et détermine si Type peut être hébergé dans un contexte.

IsDefined(Type, Boolean)

En cas de substitution dans une classe dérivée, indique si un ou plusieurs attributs du type spécifié ou de ses types dérivés sont appliqués à ce membre.

(Hérité de MemberInfo)
IsEnumDefined(Object)

Retourne une valeur qui indique si la valeur spécifiée existe dans le type énumération actuel.

IsEquivalentTo(Type)

Détermine si deux types COM ont la même identité et prennent en charge l'équivalence de type.

IsInstanceOfType(Object)

Détermine si l'objet spécifié est une instance du Type actuel.

IsMarshalByRefImpl()

Implémente la propriété IsMarshalByRef et détermine si le Type est marshalé par référence.

IsPointerImpl()

En cas de substitution dans une classe dérivée, implémente la propriété IsPointer et détermine si le Type est un pointeur.

IsPrimitiveImpl()

En cas de substitution dans une classe dérivée, implémente la propriété IsPrimitive et détermine si Type est l'un des types primitifs.

IsSubclassOf(Type)

Détermine si le Type actuel dérive du Type spécifié.

IsValueTypeImpl()

Implémente la propriété IsValueType et détermine si le Type est un type valeur, c'est-à-dire ni une classe ni une interface.

MakeArrayType()

Retourne un objet Type qui représente un tableau unidimensionnel du type actuel, avec une limite inférieure de zéro.

MakeArrayType(Int32)

Retourne un objet Type qui représente un tableau du type actuel, avec le nombre spécifié de dimensions.

MakeByRefType()

Retourne un objet Type qui représente le type actuel quand il est passé en tant que paramètre ref (paramètre ByRef en Visual Basic).

MakeGenericMethodParameter(Int32)

Retourne un objet de type signature qui peut être passé dans le paramètre de tableau Type[] d’une méthode GetMethod pour représenter une référence de paramètre générique.

MakeGenericSignatureType(Type, Type[])

Crée un type de signature générique, qui permet aux réimplémentations tierces de réflexion de prendre entièrement en charge l’utilisation des types de signature dans l’interrogation des membres de type.

MakeGenericType(Type[])

Substitue les éléments d'un tableau de types aux paramètres de type de la définition du type générique actuel et retourne un objet Type qui représente le type construit résultant.

MakePointerType()

Retourne un objet Type qui représente un pointeur vers le type actuel.

MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
ReflectionOnlyGetType(String, Boolean, Boolean)
Obsolète.

Obtient le Type portant le nom spécifié, indiquant s'il faut effectuer une recherche respectant la casse et lever une exception si le type est introuvable. Le type est chargé dans un contexte de réflexion, et non d'exécution.

ToString()

Retourne String représentant le nom du Type actuel.

Opérateurs

Equality(Type, Type)

Indique si deux objets Type sont égaux.

Inequality(Type, Type)

Indique si deux objets Type ne sont pas égaux.

Implémentations d’interfaces explicites

_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.

(Hérité de MemberInfo)
_MemberInfo.GetType()

Obtient un objet Type représentant la classe MemberInfo.

(Hérité de MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Récupère les informations de type pour un objet, qui peuvent être utilisées ensuite pour obtenir les informations de type d'une interface.

(Hérité de MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1).

(Hérité de MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fournit l'accès aux propriétés et aux méthodes exposées par un objet.

(Hérité de MemberInfo)
_Type.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.

_Type.GetTypeInfo(UInt32, UInt32, IntPtr)

Récupère les informations de type pour un objet, qui peuvent être utilisées ensuite pour obtenir les informations de type d'une interface.

_Type.GetTypeInfoCount(UInt32)

Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1).

_Type.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fournit l'accès aux propriétés et aux méthodes exposées par un objet.

Méthodes d’extension

GetCustomAttribute(MemberInfo, Type)

Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un membre spécifié.

GetCustomAttribute(MemberInfo, Type, Boolean)

Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un membre spécifié, et inspecte éventuellement les ancêtres de ce membre.

GetCustomAttribute<T>(MemberInfo)

Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un membre spécifié.

GetCustomAttribute<T>(MemberInfo, Boolean)

Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un membre spécifié, et inspecte éventuellement les ancêtres de ce membre.

GetCustomAttributes(MemberInfo)

Récupère une collection d'attributs personnalisés qui sont appliqués à un membre spécifié.

GetCustomAttributes(MemberInfo, Boolean)

Récupère une collection d'attributs personnalisés qui sont appliqués à un membre spécifié, et inspecte éventuellement les ancêtres de ce membre.

GetCustomAttributes(MemberInfo, Type)

Extrait une collection d'attributs personnalisés d'un type spécifié qui sont appliqués à un membre spécifié.

GetCustomAttributes(MemberInfo, Type, Boolean)

Extrait une collection d'attributs personnalisés d'un type spécifié qui sont appliqués à un membre spécifié, et inspecte éventuellement les ancêtres de ce membre.

GetCustomAttributes<T>(MemberInfo)

Extrait une collection d'attributs personnalisés d'un type spécifié qui sont appliqués à un membre spécifié.

GetCustomAttributes<T>(MemberInfo, Boolean)

Extrait une collection d'attributs personnalisés d'un type spécifié qui sont appliqués à un membre spécifié, et inspecte éventuellement les ancêtres de ce membre.

IsDefined(MemberInfo, Type)

Indique si des attributs personnalisés d'un type spécifié sont appliqués à un membre spécifié.

IsDefined(MemberInfo, Type, Boolean)

Indique si les attributs personnalisés d'un type spécifié sont appliqués à un membre spécifié, et, éventuellement, appliqués à ses ancêtres.

GetTypeInfo(Type)

Retourne la représentation TypeInfo du type spécifié.

GetMetadataToken(MemberInfo)

Obtient un jeton de métadonnées pour le membre donné, s’il est disponible.

HasMetadataToken(MemberInfo)

Retourne une valeur qui indique si un jeton de métadonnées est disponible pour le membre spécifié.

GetRuntimeEvent(Type, String)

Récupère un objet qui représente l’événement spécifié.

GetRuntimeEvents(Type)

Récupère une collection qui représente tous les événements définis sur un type spécifié.

GetRuntimeField(Type, String)

Récupère un objet qui représente un champ spécifié.

GetRuntimeFields(Type)

Récupère une collection qui représente tous les événements définis sur un type spécifié.

GetRuntimeMethod(Type, String, Type[])

Récupère un objet qui représente une méthode spécifiée.

GetRuntimeMethods(Type)

Récupère une collection qui représente toutes les méthodes définies sur un type spécifié.

GetRuntimeProperties(Type)

Récupère une collection qui représente toutes les méthodes définies sur un type spécifié.

GetRuntimeProperty(Type, String)

Récupère un objet qui représente une propriété spécifiée.

GetConstructor(Type, Type[])
GetConstructors(Type)
GetConstructors(Type, BindingFlags)
GetDefaultMembers(Type)
GetEvent(Type, String)
GetEvent(Type, String, BindingFlags)
GetEvents(Type)
GetEvents(Type, BindingFlags)
GetField(Type, String)
GetField(Type, String, BindingFlags)
GetFields(Type)
GetFields(Type, BindingFlags)
GetGenericArguments(Type)
GetInterfaces(Type)
GetMember(Type, String)
GetMember(Type, String, BindingFlags)
GetMembers(Type)
GetMembers(Type, BindingFlags)
GetMethod(Type, String)
GetMethod(Type, String, BindingFlags)
GetMethod(Type, String, Type[])
GetMethods(Type)
GetMethods(Type, BindingFlags)
GetNestedType(Type, String, BindingFlags)
GetNestedTypes(Type, BindingFlags)
GetProperties(Type)
GetProperties(Type, BindingFlags)
GetProperty(Type, String)
GetProperty(Type, String, BindingFlags)
GetProperty(Type, String, Type)
GetProperty(Type, String, Type, Type[])
IsAssignableFrom(Type, Type)
IsInstanceOfType(Type, Object)

S’applique à

Cohérence de thread

Ce type est thread-safe.

Voir aussi