Refleksja pozwala programowi inspektować i manipulować typami, metodami i właściwościami w runtime'ie — nawet takimi, które są nieznane w czasie kompilacji. Atrybuty dołączają deklaratywne metadane do kodu, które narzędzia i frameworki odczytują (często za pośrednictwem refleksji), aby sterować zachowaniem. Razem umożliwiają wiele "magii" frameworku .NET (serializacja, wstrzykiwanie zależności, ORMy, walidacja).
// 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
Refleksja pozwala kodowi odkrywać i używać typy dynamicznie — tworzyć instancje przez typ, odczytywać/ustawiać właściwości, wywoływać metody — co jest sposobem, w jaki frameworki operują na twoich typach bez wcześniejszej wiedzy o nich.
// 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) { }
Atrybuty adnotują kod metadanymi, które frameworki odczytują, aby sterować zachowaniem — reguły walidacji, nazwy serializacji, routing itp.
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 jest mechanizm stojący za ASP.NET ([HttpGet], [Authorize]), walidacją ([Required]), serializacją ([JsonPropertyName]), ORMami i frameworkami testowymi — skanują one kod z atrybutami za pośrednictwem refleksji i automatycznie konfigurują zachowanie.
Refleksja i atrybuty są maszynerią stojącą za większością funkcjonalności frameworku .NET, dlatego zrozumienie ich jest cenne dla pojęcia, jak działają frameworki i w zaawansowanych scenariuszach. Refleksja umożliwia generyczne, dynamiczne zachowanie — inspekcję i operowanie na typach w runtime'ie bez wiedzy z czasu kompilacji — co jest sposobem działania wstrzykiwania zależności, serializacji (biblioteki JSON/XML odczytujące właściwości), ORMów (mapowanie obiektów na tabele bazy danych) i frameworków testowych na dowolnych twoich typach. Atrybuty dostarczają deklaratywne metadane, które te narzędzia odczytują (za pośrednictwem refleksji), aby sterować swoim zachowaniem, zastępując wielosłowną konfigurację prostymi adnotacjami ([Required] do walidacji, [HttpGet] do routingu, [JsonPropertyName] do serializacji, [Authorize] do bezpieczeństwa).
Zrozumienie ich wyjaśnia, jak ASP.NET Core, Entity Framework, walidacja, serializacja i frameworki testowe osiągają swoją deklaratywną "magię" — rozumiejąc, że atrybuty oznaczają kod, a refleksja je odczytuje i działa na podstawie tych oznaczeń.
Ta wiedza jest cenna do efektywnego korzystania z tych frameworków, budowania własnych narzędzi lub bibliotek podobnych do frameworków (atrybuty niestandardowe + refleksja) oraz zrozumienia kompromisów (refleksja jest wolniejsza niż bezpośrednie wywołania i omija pewne sprawdzenia z czasu kompilacji, więc jest używana rozsądnie).
Chociaż zaawansowane i nie codzienne kodowanie, zrozumienie refleksji i atrybutów jest ważną wiedzą na poziomie seniora dla głębokich prac w ekosystemie .NET — wyjaśnia, jak faktycznie działają frameworki, których używasz codziennie, umożliwia zaawansowaną metaprogramowanie i jest istotnym tematem do zrozumienia architektury .NET oraz budowania rozszerzalnych, opartych na atrybutach bibliotek, co czyni to wiedzę godną poznania, która wyróżnia programistów z głębokim zrozumieniem .NET.