Рефлексия и атрибуты в C#: typeof, GetType и собственные атрибуты

Рефлексия позволяет программе исследовать типы во время работы: какие свойства есть у класса, каковы их значения, какие существуют методы, какие атрибуты прикреплены. Атрибуты это вторая половина: декларативные метки в квадратных скобках вроде [Obsolete] или [JsonPropertyName("id")], которые сами по себе ничего не значат, пока их не прочитает компилятор или какой-то код через рефлексию. Так работают сериализаторы, ORM, библиотеки проверки, фреймворки тестирования и маршрутизация ASP.NET.

Большинству прикладного кода рефлексия напрямую нужна редко, но понимание её работы объясняет многое в поведении фреймворков.

Объекты 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 выглядит похоже, но это вообще не рефлексия: компилятор заменяет его строковой константой.

GetType() у ссылки null выбрасывает NullReferenceException, поскольку спрашивать некого. У упакованного типа значения, допускающего null, он возвращает базовый тип: ((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, поэтому типы значений возвращаются упакованными, и для использования их нужно привести.
• GetProperty с несуществующим именем возвращает null, и следующий вызов на нём выбрасывает NullReferenceException. Проверяйте перед использованием.
• BindingFlags.NonPublic | BindingFlags.Instance добирается до закрытых членов. Это законно в инструментах и тестах, но обходит инкапсуляцию и молча ломается при рефакторинге класса.

Этот цикл по сути и есть то, как работает экспорт в CSV или сериализатор объектов в JSON: пройти по свойствам, прочитать каждое значение, отформатировать его.

Вызов методов и создание объектов по имени

GetMethod находит метод, а Invoke вызывает его с массивом аргументов. Activator.CreateInstance создаёт объект по Type, и так системы плагинов и контейнеры внедрения зависимостей строят типы, выбранные во время выполнения:

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") требует имени с пространством имён, а для типов из других сборок ещё и имени сборки ("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(...), значения перечислений или массивы из них), потому что они хранятся в метаданных сборки. GetCustomAttribute<T>() это метод расширения из System.Reflection; есть также IsDefined(typeof(T)), когда нужно лишь узнать, присутствует ли атрибут.

Цена рефлексии

Рефлексия обменивает скорость и безопасность на гибкость:

• Скорость. Поиск члена по имени и вызов через Invoke или GetValue намного медленнее прямого вызова и упаковывает типы значений. Для повторного использования найдите PropertyInfo или MethodInfo один раз и сохраните его или превратите в делегат через Delegate.CreateDelegate или MethodInfo.CreateDelegate и вызывайте его.
• Безопасность. Опечатка в имени или изменённая сигнатура нормально компилируются и падают во время выполнения. Везде, где можно, предпочитайте nameof(Product.Price) строке "Price", чтобы переименования ловились.
• Обрезка и AOT. Обрезанные приложения и приложения Native AOT удаляют члены, которые, как кажется, никто не использует, а рефлексия скрывает использование от этого анализа. Современные библиотеки (System.Text.Json, GeneratedRegex, логирование) переходят на генераторы исходного кода, которые делают ту же работу при компиляции.

Используйте рефлексию для тех частей программы, которые действительно заранее не знают своих типов: плагины, универсальные инструменты, сериализаторы, вспомогательные средства тестов. Когда типы известны, обычный код, обобщения или интерфейсы быстрее и проверяются компилятором.

Частые ошибки

• GetType() == typeof(Base) для проверки базового класса. Не срабатывает для производных типов. Используйте is или IsAssignableFrom.
• Нет проверки на null. GetProperty, GetMethod и Type.GetType возвращают null, когда ничего не найдено.
• Рефлексия в горячем цикле без кэширования. Кэшируйте MemberInfo или скомпилируйте делегат.
• Перехват не того исключения из Invoke. Настоящее исключение это InnerException у TargetInvocationException.
• Магические строки для имён членов. Используйте nameof.