Réflexion
Les classes de l'espace de noms System.Reflection, ainsi que System.Type, vous permettent d'obtenir des informations à propos des assemblys chargés et des types définis dans ceux-ci, tels que les classes, les interfaces et les types valeur. Vous pouvez également utiliser la réflexion pour créer des instances de type au moment de l'exécution, les appeler et y accéder. Pour accéder à des rubriques relatives à des aspects spécifiques de la réflexion, consultez Rubriques connexes à la fin de cette vue d'ensemble.
Le chargeur du Common Language Runtime gère des domaines d'application, qui constituent des limites définies autour d'objets qui ont la même portée d'application. Cette gestion inclut le chargement de chaque assembly dans le domaine d'application approprié et le contrôle de la disposition en mémoire de la hiérarchie de types dans chaque assembly.
Les assemblys contiennent des modules, les modules contiennent des types, et les types contiennent des membres. La réflexion fournit des objets qui encapsulent les assemblys, les modules et les types. Vous pouvez utiliser la réflexion pour créer dynamiquement une instance d'un type, lier le type à un objet existant ou l'obtenir à partir d'un objet existant. Vous pouvez ensuite appeler les méthodes de ce type ou accéder à ses champs et propriétés. Les principaux usages de la réflexion sont les suivants :
Utilisez Assembly pour définir et charger des assemblys, charger les modules répertoriés dans le manifeste d'assembly, et localiser un type à partir de cet assembly pour en créer une instance.
Utilisez Module pour découvrir certaines informations comme l'assembly qui contient le module et les classes présentes dans ce module. Vous pouvez également obtenir toutes les méthodes globales ou d'autres méthodes non globales spécifiques, définies sur le module.
Utilisez ConstructorInfo pour découvrir des informations telles que le nom, les paramètres, les modificateurs d'accès (tels que public ou private) et les détails d'implémentation (tels que abstract ou virtual) d'un constructeur. Utilisez la méthode GetConstructors ou GetConstructor d'un Type pour appeler un constructeur spécifique.
Utilisez MethodInfo pour découvrir des informations telles que le nom, le type de retour, les paramètres, les modificateurs d'accès (tels que public ou private) et les détails d'implémentation (tels que abstract ou virtual) d'une méthode. Utilisez la méthode GetMethods ou GetMethod d'un Type pour appeler une méthode spécifique.
Utilisez FieldInfo pour découvrir des informations telles que le nom, les modificateurs d'accès (tels que public ou private) et les détails d'implémentation (tels que static) d'un champ, et pour obtenir ou définir des valeurs de champ.
Utilisez EventInfo pour découvrir des informations telles que le nom, le type de données du gestionnaire d'événements, les attributs personnalisés, le type déclarant et le type réfléchi d'un événement, ainsi que pour ajouter ou supprimer des gestionnaires d'événements.
Utilisez PropertyInfo pour découvrir des informations telles que le nom, le type de données, le type déclarant, le type réfléchi et l'état (lecture seule ou écriture) d'une propriété, ainsi que pour obtenir ou définir des valeurs de propriété.
Utilisez ParameterInfo pour découvrir des informations telles que le nom d'un paramètre, le type de données, la définition (paramètre d'entrée ou de sortie), ainsi que la position du paramètre dans une signature de méthode.
Utilisez CustomAttributeData pour découvrir des informations à propos des attributs personnalisés lorsque vous travaillez dans le contexte de réflexion uniquement d'un domaine d'application. CustomAttributeData vous permet d'examiner les attributs sans en créer des instances.
Les classes de l'espace de noms System.Reflection.Emit fournissent un formulaire spécialisé de réflexion qui vous permet de générer des types au moment de l'exécution.
Les réflexions peuvent également servir à créer des applications appelées explorateurs de types, qui permettent aux utilisateurs de sélectionner des types et d'afficher les informations associées.
D'autres utilisations sont encore possibles pour la réflexion. Les compilateurs de langages tels que JScript utilisent la réflexion pour construire des tables de symboles. Les classes de l'espace de noms System.Runtime.Serialization utilisent la réflexion pour accéder aux données et déterminer les champs à rendre persistants. Les classes de l'espace de noms System.Runtime.Remoting utilisent indirectement la réflexion via la sérialisation.
Rubriques connexes
Titre |
Description |
|---|---|
Décrit les types internes, tels que RuntimeType, qui héritent des classes abstraites dans l'espace de noms System.Reflection et fournissent la majeure partie de leur implémentation. |
|
Décrit la classe Type et fournit des exemples de code illustrant l'utilisation de Type avec plusieurs classes de réflexion pour obtenir des informations sur les constructeurs, méthodes, champs, propriétés et événements. |
|
Explique comment la réflexion gère les paramètres et arguments de type des types et méthodes génériques. |
|
Fournit un tableau illustrant le modèle d'affectation de noms aux méthodes et l'utilisation des classes de réflexion les plus fréquentes, notamment les classes Module, Type et MemberInfo. |
|
Décrit les règles qui déterminent la limite d'utilisation de la réflexion pour la découverte des informations de type et l'accès aux types. |
|
Décrit l'interface de liaison personnalisée de réflexion prenant en charge la liaison tardive. |
|
Comment : charger des assemblys dans le contexte de réflexion uniquement |
Décrit le contexte de chargement de réflexion uniquement. Indique comment charger un assembly, tester le contexte et examiner des attributs appliqués à un assembly dans le contexte de réflexion uniquement. |
Montre comment utiliser la réflexion pour accéder aux membres par défaut d'une classe. |
|
Montre comment utiliser la réflexion pour accéder aux arguments dotés de valeurs par défaut, et comment appeler les méthodes comportant des arguments dotés de valeurs par défaut. |
|
Montre comment utiliser la réflexion pour déterminer l'existence et les valeurs des attributs. |
|
Décrit le format des noms de types qualifiés complets sous la forme Backus-Naur (BNF), et la syntaxe requise pour spécifier les caractères spéciaux, les noms d'assemblys, les pointeurs, les références et les tableaux. |
|
Explique où trouver des informations sur l'utilisation de la réflexion non managée pour l'examen de métadonnées. |
|
Explique comment créer un délégué pour une méthode et connecter le délégué à un événement. Explique comment créer une méthode de gestion d'événements au moment de l'exécution à l'aide de DynamicMethod. |
|
Explique comment générer des assemblys et méthodes dynamiques. |
Référence
Retour au début