Refleksja i atrybuty w C#: typeof, GetType i własne atrybuty

Refleksja (reflection) pozwala programowi badać typy w trakcie działania: jakie właściwości ma klasa, jakie mają wartości, jakie metody istnieją, jakie atrybuty są dołączone. Atrybuty to druga połowa: deklaratywne znaczniki w nawiasach kwadratowych, takie jak [Obsolete] czy [JsonPropertyName("id")], które same w sobie nic nie znaczą, dopóki kompilator albo jakiś kod nie odczyta ich przez refleksję. Tak działają serializatory, ORM-y, biblioteki walidacji, frameworki testowe i routing w ASP.NET.

Większość kodu aplikacji rzadko potrzebuje refleksji bezpośrednio, ale wiedza o tym, jak działa, wyjaśnia wiele zachowań frameworków.

Obiekty Type: typeof i GetType

Wszystko zaczyna się od System.Type. Są dwa sposoby, żeby go zdobyć:

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
    }
}

Wynik:

Employee
Manager
Employee
False
True
True
System.Int32
False
Name

Różnica do zapamiętania: typeof(X) nazywa typ, który znasz w chwili pisania kodu, a obj.GetType() pyta obiekt, czym naprawdę jest. Porównanie GetType() == typeof(Employee) to dokładne dopasowanie, które zawodzi dla klas pochodnych, a zwykle nie o to chodzi; is i IsAssignableFrom respektują dziedziczenie. nameof wygląda podobnie, ale w ogóle nie jest refleksją: kompilator zastępuje je stałą tekstową.

GetType() na referencji null rzuca NullReferenceException, bo nie ma obiektu, którego można by zapytać. Na opakowanym typie wartościowym nullable zwraca typ bazowy: ((int?)5).GetType() to System.Int32.

Odczyt i ustawianie właściwości

GetProperties() wypisuje publiczne właściwości typu jako obiekty PropertyInfo, z których każdy potrafi odczytać i zapisać wartość na danej instancji:

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));
    }
}

Wynik:

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

Ten przykład pokazuje trzy rzeczy:

• GetValue zwraca object, więc typy wartościowe wracają opakowane i żeby ich użyć, trzeba je rzutować.
• GetProperty z nazwą, która nie istnieje, zwraca null, a następne wywołanie na tym wyniku rzuca NullReferenceException. Sprawdzaj przed użyciem.
• BindingFlags.NonPublic | BindingFlags.Instance sięga do prywatnych składowych. W narzędziach i testach jest to uzasadnione, ale omija hermetyzację i po cichu psuje się przy refaktoryzacji klasy.

Ta pętla to w zasadzie sposób działania eksportera CSV albo serializatora obiektów do JSON: przejdź po właściwościach, odczytaj każdą wartość i ją sformatuj.

Wywoływanie metod i tworzenie obiektów po nazwie

GetMethod znajduje metodę, a Invoke wywołuje ją z tablicą argumentów. Activator.CreateInstance tworzy obiekt na podstawie Type; tak systemy wtyczek i kontenery DI budują typy wybrane w czasie działania:

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);
    }
}

Wynik:

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

DeclaredOnly ogranicza listę do składowych zadeklarowanych w samej klasie; bez tego GetMethods zwraca też ToString, Equals, GetHashCode i GetType z object. Type.GetType("Name") wymaga nazwy kwalifikowanej przestrzenią nazw, a dla typów z innych assembly także nazwy assembly ("MyApp.Plugins.Csv, MyApp.Plugins").

Jeśli wywołana metoda rzuci wyjątek, Invoke opakowuje go w TargetInvocationException; oryginał znajduje się w jego InnerException.

Atrybuty: znaczniki czytane przez kompilator i frameworki

Atrybut zapisuje się w nawiasach kwadratowych przed elementem, który opisuje. Framework definiuje ich wiele; oto kilka, które zmieniają działanie kompilatora:

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

Inne są odczytywane przez biblioteki w czasie działania: [JsonPropertyName] i [JsonIgnore] przez System.Text.Json, [Required] i [MaxLength] przez walidację modeli w ASP.NET Core i Entity Framework, [HttpGet("orders/{id}")] przez routing ASP.NET, [Fact] i [Test] przez narzędzia uruchamiające testy. Sam atrybut nic nie robi; robi to kod, który go szuka.

Nazwa ObsoleteAttribute skraca się przy zastosowaniu do [Obsolete]: zgodnie z konwencją nazwa każdej klasy atrybutu kończy się na Attribute, a C# pozwala pominąć ten przyrostek.

Deklarowanie i odczyt własnego atrybutu

Własny atrybut to klasa dziedzicząca po Attribute. [AttributeUsage] określa, do czego można go zastosować. Parametry konstruktora stają się argumentami pozycyjnymi, a publiczne właściwości z setterem argumentami nazwanymi:

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);
    }
}

Wynik:

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

To miniaturowa wersja tego, co robi walidacja modeli w ASP.NET Core z System.ComponentModel.DataAnnotations. Argumenty atrybutów muszą być stałymi czasu kompilacji (liczbami, stringami, typeof(...), wartościami enumów albo ich tablicami), bo są przechowywane w metadanych assembly. GetCustomAttribute<T>() to metoda rozszerzająca z System.Reflection; jest też IsDefined(typeof(T)), gdy chcesz tylko wiedzieć, czy atrybut jest obecny.

Koszt refleksji

Refleksja wymienia szybkość i bezpieczeństwo na elastyczność:

• Szybkość. Wyszukanie składowej po nazwie i wywołanie jej przez Invoke albo GetValue jest dużo wolniejsze od bezpośredniego wywołania i opakowuje typy wartościowe. Przy wielokrotnym użyciu wyszukaj PropertyInfo albo MethodInfo raz i go zachowaj, albo zamień go w delegata za pomocą Delegate.CreateDelegate lub MethodInfo.CreateDelegate i wywołuj właśnie jego.
• Bezpieczeństwo. Literówka w nazwie albo zmieniona sygnatura kompilują się bez problemu i zawodzą w czasie działania. Gdzie tylko się da, wybieraj nameof(Product.Price) zamiast stringa "Price", żeby zmiany nazw zostały wyłapane.
• Trimming i AOT. Aplikacje przycinane (trimmed) i Native AOT usuwają składowe, których pozornie nic nie używa, a refleksja ukrywa użycie przed tą analizą. Nowoczesne biblioteki (System.Text.Json, GeneratedRegex, logowanie) przechodzą na generatory źródeł, które wykonują tę samą pracę w czasie kompilacji.

Używaj refleksji w tych częściach programu, które naprawdę nie znają swoich typów z góry: we wtyczkach, ogólnych narzędziach, serializatorach i pomocnikach testowych. Gdy typy są znane, zwykły kod, typy generyczne albo interfejsy są szybsze i sprawdzane przez kompilator.

Typowe błędy

• GetType() == typeof(Base) do sprawdzania klasy bazowej. Zawodzi dla typów pochodnych. Użyj is albo IsAssignableFrom.
• Brak sprawdzenia null. GetProperty, GetMethod i Type.GetType zwracają null, gdy nic nie pasuje.
• Refleksja w gorącej pętli bez zapamiętywania. Zapamiętaj MemberInfo albo skompiluj delegata.
• Przechwytywanie niewłaściwego wyjątku z Invoke. Prawdziwy wyjątek to InnerException wyjątku TargetInvocationException.
• Magiczne stringi jako nazwy składowych. Używaj nameof.