Reflection საშუალებას აძლევს პროგრამას შემოწმდეს და მანიპულირებდეს types, methods და properties-ებს runtime-ზე — თუნდაც ისეთებს, რომლებიც compile time-ზე უცნობი იყო. Attributes ამატებს დეკლარატიულ metadata-ს კოდს, რომელსაც tools და frameworks კითხულობენ (ხშირად reflection-ის მეშვეობით) ქცევის გამოსაწვევად. ერთად ისინი უძღვებენ .NET-ის framework-ის უმეტესი "ჯადოსნობის" (serialization, DI, ORMs, validation).
// 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 საშუალებას აძლევს კოდს აღმოაჩინოს და გამოიყენოს types დინამიურად — instantiate type-ით, წაიკითხოს/დააყენოს properties, დაძახოს methods — რაც არის ის, როგორც frameworks მოქმედებენ თქვენს types-ებზე მათი წინასწარი ცოდნის გარეშე.
// 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 აწერს კოდს metadata-ით, რომელსაც frameworks კითხულობენ ქცევის გამოსაწვევად — validation rules, serialization names, routing, და ა.შ.
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
ეს არის მექანიზმი ASP.NET-ის უკან ([HttpGet], [Authorize]), validation-ის ([Required]), serialization-ის ([JsonPropertyName]), ORMs-ის და testing frameworks-ის — ისინი სკანირებენ attributed კოდს reflection-ის მეშვეობით და ეტელ ქცევას.
Reflection და attributes არის მექანიზმი .NET-ის framework functionality-ის უმეტესობის უკან, ამიტომ მათი გაგება ღირებული არის frameworks-ის მუშაობის გასაგებად და advanced scenarios-სთვის. Reflection ხელმისაწვდომელს ხდის generic, dynamic ქცევას — types-ის შემოწმება და მასზე მოქმედება runtime-ზე compile-time knowledge-ის გარეშე — რაც არის როგორ მუშაობენ dependency injection, serialization (JSON/XML libraries property-ების წაკითხვა), ORMs (objects database tables-ებზე მაპირება) და testing frameworks თქვენს arbitrary types-ებზე. Attributes იძლევა დეკლარატიულ metadata-ს, რომელსაც ეს tools კითხულობენ (reflection-ის მეშვეობით) მათი ქცევის გამოსაწვევად, verbose configuration-ის ჩანაცვლება simple annotations-ით ([Required] validation-სთვის, [HttpGet] routing-სთვის, [JsonPropertyName] serialization-სთვის, [Authorize] security-სთვის).
მათი გაგება არ აჭირთებს ASP.NET Core-ს, Entity Framework-ს, validation-ს, serialization-ს და testing frameworks-ებს მათი დეკლარატიული "ჯადოსნობის" — იმის აღიარება, რომ attributes აღნიშნავენ კოდს და reflection კითხულობს და მოქმედებს იმ მარკებზე.
ეს ცოდნა ღირებული არის ამ frameworks-ების ეფექტიანად გამოყენებისთვის, თქვენი საკუთარი framework-ის მსგავსი tools ან libraries-ის აგებისთვის (custom attributes + reflection), და framework-ის trade-offs-ის გაგებისთვის (reflection უფრო ნელია, ვიდრე direct calls და bypass ხდის ზოგ compile-time checking-ს, ამიტომ იგი გამოიყენება გულდასმით).
მიუხედავად იმისა, რომ advanced არის და ყოველდღე არ კოდირდება, reflection და attributes-ის გაგება მნიშვნელოვანი senior-level ცოდნაა .NET ecosystem-ში ღრმად მუშაობის შესაბამისად — ის ხსნის, როგორ მუშაობენ ის frameworks, რომელსაც ყოველდღე იყენებთ, ხელმისაწვდომელს ხდის advanced metaprogramming-ს და .NET-ის architecture-ის გაგებისთვის შესაბამის თემაა extensible, attribute-driven libraries-ის აგებისთვის, რაც მნიშვნელოვანი ცოდნაა, რომელიც განასხვავებს developers-ებს deep .NET understanding-ით.