Za kaj se uporabljata reflection in atributi?

Question

Accepted Answer

**Reflection** programu omogoča, da pri izvajanju **pregleduje in manipulira tipe, metode in lastnosti** — celo tiste, ki niso znane v času prevajanja. **Atributi** prilagajo deklarativne **metapodatke** kodi, ki jih orodja in ogrodja berejo (pogosto prek reflectiona), da vodijo obnašanje. Skupaj poganjajo večino .NET ogrodja "magije" (serializacija, DI, ORM-i, validacija).

## Reflection — pregled in pogon med izvajanjem

```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 kodi omogoča, da dinamično odkriva in uporablja tipe — instancira po tipu, prebira/nastavi lastnosti, poziva metode — to je način, kako ogrodja delujejo na *vaših* tipih brez da jih v naprej poznajo.

## Atributi — deklarativni metapodatki

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

Atributi opremijo kodo z metapodatki, ki jih ogrodja berejo, da vodijo obnašanje — pravila validacije, imena za serializacijo, usmerjanje, itd.

## Prilagojeni atributi + reflection (kako ogrodja delujejo)

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

To je mehanizem, ki ga uporabljata ASP.NET (`[HttpGet]`, `[Authorize]`), validacija (`[Required]`), serializacija (`[JsonPropertyName]`), ORM-i in testna ogrodja — skenirajo atribuirano kodo prek reflectiona in pripravijo obnašanje.

## Zakaj je to pomembno

Reflection in atributi so **mehanizem za večino funkcionalnosti .NET ogrodij**, zato je razumevanje njih dragoceno za razumevanje, kako ogrodja delujejo in za napredne scenarije. **Reflection** omogoča splošno, dinamično obnašanje — pregledovanje in delovanje na tipih med izvajanjem brez znanja v času prevajanja — to je način, kako dependency injection, serializacija (knjižnice JSON/XML berejo lastnosti), ORM-i (preslikavajo objekte v tabele baz podatkov) in testna ogrodja delujejo na vaših poljubnih tipih. **Atributi** zagotavljajo deklarativne metapodatke, ki jih ta orodja berejo (prek reflectiona), da vodijo svoje obnašanje, nadomestijo obsežno konfiguracijo s preprostimi opombami (`[Required]` za validacijo, `[HttpGet]` za usmerjanje, `[JsonPropertyName]` za serializacijo, `[Authorize]` za varnost).

Razumevanje jih **pojasni, kako ASP.NET Core, Entity Framework, validacija, serializacija in testna ogrodja dosegajo svoje deklarativne "magije"** — spoznanje, da atributi označijo kodo in reflection bere in deluje na te označbe.

To znanje je dragoceno za učinkovito uporabo teh ogrodij, gradnjo svojih ogrodjem podobnih orodij ali knjižnic (prilagojeni atributi + reflection) ter razumevanje kompromisov (reflection je počasnejši od neposrednih klicev in obide nekaj preverjanja v času prevajanja, zato se uporablja pazljivo).

Čeprav je to napredno in ne vsakodnevno kodiranje, je razumevanje reflectiona in atributov pomembno znanje na višji ravni za globoko delo v .NET ekosistemu — pojasni, kako ogrodja, ki jih uporabljate dnevno, dejansko delujejo, omogoči napredno metaprogramiranje in je relevantna tema za razumevanje .NET arhitekture ter za gradnjo razširljivih, atributom vodenih knjižnic, kar naredi to znanje vredno, da ločimo razvijalce s globokim .NET razumevanjem.