Reflektimi lejon një program të inspektojë dhe manipulojë tipe, metoda dhe prona në kohën e ekzekutimit — madje edhe ato të panjohura në kohën e përpilimit. Atributet bashkëngjitën metadata deklarative në kod që mjetet dhe framework-et e lexojnë (shpesh përmes reflektimit) për të drejtuar sjelljen. Së bashku ato fuqizojnë shumë nga "magjia" e framework-ut .NET (serializimi, DI, ORM-et, validimi).
// 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
Reflektimi lejon kodin të zbulojë dhe përdorë tipet dinamikisht — të instantifikojë sipas tipit, të lexojë/vendosë prona, të thërrasë metoda — çka është mënyra se si framework-et operojnë në tipet tuaja pa i njohur më përpara.
// 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) { }
Atributet anotojnë kodin me metadata që framework-et e lexojnë për të drejtuar sjelljen — rregullat e validimit, emrat e serializimit, rrugëzimi, etj.
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
Kjo është mekanizmi pas ASP.NET ([HttpGet], [Authorize]), validimit ([Required]), serializimit ([JsonPropertyName]), ORM-eve dhe framework-eve të testimit — ato skanojnë kodin e atribuuar përmes reflektimit dhe lidhën sjelljen.
Reflektimi dhe atributet janë makineria pas shumë funksionalitetit të framework-ut .NET, kështu që kuptimi i tyre ka vlerë për të kuptuar se si funksionojnë framework-et dhe për skenarë të përparuara. Reflektimi mundëson sjellje gjenerike dhe dinamike — inspektimi dhe veprimi në tipet në kohën e ekzekutimit pa ditur në kohën e përpilimit — çka është mënyra se si funksionojnë injektimi i varësisë, serializimi (biblioteket JSON/XML që lexojnë prona), ORM-et (hartëzimi i objekteve me tabela bazash të të dhënave) dhe framework-et e testimit në tipet tuaja arbitrare. Atributet ofrojnë metadata deklarative që këto mjete e lexojnë (përmes reflektimit) për të drejtuar sjelljen e tyre, duke zëvendësuar konfigurimin e ndërlikuar me anotacione të thjeshta ([Required] për validim, [HttpGet] për rrugëzim, [JsonPropertyName] për serializim, [Authorize] për siguri).
Kuptimi i tyre demistifikon se si ASP.NET Core, Entity Framework, validimi, serializimi dhe framework-et e testimit arritjnë "magjinë" e tyre deklarative — njohja se atributet shënojnë kodin dhe reflektimi e lexon dhe vepron në ato shenja.
Ky njohuri është i vlefshëm për përdorimin efektiv të këtyre framework-eve, ndërtimin e mjeteve ose bibliotekave tuaja të ngjashme me framework-in (atributet e zakonshme + reflektimi) dhe kuptimin e kompromiseve (reflektimi është më i ngadalshëm se thirrjet e drejtpërdrejta dhe anashkalon disa kontrolle në kohën e përpilimit, kështu që përdoret me kujdes).
Megjithëse i përparuar dhe jo kodim i përditshëm, kuptimi i reflektimit dhe atributeve është njohuri e rëndësishme për nivelin e lartë për të punuar thellësisht në ekosistemën .NET — shpjegon se si funksionojnë në të vërtetë framework-et që përdorni çdo ditë, mundëson metaprogramimin e përparuar dhe është temë përkatëse për të kuptuar arkitekturën e .NET dhe për ndërtimin e bibliotekave të zgjerueshme dhe të drejtuara nga atributet, duke e bërë të vërteta njohuri që dallon zhvilluesit me kuptim të thellë të .NET.