Kam naudojami reflection ir atributai?

Question

Accepted Answer

**Reflection** leidžia programai **patikrinti ir manipuliuoti tipos, metodus ir savybes vykdymo metu** — netgi tais, kurie nežinomi kompiliacijos metu. **Atributai** prideda deklaratyvų **metaduomenis** prie kodo, kuriuos skaito įrankiai ir framework'ai (dažnai per reflection), siekdami nukreipti elgesį. Kartu jie suteikia daug .NET framework'o "magijos" (serializacija, DI, ORM'ai, validacija).

## Reflection — vykdymo metu inspektavimas ir iškvietimas

```csharp
// 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 leidžia kodui dinamiškai atrasti ir naudoti tipus — sukurti instancijas pagal tipą, skaityti/nustatyti savybes, iškviesti metodus — tai yra būdas, kuriuo framework'ai veikia su *jūsų* tipais nežinodami jų iš anksto.

## Atributai — deklaratyvūs metaduomenys

```csharp
// 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) { }
```

Atributai anotacija aprašo kodą su metaduomenimis, kuriuos framework'ai skaito, siekdami nukreipti elgesį — validavimo taisykles, serializacijos pavadinimus, maršrutizavimą ir pan.

## Pasirinktiniai atributai + reflection (kaip veikia framework'ai)

```csharp
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
```

Tai yra mechanizmas, kuriuo naudojasi ASP.NET (`[HttpGet]`, `[Authorize]`), validacija (`[Required]`), serializacija (`[JsonPropertyName]`), ORM'ai ir testavimo framework'ai — jie nuskaito anotacijas atliekant kodą per reflection ir nustatinėja elgesį.

## Kodėl tai svarbu

Reflection ir atributai yra **pagrindinis komponentas daug .NET framework'o funkcionalumo**, todėl juos suprasti yra vertinga siekiant suprasti, kaip veikia framework'ai, ir sudėtinesniais atvejais. **Reflection** suteikia generinį, dinaminį elgesį — patikrinant ir atliekant operacijas su tipais vykdymo metu be kompiliacijos laiko žinojimo — tai yra būdas, kuriuo veikia priklausomybių injekcija, serializacija (JSON/XML bibliotekos skaitydamos savybes), ORM'ai (žemėlapiai objektams į duomenų bazės lenteles) ir testavimo framework'ai, veikdami su jūsų savavališkais tipais. **Atributai** teikia deklaratyviuosius metaduomenis, kuriuos šie įrankiai skaito (per reflection), siekdami nukreipti jų elgesį, keisdami sudetingą konfigūraciją paprastomis anotacijomis (`[Required]` validavimui, `[HttpGet]` maršrutizavimui, `[JsonPropertyName]` serializacijai, `[Authorize]` saugumui).

Jų supratimas **paaiškina, kaip ASP.NET Core, Entity Framework, validacija, serializacija ir testavimo framework'ai pasiekia deklaratyvią "magiją"** — atpažinti, kad atributai žymi kodą, o reflection juos skaito ir veikia pagal jų.

Ši žinias yra vertinga šiems framework'ams efektyviai naudoti, sukuriant savo framework'o pavidalo įrankius ar bibliotekas (pasirinktiniai atributai + reflection) ir suprantant kompromisus (reflection yra lėtesnis nei tiesioginiai iškvietimai ir aplenkia kai kurį kompiliacijos laiko tikrinimą, todėl jis naudojamas atsargiai).

Nors tai sudėtinga ir ne kasdieninis kodavimas, reflection ir atributų supratimas yra svarbi aukštesnio lygio žinias, reikalinga dirbant giliau .NET ekosistemoje — tai paaiškina, kaip iš tikrųjų veikia framework'ai, kuriuos kasdien naudojate, suteikia galimybę atliekant pažangiųjį metaprogramavimą ir yra svarbi tema suprasti .NET architektūrą ir kurti išplečiamas, atributais valdomas bibliotekas, todėl tai yra vertinga žinias, kuri išskiria plačiai .NET suprantančius kūrėjus.