Reflection ermöglicht es einem Programm, zur Laufzeit Typen, Methoden und Eigenschaften zu inspizieren und zu manipulieren — auch solche, die zur Compile-Zeit unbekannt sind. Attribute hängen deklarativ Metadaten an Code an, die Tools und Frameworks lesen (oft über Reflection), um Verhalten zu steuern. Zusammen ermöglichen sie einen Großteil der .NET-Framework-"Magie" (Serialisierung, DI, ORMs, Validierung).
// 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 ermöglicht es Code, Typen dynamisch zu entdecken und zu verwenden — Instanzieren nach Typ, Eigenschaften lesen/setzen, Methoden aufrufen — auf diese Weise können Frameworks auf Ihre Typen zugreifen, ohne sie vorher zu 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) { }
Attribute annotieren Code mit Metadaten, die Frameworks lesen, um Verhalten zu steuern — Validierungsregeln, Serialisierungsnamen, Routing, etc.
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
Das ist der Mechanismus hinter ASP.NET ([HttpGet], [Authorize]), Validierung ([Required]), Serialisierung ([JsonPropertyName]), ORMs und Testing-Frameworks — sie scannen attributierten Code über Reflection und verdrahten Verhalten.
Reflection und Attribute sind die Maschinen hinter vielen .NET-Framework-Funktionalitäten, daher ist deren Verständnis wertvoll, um zu verstehen, wie Frameworks funktionieren und für fortgeschrittene Szenarien. Reflection ermöglicht generisches, dynamisches Verhalten — Inspizieren und Operieren auf Typen zur Laufzeit ohne Compile-Zeit-Wissen — auf diese Weise funktionieren Dependency Injection, Serialisierung (JSON/XML-Bibliotheken lesen Eigenschaften), ORMs (Objekte auf Datenbanktabellen abbilden) und Testing-Frameworks auf Ihre beliebigen Typen. Attribute bieten die deklarativen Metadaten, die diese Tools lesen (über Reflection), um ihr Verhalten zu steuern und ersetzen verboseKonfiguration durch einfache Annotationen ([Required] für Validierung, [HttpGet] für Routing, [JsonPropertyName] für Serialisierung, [Authorize] für Sicherheit).
Das Verständnis entzaubert, wie ASP.NET Core, Entity Framework, Validierung, Serialisierung und Testing-Frameworks ihre deklarative "Magie" erreichen — zu erkennen, dass Attribute Code markieren und Reflection diese Marken liest und darauf reagiert.
Disses Wissen ist wertvoll für die effektive Nutzung dieser Frameworks, das Erstellen eigener Framework-ähnlicher Tools oder Bibliotheken (benutzerdefinierte Attribute + Reflection) und das Verstehen der Kompromisse (Reflection ist langsamer als direkte Aufrufe und umgeht einige Compile-Zeit-Überprüfungen, wird also bedacht eingesetzt).
Obwohl fortgeschritten und nicht tägliche Programmierung, ist das Verständnis von Reflection und Attributen wichtiges Wissen auf Senior-Niveau für tiefes Arbeiten im .NET-Ökosystem — es erklärt, wie die Frameworks funktionieren, die Sie täglich verwenden, ermöglicht fortgeschrittene Metaprogrammierung und ist ein relevantes Thema zum Verständnis von .NETs Architektur und zum Erstellen erweiterbarer, attribut-gesteuerte Bibliotheken, was es zu wertvollen Wissen macht, das Entwickler mit tiefem .NET-Verständnis auszeichnet.