C# Reflection ו-Attributes: typeof, GetType ותכונות מותאמות

Reflection מאפשר לתוכנית לבחון טיפוסים בזמן שהיא רצה: אילו מאפיינים יש למחלקה, מה הערכים שלהם, אילו מתודות קיימות, אילו תכונות מוצמדות. Attributes (תכונות) הם החצי השני: תגיות הצהרתיות בסוגריים מרובעים, כמו [Obsolete] או [JsonPropertyName("id")], שאין להן משמעות בפני עצמן עד שהקומפיילר או קוד כלשהו קוראים אותן עם reflection. סריאלייזרים, ORMs, ספריות אימות, מסגרות בדיקה והניתוב של ASP.NET עובדים כולם כך.

רוב קוד האפליקציות רק לעיתים רחוקות צריך reflection ישירות, אבל הבנה של איך הוא עובד מסבירה הרבה מההתנהגות של מסגרות העבודה.

אובייקטי Type: typeof ו-GetType

הכול מתחיל מ-System.Type. יש שתי דרכים לקבל אחד:

using System;

class Employee { public string Name { get; set; } }
class Manager : Employee { public int Reports { get; set; } }

class Program
{
    static void Main()
    {
        Type t1 = typeof(Employee);          // from a type name, at compile time
        Employee e = new Manager();
        Type t2 = e.GetType();               // from an object, at run time

        Console.WriteLine(t1.Name);
        Console.WriteLine(t2.Name);          // the real type, not the variable's type
        Console.WriteLine(t2.BaseType.Name);

        Console.WriteLine(e.GetType() == typeof(Employee));   // exact type check
        Console.WriteLine(e is Employee);                     // "is it an Employee or derived?"
        Console.WriteLine(typeof(Employee).IsAssignableFrom(t2));

        Console.WriteLine(typeof(int).FullName);
        Console.WriteLine(typeof(string).IsValueType);
        Console.WriteLine(nameof(Employee.Name));             // compile-time name, no reflection
    }
}

פלט:

Employee
Manager
Employee
False
True
True
System.Int32
False
Name

ההבדל שצריך לזכור: typeof(X) נותן שם לטיפוס שאתם מכירים כשאתם כותבים את הקוד, ו-obj.GetType() שואל אובייקט מה הוא באמת. ההשוואה GetType() == typeof(Employee) היא התאמה מדויקת שנכשלת עבור מחלקות נגזרות, ובדרך כלל זה לא מה שרוצים; is ו-IsAssignableFrom מתחשבים בירושה. nameof נראה דומה אבל הוא בכלל לא reflection: הקומפיילר מחליף אותו בקבוע מחרוזת.

GetType() על הפניה שהיא null זורק NullReferenceException, כי אין אובייקט לשאול. על טיפוס ערך nullable ארוז הוא מחזיר את הטיפוס שבבסיס: ((int?)5).GetType() הוא System.Int32.

קריאה והצבה של מאפיינים

GetProperties() מפרט את המאפיינים הציבוריים של טיפוס כאובייקטי PropertyInfo, שכל אחד מהם יכול לקרוא ולכתוב את הערך במופע נתון:

using System;
using System.Reflection;

class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int Stock { get; set; }
    private string supplierCode = "SUP-77";
}

class Program
{
    static void Main()
    {
        var mug = new Product { Name = "Mug", Price = 8.50m, Stock = 12 };
        Type type = mug.GetType();

        foreach (PropertyInfo p in type.GetProperties())
            Console.WriteLine($"{p.Name,-6} {p.PropertyType.Name,-8} = {p.GetValue(mug)}");

        PropertyInfo price = type.GetProperty("Price");
        price.SetValue(mug, 7.90m);
        Console.WriteLine(mug.Price);

        Console.WriteLine(type.GetProperty("Colour") == null);   // no such property

        FieldInfo hidden = type.GetField("supplierCode", BindingFlags.NonPublic | BindingFlags.Instance);
        Console.WriteLine(hidden.GetValue(mug));
    }
}

פלט:

Name   String   = Mug
Price  Decimal  = 8.50
Stock  Int32    = 12
7.90
True
SUP-77

שלושה דברים שזה מראה:

• GetValue מחזיר object, כך שטיפוסי ערך חוזרים ארוזים (boxed) וצריך להמיר אותם כדי להשתמש בהם.
• GetProperty עם שם שלא קיים מחזיר null, והקריאה הבאה עליו זורקת NullReferenceException. בדקו לפני השימוש.
• BindingFlags.NonPublic | BindingFlags.Instance מגיע לאיברים פרטיים. זה לגיטימי בכלים ובבדיקות, אבל זה עוקף את הכימוס ונשבר בשקט כשמבצעים refactoring למחלקה.

