La riflessione permette a un programma di ispezionare e manipolare tipi, metodi e proprietà a runtime — anche quelli sconosciuti al momento della compilazione. Gli attributi allegano metadati dichiarativi al codice che strumenti e framework leggono (spesso tramite riflessione) per guidare il comportamento. Insieme alimentano gran parte della "magia" del framework .NET (serializzazione, DI, ORM, validazione).
// 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 riflessione permette al codice di scoprire e utilizzare i tipi dinamicamente — istanziare per tipo, leggere/impostare proprietà, invocare metodi — questo è il modo in cui i framework operano sui tuoi tipi senza conoscerli in anticipo.
// 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) { }
Gli attributi annotano il codice con metadati che i framework leggono per guidare il comportamento — regole di validazione, nomi di serializzazione, routing, ecc.
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
Questo è il meccanismo dietro ASP.NET ([HttpGet], [Authorize]), validazione ([Required]), serializzazione ([JsonPropertyName]), ORM e framework di testing — scansionano il codice con attributi tramite riflessione e collegano il comportamento.
La riflessione e gli attributi sono il meccanismo dietro gran parte della funzionalità dei framework .NET, quindi comprenderli è prezioso per comprendere come funzionano i framework e per scenari avanzati. La riflessione abilita comportamenti generici e dinamici — ispezionando e operando sui tipi a runtime senza conoscenza al momento della compilazione — questo è il modo in cui l'iniezione di dipendenze, la serializzazione (librerie JSON/XML che leggono proprietà), gli ORM (mappatura di oggetti a tabelle di database) e i framework di testing funzionano sui tuoi tipi arbitrari. Gli attributi forniscono i metadati dichiarativi che questi strumenti leggono (tramite riflessione) per guidare il loro comportamento, sostituendo la configurazione verbosa con semplici annotazioni ([Required] per la validazione, [HttpGet] per il routing, [JsonPropertyName] per la serializzazione, [Authorize] per la sicurezza).
\