Reflection stelt een programma in staat om types, methoden en properties tijdens runtime te inspecteren en te manipuleren — zelfs degene die tijdens het compileren onbekend zijn. Attributes voegen declaratieve metagegevens toe aan code die tools en frameworks lezen (vaak via reflection) om gedrag aan te sturen. Samen vormen zij de basis voor veel van .NET's framework "magie" (serialisatie, DI, ORM's, validatie).
// 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 stelt code in staat types dynamisch te ontdekken en te gebruiken — instantiëren op basis van type, eigenschappen lezen/instellen, methoden aanroepen — wat aantoont hoe frameworks op jouw types werken zonder deze vooraf te kennen.
// 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 voorzien code van metagegevens die frameworks lezen om gedrag aan te sturen — validatieregels, serializatienamen, routing, enzovoort.
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
Dit is het mechanisme achter ASP.NET ([HttpGet], [Authorize]), validatie ([Required]), serialisatie ([JsonPropertyName]), ORM's en testingframeworks — zij scannen geannoteerde code via reflection en verbinden gedrag.
Reflection en attributes zijn de mechanica achter veel van .NET's frameworkfunctionaliteit, dus het begrijpen ervan is waardevol voor het doorgronden van hoe frameworks werken en voor geavanceerde scenario's. Reflection maakt generiek, dynamisch gedrag mogelijk — types tijdens runtime inspecteren en manipuleren zonder compile-time kennis — wat aantoont hoe dependency injection, serialisatie (JSON/XML-biblioteken die properties lezen), ORM's (objecten toewijzen aan databasetabellen) en testingframeworks op jouw willekeurige types werken. Attributes bieden de declaratieve metagegevens die deze tools lezen (via reflection) om hun gedrag aan te sturen, vervangend uitgebreide configuratie door eenvoudige annotaties ([Required] voor validatie, [HttpGet] voor routing, [JsonPropertyName] voor serialisatie, [Authorize] voor beveiliging).
Het begrijpen ervan demystificeert hoe ASP.NET Core, Entity Framework, validatie, serialisatie en testingframeworks hun declaratieve "magie" bereiken — erkennend dat attributes code markeren en reflection deze markeringen leest en erop inwerkt.
Deze kennis is waardevol voor het effectief gebruiken van deze frameworks, het bouwen van je eigen frameworkachtige tools of bibliotheken (custom attributes + reflection) en het begrijpen van de afwegingen (reflection is langzamer dan directe aanroepen en omzeilt bepaalde compile-time controles, dus wordt voorzichtig gebruikt).
Hoewel geavanceerd en niet alledaagse programmeerpraktijk, is het begrijpen van reflection en attributes belangrijke kennis op senior-niveau voor diepgaande werkzaamheden in het .NET-ecosysteem — het legt uit hoe de frameworks die je dagelijks gebruikt eigenlijk werken, maakt geavanceerde metaprogrammering mogelijk, en is een relevant onderwerp voor het begrijpen van .NET's architectuur en voor het bouwen van extensibele, op attributes gebaseerde bibliotheken, wat het tot waardevol kennis maakt die ontwikkelaars onderscheidt met diep .NET-inzicht.