הלולאה הזו היא בעצם האופן שבו עובד מייצא CSV או סריאלייזר מאובייקט ל-JSON: עוברים על המאפיינים, קוראים כל ערך ומעצבים אותו.

קריאה למתודות ויצירת אובייקטים לפי שם

GetMethod מוצא מתודה, ו-Invoke קורא לה עם מערך של ארגומנטים. Activator.CreateInstance יוצר אובייקט מ-Type, וכך מערכות תוספים ומכלי DI בונים טיפוסים שנבחרים בזמן ריצה:

using System;
using System.Reflection;

class PriceCalculator
{
    public decimal Rate { get; set; } = 0.20m;
    public decimal WithTax(decimal net) => net * (1 + Rate);
    public string Describe() => $"Tax rate {Rate:P0}";
}

class Program
{
    static void Main()
    {
        Type type = typeof(PriceCalculator);
        object calc = Activator.CreateInstance(type);

        MethodInfo withTax = type.GetMethod("WithTax");
        object result = withTax.Invoke(calc, new object[] { 50m });
        Console.WriteLine(result);

        foreach (MethodInfo m in type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
        {
            if (m.IsSpecialName) continue;   // skip property getters and setters
            Console.WriteLine($"{m.ReturnType.Name} {m.Name}({m.GetParameters().Length} parameters)");
        }

        Type byName = Type.GetType("PriceCalculator");
        Console.WriteLine(byName == type);
    }
}

פלט:

60.00
Decimal WithTax(1 parameters)
String Describe(0 parameters)
True

DeclaredOnly מגביל את הרשימה לאיברים שהוצהרו במחלקה עצמה; בלעדיו, GetMethods מחזירה גם את ToString, Equals, GetHashCode ו-GetType מ-object. Type.GetType("Name") צריך את השם המלא כולל ה-namespace, ובטיפוסים מ-assemblies אחרים גם את שם ה-assembly ("MyApp.Plugins.Csv, MyApp.Plugins").

אם המתודה שהופעלה זורקת חריגה, Invoke עוטף אותה ב-TargetInvocationException; החריגה המקורית נמצאת ב-InnerException שלה.

תכונות: תגיות שהקומפיילר ומסגרות העבודה קוראים

תכונה נכתבת בסוגריים מרובעים לפני הדבר שהיא מתארת. מסגרת העבודה מגדירה הרבה תכונות; כמה מהן משנות את מה שהקומפיילר עושה:

public class OrderService
{
    [Obsolete("Use PlaceOrderAsync instead.")]
    public void PlaceOrder(Order order) { }
    // Every call site: warning CS0618: 'OrderService.PlaceOrder(Order)' is obsolete: 'Use PlaceOrderAsync instead.'
    // [Obsolete("...", true)] makes it error CS0619 instead.

    [Conditional("DEBUG")]
    public void Trace(string message) => Console.WriteLine(message);
    // Calls to Trace are removed entirely from builds without the DEBUG symbol.
}

[Flags] enum Channels { None = 0, Email = 1, Sms = 2 }   // changes how ToString formats combinations
[Serializable] class Snapshot { }                     // marks a type for legacy binary serialization

אחרות נקראות על ידי ספריות בזמן ריצה: [JsonPropertyName] ו-[JsonIgnore] על ידי System.Text.Json, [Required] ו-[MaxLength] על ידי אימות המודלים של ASP.NET Core ועל ידי Entity Framework, [HttpGet("orders/{id}")] על ידי הניתוב של ASP.NET, [Fact] ו-[Test] על ידי מריצי בדיקות. התכונה עצמה לא עושה כלום; הקוד שמחפש אותה עושה.

השם ObsoleteAttribute מתקצר ל-[Obsolete] כשמחילים אותו: לפי המוסכמה כל שם של מחלקת תכונה מסתיים ב-Attribute, ו-C# מאפשרת להשמיט את הסיומת.

הצהרה על תכונה מותאמת וקריאתה

תכונה מותאמת היא מחלקה שנגזרת מ-Attribute. [AttributeUsage] אומר על מה מותר להחיל אותה. פרמטרים של הבנאי הופכים לארגומנטים לפי מיקום, ומאפיינים ציבוריים שאפשר להציב בהם הופכים לארגומנטים עם שם:

using System;
using System.Collections.Generic;
using System.Reflection;

[AttributeUsage(AttributeTargets.Property)]
class RequiredAttribute : Attribute { }

[AttributeUsage(AttributeTargets.Property)]
class MaxLengthAttribute : Attribute
{
    public int Length { get; }
    public string Message { get; set; }            // optional, set as a named argument
    public MaxLengthAttribute(int length) { Length = length; }
}

class SignupForm
{
    [Required, MaxLength(20)]
    public string Username { get; set; }

