human
Qu'est-ce que la réflexion ? Pourquoi est-ce utile ?
* Est-il recommandé de l'utiliser dans les projets ?
* Comment l'utiliser ?
* Dans quelles situations peut-on utiliser la réflexion
gpt
La réflexion est un terme utilisé pour indiquer la capacité d'obtenir des métadonnées sur le programme lui-même compilé, en français on peut se référer à cela comme réflexion même.
Qu'est-ce que cela signifie, les métadonnées ?
Obtenir des informations sur les types de données de manière dynamique est très important pour les codes qui agissent sur des objets dont on ne connaît pas le design. C'est largement utilisé dans les bibliothèques qui traitent des objets de types qu'elles ne connaissent pas lors de leur conception.
Par exemple, ASP.NET MVC n'est possible que grâce à la réflexion. Comment pourrait-il appeler les méthodes des contrôleurs qu'il ne connaît même pas ?
Cependant, il faut dire que la réflexion n'est pas toujours rapide, il est nécessaire de vérifier les autorisations, le niveau de sécurité dans lequel le code s'exécute, entre autres. C'est pourquoi, lorsque l'on obtient un résultat quelconque à travers la réflexion, ces informations sont généralement mises en cache, c'est-à-dire sauvegardées en mémoire.
Est-ce recommandé ?
Cela dépend de l'utilisation:

* oui, c'est recommandé: pour créer des comportements dynamiques en utilisant des attributs, la seule option est la réflexion
* oui, c'est recommandé: pour appeler une méthode que l'on ne connaît pas lors de la conception du système, c'est également la seule option
* non, c'est abusif: appeler une méthode d'une classe connue au moment du design en utilisant la réflexion... c'est absurde

Il existe tellement de façons d'utiliser la réflexion que je pourrais continuer cette liste pendant longtemps. Alors, voici le conseil suivant: bon sens.
Comment l'utiliser ?
Il existe quelques vecteurs d'utilisation de la réflexion que je connais. Pour les démontrer, considérons d'abord la classe suivante:
```public class Personne
{
    public string Nom { get; set; }
}
```

* Expressions Lambda: c'est un vecteur de réflexion, car il est possible d'utiliser des expressions lambda pour accéder aux types, méthodes et autres objets réfléchis qui ont été utilisés dans l'expression. Il est couramment utilisé pour rendre fortement typée l'obtention d'objets réfléchis à partir des membres d'une classe, avant cela, il était seulement possible d'obtenir ces objets en indiquant une chaîne avec le nom de la méthode.
```Expression<Func<Personne, string>> expr = p => p.Nom;
var lambda = (LambdaExpression)expr;
var cast = lambda.Body as UnaryExpression;
var member = (cast != null ? cast.Operand : lambda.Body) as MemberExpression;
var propInfo = member.Member as PropertyInfo;
Console.WriteLine(propInfo.Name); // "Nom"
```
* typeof(Type): c'est l'une des façons les plus courantes d'obtenir des informations réfléchies sur le système. Elle sert à obtenir des informations sur le type indiqué directement.
```var type = typeof(Personne);
Console.WriteLine(type.Name); // "Personne"
```
* obj.GetType(): aussi courant que ```typeof```, mais au lieu de se référer directement à un type, il se réfère au type de l'objet en question: mais il y a un détail, ce n'est pas le type déclaré de la variable, mais plutôt le type de l'objet lui-même.
```var p = new Personne();
var type = p.GetType();
Console.WriteLine(type.IsSealed); // "false"
```
* Assembly: il est utilisé pour obtenir des types à grande échelle: par exemple, pour analyser tous les types existants dans un assembly, ou alors dans tous les assemblies chargés.
```// localiser un type parmi tous les types chargés
var tousLesTypesChargés = AppDomain.CurrentDomain
    .GetAssemblies()
    .SelectMany(a => a.GetTypes())
    .Where(t => t.Name == "Personne");
```

Et le namespace Reflection.Emit ?
Je ne suis pas sûr si je considère cela comme de la réflexion ou non. Mais de toute façon, il est nécessaire d'utiliser la réfle