Reflection permite unui program să inspecteze și manipuleze tipuri, metode și proprietăți la runtime — chiar și cele necunoscute la compile time. Attributes atașează metadate declarative la cod pe care tool-urile și framework-urile le citesc (adesea prin reflection) pentru a controla comportamentul. Împreună, ele alimentează o mare parte din "magia" framework-ului .NET (serializare, DI, ORM-uri, validare).
// 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
Reflection permite codului să descopere și să folosească tipuri dinamic — instantiează după tip, citește/setează proprietăți, invocă metode — ceea ce este modul în care framework-urile operează pe tipurile tale fără a le cunoaște dinainte.
// 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) { }
Attributes adnotează codul cu metadate pe care framework-urile le citesc pentru a controla comportamentul — reguli de validare, nume de serializare, rutare, 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
Acesta este mecanismul din spatele ASP.NET ([HttpGet], [Authorize]), validării ([Required]), serializării ([JsonPropertyName]), ORM-urilor și framework-urilor de testare — ele scanează codul cu atribute prin reflection și configurează comportamentul.
Reflection și attributes sunt mecanismul din spatele unei mari părți din funcționalitatea framework-ului .NET, deci înțelegerea lor este valoroasă pentru a înțelege cum funcționează framework-urile și pentru scenarii avansate. Reflection permite comportamentul generic și dinamic — inspectează și operează pe tipuri la runtime fără cunoaștere la compile time — ceea ce este modul în care dependency injection, serializarea (bibliotecile JSON/XML citind proprietăți), ORM-urile (mapând obiecte la tabele de bază de date) și framework-urile de testare funcționează pe tipurile tale arbitrare. Attributes furnizează metadatele declarative pe care aceste tool-uri le citesc (prin reflection) pentru a conduce comportamentul lor, înlocuind configurația verbală cu adnotări simple ([Required] pentru validare, [HttpGet] pentru rutare, [JsonPropertyName] pentru serializare, [Authorize] pentru securitate).
Înțelegerea lor demistifică modul în care ASP.NET Core, Entity Framework, validarea, serializarea și framework-urile de testare realizează "magia" lor declarativă — recunoscând că attributes marchează codul și reflection citește și acționează pe acele marcaje.
Această cunoaștere este valoroasă pentru utilizarea eficientă a acestor framework-uri, construirea propriilor tool-uri sau biblioteci de tip framework (atribute personalizate + reflection) și înțelegerea compromisurilor (reflection este mai lent decât apelurile directe și ocolește unele verificări la compile time, deci este folosit cu judecată).
Deși avansat și nu de zi cu zi, înțelegerea reflection și attributes este cunoaștere importantă la nivel senior pentru lucrul profund în ecosistemul .NET — explică cum funcționează de fapt framework-urile pe care le folosești zilnic, permite metaprogramarea avansată și este un subiect relevant pentru înțelegerea arhitecturii .NET și pentru construirea bibliotecilor extensibile și bazate pe atribute, făcând-o o cunoaștere care merită să fie dobândită și care distinge dezvoltatorii cu o înțelegere profundă a .NET-ului.