    [Required]
    public string Email { get; set; }

    [MaxLength(10, Message = "Keep the city code short")]
    public string CityCode { get; set; }
}

static class Validator
{
    public static List<string> Validate(object model)
    {
        var errors = new List<string>();
        foreach (PropertyInfo p in model.GetType().GetProperties())
        {
            var value = p.GetValue(model) as string;

            if (p.GetCustomAttribute<RequiredAttribute>() != null && string.IsNullOrWhiteSpace(value))
                errors.Add($"{p.Name} is required");

            var max = p.GetCustomAttribute<MaxLengthAttribute>();
            if (max != null && value != null && value.Length > max.Length)
                errors.Add(max.Message ?? $"{p.Name} must be at most {max.Length} characters");
        }
        return errors;
    }
}

class Program
{
    static void Main()
    {
        var form = new SignupForm { Username = "a_very_long_username_indeed", CityCode = "LISBON-CENTRAL" };
        foreach (var error in Validator.Validate(form))
            Console.WriteLine(error);

        var ok = new SignupForm { Username = "ana", Email = "ana@example.com", CityCode = "LIS" };
        Console.WriteLine(Validator.Validate(ok).Count);
    }
}

פלט:

Username must be at most 20 characters
Email is required
Keep the city code short
0

זו גרסה מוקטנת של מה שאימות המודלים של ASP.NET Core עושה עם System.ComponentModel.DataAnnotations. ארגומנטים של תכונות חייבים להיות קבועים בזמן קומפילציה (מספרים, מחרוזות, typeof(...), ערכי enum, או מערכים שלהם), כי הם נשמרים במטא-נתונים של ה-assembly. GetCustomAttribute<T>() היא מתודת הרחבה ב-System.Reflection; יש גם IsDefined(typeof(T)) כשצריך רק לדעת אם תכונה קיימת.

המחיר של reflection

reflection מחליף מהירות ובטיחות בגמישות:

• מהירות. חיפוש איבר לפי שם וקריאה לו דרך Invoke או GetValue איטיים בהרבה מקריאה ישירה, ומבצעים boxing לטיפוסי ערך. לשימוש חוזר, חפשו את ה-PropertyInfo או ה-MethodInfo פעם אחת ושמרו אותו, או הפכו אותו ל-delegate עם Delegate.CreateDelegate או MethodInfo.CreateDelegate וקראו לו.
• בטיחות. שם עם שגיאת כתיב או חתימה שהשתנתה מתקמפלים בלי בעיה ונכשלים בזמן ריצה. העדיפו את nameof(Product.Price) על פני המחרוזת "Price" בכל מקום אפשרי, כך ששינויי שמות ייתפסו.
• Trimming ו-AOT. אפליקציות עם trimming ו-Native AOT מסירות איברים שנראה שאף אחד לא משתמש בהם, ו-reflection מסתיר שימוש מהניתוח הזה. ספריות מודרניות (System.Text.Json, GeneratedRegex, לוגים) עוברות ל-source generators, שעושים את אותה עבודה בזמן קומפילציה.

השתמשו ב-reflection לחלקים של תוכנית שבאמת לא מכירים מראש את הטיפוסים שלהם: תוספים, כלים גנריים, סריאלייזרים, עזרים לבדיקות. כשהטיפוסים ידועים, קוד רגיל, generics או ממשקים מהירים יותר ונבדקים על ידי הקומפיילר.

טעויות נפוצות

• GetType() == typeof(Base) כדי לבדוק מחלקת בסיס. זה נכשל עבור טיפוסים נגזרים. השתמשו ב-is או ב-IsAssignableFrom.
• אי בדיקה של null. GetProperty, GetMethod ו-Type.GetType מחזירים null כששום דבר לא מתאים.
• reflection בלולאה חמה בלי שמירה במטמון. שמרו את ה-MemberInfo או קמפלו delegate.
• תפיסה של החריגה הלא נכונה מ-Invoke. החריגה האמיתית היא ה-InnerException של TargetInvocationException.
• מחרוזות קסם לשמות איברים. השתמשו ב-nameof.