K čemu slouží reflexe a atributy?

Question

Accepted Answer

**Reflexe** umožňuje programu **inspektovat a manipulovat typy, metody a vlastnosti za běhu** — i ty, které nejsou známy v čase kompilace. **Atributy** připojují deklarativní **metadata** ke kódu, která si nástroje a frameworky čtou (často prostřednictvím reflexe) a řídí podle nich své chování. Společně poháněly velkou část "magie" frameworku .NET (serializace, dependency injection, ORM, validace).

## Reflexe — inspekce a vyvolání za běhu

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

Reflexe umožňuje kódu dynamicky objevovat a používat typy — instantiovat podle typu, číst a nastavovat vlastnosti, vyvolávat metody — což je způsob, jakým frameworky pracují s *vašimi* typy bez předchozí znalosti.

## Atributy — deklarativní metadata

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

Atributy anotují kód metadaty, která si frameworky čtou a řídí podle nich své chování — validační pravidla, jména pro serializaci, směrování, atd.

## Vlastní atributy + reflexe (jak fungují frameworky)

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

Toto je mechanismus za ASP.NET (`[HttpGet]`, `[Authorize]`), validací (`[Required]`), serializací (`[JsonPropertyName]`), ORM a testovacími frameworky — skenují atributovaný kód prostřednictvím reflexe a připravují chování.

## Proč je to důležité

Reflexe a atributy jsou **strojovnou za velkou část funkčnosti frameworků .NET**, takže jejich pochopení je cenné pro porozumění tomu, jak frameworky fungují, a pro pokročilé scénáře. **Reflexe** umožňuje generické a dynamické chování — inspekci a operaci na typech za běhu bez znalosti v čase kompilace — což je způsob, jakým funguje dependency injection, serializace (knihovny JSON/XML čtoucí vlastnosti), ORM (mapování objektů na tabulky databází) a testovací frameworky na vašich libovolných typech. **Atributy** poskytují deklarativní metadata, která si tyto nástroje čtou (prostřednictvím reflexe) a řídí podle nich své chování, nahrazují podrobnou konfiguraci jednoduchými anotacemi (`[Required]` pro validaci, `[HttpGet]` pro směrování, `[JsonPropertyName]` pro serializaci, `[Authorize]` pro bezpečnost).

Pochopení jich **demystifikuje, jak ASP.NET Core, Entity Framework, validace, serializace a testovací frameworky dosahují své deklarativní "magie"** — rozpoznáním, že atributy označují kód a reflexe je čte a jedná podle nich.

Tato znalost je cenná pro efektivní používání těchto frameworků, vytváření vlastních nástrojů nebo knihoven podobných frameworkům (vlastní atributy + reflexe) a pro pochopení kompromisů (reflexe je pomalejší než přímá volání a obchází některé kontroly v čase kompilace, takže se používá obezřetně).

Ačkoli je to pokročilé a není to dennodenní kódování, pochopení reflexe a atributů je důležitou znalostí na úrovni senior pro hlubší práci v ekosystému .NET — vysvětluje, jak frameworky, které používáte každodenně, ve skutečnosti fungují, umožňuje pokročilou metaprogrammování a je relevantním tématem pro pochopení architektury .NET a pro vytváření extensivních knihoven řízených atributy, takže je to znalost, která stojí za to si ji osvojit a která rozlišuje vývojáře s hlubokým porozuměním .NET.