Hvad bruges reflection og attributes til?

Question

Accepted Answer

**Reflection** giver et program mulighed for at **inspicere og manipulere typer, metoder og egenskaber ved runtime** — selv dem der er ukendte ved kompileringstidspunktet. **Attributes** vedhæfter deklarativ **metadata** til kode, som værktøjer og frameworks læser (ofte via reflection) for at styre adfærd. Sammen driver de meget af .NET's framework "magi" (serialisering, DI, ORMs, validering).

## Reflection — runtime inspektion og invokering

```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 lader kode opdage og bruge typer dynamisk — instantiere efter type, læse/sætte egenskaber, invokere metoder — hvilket er hvordan frameworks opererer på *dine* typer uden at kende dem på forhånd.

## Attributes — deklarativ 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) { }
```

Attributes annoterer kode med metadata, som frameworks læser for at styre adfærd — valideringsregler, serialiseringnavne, routing osv.

## Custom attributes + reflection (hvordan frameworks fungerer)

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

Dette er mekanismen bag ASP.NET (`[HttpGet]`, `[Authorize]`), validering (`[Required]`), serialisering (`[JsonPropertyName]`), ORMs og testningsframeworks — de scanner attributeret kode via reflection og forbinder adfærd.

## Hvorfor det betyder noget

Reflection og attributes er **maskinerierne bag meget af .NET's framework-funktionalitet**, så forståelse af dem er værdifuld for at forstå, hvordan frameworks fungerer, og for avancerede scenarier. **Reflection** muliggør generisk, dynamisk adfærd — inspektion og drift af typer ved runtime uden kompileringstidspunktets viden — hvilket er hvordan afhængighedsinjektionindsprøjtning, serialisering (JSON/XML-biblioteker læser egenskaber), ORMs (kortlægning af objekter til databasetabeller) og testningsframeworks fungerer på dine vilkårlige typer. **Attributes** giver det deklarative metadata, som disse værktøjer læser (via reflection) for at styre deres adfærd, og erstatter omstændig konfiguration med simple annotationer (`[Required]` til validering, `[HttpGet]` til routing, `[JsonPropertyName]` til serialisering, `[Authorize]` for sikkerhed).

At forstå dem **demystificerer hvordan ASP.NET Core, Entity Framework, validering, serialisering og testningsframeworks opnår deres deklarative "magi"** — at genkende, at attributes markerer kode, og reflection læser og handler på disse mærker.

Denne viden er værdifuld for at bruge disse frameworks effektivt, bygge dine egne framework-lignende værktøjer eller biblioteker (custom attributes + reflection) og forstå afvejningerne (reflection er langsommere end direkte kald og omgår nogle kompileringstidspunkts-kontroller, så det bruges med omhu).

Skønt avanceret og ikke hverdagskodning, er forståelse af reflection og attributes vigtig senior-level viden for at arbejde dybde i .NET-økosystemet — det forklarer hvordan de frameworks, du bruger dagligt, faktisk fungerer, muliggør avanceret metaprogrammering og er et relevant emne for forståelse af .NET's arkitektur og til at bygge udvidelige, attribute-drevne biblioteker, hvilket gør det værdifuld viden, der adskiller udvikler med dybindgående .NET-forståelse.