Что такое Reflection?

Что такое Reflection (отражение) в C#?

Reflection — это механизм в .NET, позволяющий получать метаданные о типах, объектах, сборках и модулях во время выполнения программы, а также динамически создавать, исследовать и манипулировать этими типами и объектами. Это мощный инструмент для интроспекции кода, который открывает возможности, недоступные при статической компиляции.

Основные возможности Reflection

Reflection предоставляет доступ к следующей информации:

• Имя типа (полное, пространство имён, сборка).
• Модификаторы доступа (public, private, protected).
• Базовые классы и реализуемые интерфейсы.
• Члены типа: поля (FieldInfo), свойства (PropertyInfo), методы (MethodInfo), конструкторы (ConstructorInfo), события (EventInfo).
• Атрибуты (как стандартные, так и пользовательские), применённые к типу или его членам.

Ключевые классы в пространстве имён System.Reflection

Работа с отражением строится вокруг нескольких основных классов:

• Type — центральный класс, представляющий объявление типа (класс, интерфейс, массив и т.д.). Получить экземпляр Type можно несколькими способами:

  // Через оператор typeof (статически известный тип)
  Type type1 = typeof(string);
  
  // Через экземпляр объекта
  string str = "test";
  Type type2 = str.GetType();
  
  // Через имя типа (полное или частичное)
  Type type3 = Type.GetType("System.String");
  

• Assembly — представляет сборку (.dll или .exe файл). Через него можно загружать сборки динамически и исследовать содержащиеся в них типы.

  // Загрузка сборки и получение всех её типов
  Assembly assembly = Assembly.LoadFrom("MyLibrary.dll");
  Type[] allTypes = assembly.GetTypes();
  

• MethodInfo, PropertyInfo, FieldInfo и др. — классы, предоставляющие детальную информацию о соответствующих членах типа и позволяющие их использовать.

Практическое применение Reflection

1. Динамический вызов методов и доступ к членам

Reflection позволяет вызывать методы или получать/устанавливать значения полей и свойств, имена которых неизвестны на этапе компиляции.

using System.Reflection;

public class Calculator
{
    private int _value = 10;
    public int Add(int a, int b) => a + b;
}

class Program
{
    static void Main()
    {
        Calculator calc = new Calculator();
        Type calcType = calc.GetType();

        // Вызов публичного метода
        MethodInfo addMethod = calcType.GetMethod("Add");
        object result = addMethod.Invoke(calc, new object[] { 5, 3 });
        Console.WriteLine($"Результат Add: {result}"); // 8

        // Доступ к приватному полю
        FieldInfo valueField = calcType.GetField("_value", BindingFlags.NonPublic | BindingFlags.Instance);
        int currentValue = (int)valueField.GetValue(calc);
        Console.WriteLine($"Приватное поле _value: {currentValue}"); // 10

        // Изменение приватного поля
        valueField.SetValue(calc, 20);
        Console.WriteLine($"Новое значение _value: {calc.GetType().GetField("_value", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(calc)}"); // 20
    }
}

2. Работа с атрибутами

Reflection — основной способ чтения метаданных, заданных атрибутами.

[AttributeUsage(AttributeTargets.Class)]
public class DescriptionAttribute : Attribute
{
    public string Text { get; }
    public DescriptionAttribute(string text) => Text = text;
}

[Description("Это важный класс для расчётов")]
public class ImportantClass { }

class Program
{
    static void Main()
    {
        Type type = typeof(ImportantClass);
        var attribute = type.GetCustomAttribute<DescriptionAttribute>();
        if (attribute != null)
        {
            Console.WriteLine($"Описание класса: {attribute.Text}");
        }
    }
}

3. Динамическое создание объектов

Можно создавать экземпляры типов, даже если их тип неизвестен на этапе компиляции, используя конструкторы.

Type stringType = typeof(string);
// Создание строки через конструктор char[]
ConstructorInfo ctor = stringType.GetConstructor(new[] { typeof(char[]) });
object strInstance = ctor.Invoke(new object[] { new char[] { 'H', 'i' } });
Console.WriteLine(strInstance); // Hi

Когда использовать Reflection?

• Плагинные архитектуры и IoC/DI-контейнеры: для сканирования сборок и поиска реализаций интерфейсов.
• Сериализация/десериализация: многие библиотеки (например, JSON.NET) используют Reflection для анализа структуры объектов.
• ORM (Object-Relational Mappers): такие как Entity Framework, используют Reflection для маппинга свойств классов на колонки таблиц БД.
• Юнит-тестирование и системы мониторинга: для автоматического обнаружения тестов или сбора метрик.
• Динамическое создание прокси-объектов и AOP (Aspect-Oriented Programming).

Критические недостатки и предостережения

• Производительность: операции Reflection значительно медленнее прямых вызовов кода из-за накладных расходов на проверки и динамическое разрешение. В критичных к производительности местах следует избегать или кэшировать объекты MethodInfo/PropertyInfo.
• Безопасность: Reflection может обходить инкапсуляцию (доступ к private членам), что требует соответствующего уровня доверия (permissions).
• Сложность отладки: код, использующий Reflection, сложнее отлаживать и поддерживать, так как многие ошибки (например, отсутствие метода) возникают только во время выполнения.
• Стабильность к рефакторингу: имена методов и типов, передаваемые как строки, не проверяются компилятором и могут сломаться при переименовании.

Альтернативы в современных версиях C#

Для сценариев, где критична производительность, в более новых версиях C# появились альтернативы:

• Expression Trees: позволяют строить код динамически, но с последующей компиляцией в делегаты, что работает быстрее чистого Reflection.
• Динамическая типизация (dynamic): упрощает синтаксис для вызова членов, но всё равно использует Reflection под капотом.
• Генерация исходного кода (Source Generators в .NET 5+): позволяет перенести часть "рефлексивной" логики на этап компиляции, что даёт максимальную производительность.

Вывод: Reflection — это чрезвычайно мощный инструмент для метапрограммирования в C#, который открывает двери для создания гибких и расширяемых архитектур. Однако его следует применять обдуманно, учитывая серьёзные компромиссы в производительности и поддерживаемости кода, и там, где его использование действительно оправдано архитектурными требованиями.