La réflexion permet à un programme d'inspecter et de manipuler les types, les méthodes et les propriétés à l'exécution — même ceux inconnus à la compilation. Les attributs attachent des métadonnées déclaratives au code que les outils et frameworks lisent (souvent via la réflexion) pour piloter le comportement. Ensemble, ils alimentent une grande partie de la « magie » du framework .NET (sérialisation, injection de dépendances, ORMs, validation).
// examine a type's structure at runtime
Type type = typeof(User);
foreach (PropertyInfo prop in type.GetProperties())
Console.WriteLine($"{prop.Name}: {prop.PropertyType}");
foreach (MethodInfo method in type.GetMethods()) { }
// create instances and invoke members dynamically
object instance = Activator.CreateInstance(type); // create without knowing the type at compile time
PropertyInfo p = type.GetProperty("Name");
p.SetValue(instance, "Ann"); // set a property reflectively
La réflexion permet au code de découvrir et d'utiliser les types dynamiquement — instancier par type, lire/définir les propriétés, invoquer les méthodes — c'est ainsi que les frameworks opèrent sur vos types sans les connaître à l'avance.
// built-in and framework attributes attach metadata to code
[Obsolete("Use NewMethod instead")]
[Serializable]
public class OldClass { }
public class User
{
[Required] // validation attribute (ASP.NET)
[StringLength(100)]
public string Name { get; set; }
[JsonPropertyName("email_address")] // serialization attribute
public string Email { get; set; }
}
[HttpGet("/users/{id}")] // ASP.NET routing attribute
public User Get(int id) { }
Les attributs annotent le code avec des métadonnées que les frameworks lisent pour piloter le comportement — règles de validation, noms de sérialisation, routage, etc.
public class AuditAttribute : Attribute { public string Action; }
[Audit(Action = "delete")]
public void DeleteUser(int id) { }
// a framework reads the attribute via reflection and acts on it
var attr = method.GetCustomAttribute<AuditAttribute>();
if (attr != null) Log(attr.Action); // wrap/log/intercept based on the metadata
C'est le mécanisme derrière ASP.NET ([HttpGet], [Authorize]), la validation ([Required]), la sérialisation ([JsonPropertyName]), les ORMs et les frameworks de test — ils analysent le code annoté via la réflexion et mettent en place le comportement.
La réflexion et les attributs sont la machinerie derrière une grande partie de la fonctionnalité des frameworks .NET, donc les comprendre est précieux pour comprendre comment les frameworks fonctionnent et pour les scénarios avancés. La réflexion active le comportement générique et dynamique — inspecter et opérer sur les types à l'exécution sans connaissance à la compilation — c'est ainsi que fonctionnent l'injection de dépendances, la sérialisation (les bibliothèques JSON/XML lisant les propriétés), les ORMs (mappant les objets aux tables de base de données) et les frameworks de test sur vos types arbitraires. Les attributs fournissent les métadonnées déclaratives que ces outils lisent (via la réflexion) pour piloter leur comportement, remplaçant la configuration verbeuse par des annotations simples ([Required] pour la validation, [HttpGet] pour le routage, [JsonPropertyName] pour la sérialisation, [Authorize] pour la sécurité).
Les comprendre démystifie comment ASP.NET Core, Entity Framework, la validation, la sérialisation et les frameworks de test réalisent leur « magie » déclarative — en reconnaissant que les attributs marquent le code et que la réflexion lit et agit sur ces marques.
Cette connaissance est précieuse pour utiliser efficacement ces frameworks, construire vos propres outils ou bibliothèques de type framework (attributs personnalisés + réflexion) et comprendre les compromis (la réflexion est plus lente que les appels directs et contourne certaines vérifications à la compilation, donc elle est utilisée judicieusement).
Bien qu'avancée et non du codage quotidien, la compréhension de la réflexion et des attributs est une connaissance importante au niveau senior pour travailler en profondeur dans l'écosystème .NET — elle explique comment les frameworks que vous utilisez quotidiennement fonctionnent réellement, active la métaprogrammation avancée et est un sujet pertinent pour comprendre l'architecture de .NET et pour construire des bibliothèques extensibles et pilotées par attributs, ce qui en fait une connaissance utile qui distingue les développeurs ayant une compréhension approfondie de .NET.