Отражение в C# и динамическое управление типами

// Неэффективно: повторное получение MethodInfo при каждом вызове
public object InvokeMethodBad(object instance, string methodName) 
{
    return instance.GetType().GetMethod(methodName).Invoke(instance, null);
}
 
// Эффективно: кэширование MethodInfo
private static ConcurrentDictionary<(Type, string), MethodInfo> _methodCache = 
    new ConcurrentDictionary<(Type, string), MethodInfo>();
 
public object InvokeMethodGood(object instance, string methodName) 
{
    var type = instance.GetType();
    var methodInfo = _methodCache.GetOrAdd((type, methodName), 
        key => key.Item1.GetMethod(key.Item2));
    return methodInfo.Invoke(instance, null);
}

// Получение типа от конкретного экземпляра
Type type1 = myObject.GetType();
 
// Получение типа напрямую, используя оператор typeof
Type type2 = typeof(MyClass);
 
// Получение типа по имени (во время выполнения)
Type type3 = Type.GetType("Namespace.MyClass");

ConstructorInfo  // Представляет конструкторы
MethodInfo       // Обычные методы
PropertyInfo     // Свойства
FieldInfo        // Поля
EventInfo        // События
TypeInfo         // Расширенная информация о типе

// Потенциально опасный код: изменение приватного поля
var field = typeof(SecureClass).GetField("_sensitiveData", 
    BindingFlags.NonPublic | BindingFlags.Instance);
field.SetValue(secureInstance, "compromizedData");

// Три способа получить Type
Type byInstance = myObject.GetType();
Type byTypeOf = typeof(MyClass);
Type byName = Type.GetType("MyNamespace.MyClass");
 
// Исследование методов
MethodInfo[] methods = byTypeOf.GetMethods(BindingFlags.Public | BindingFlags.Instance);
foreach (var method in methods)
{
    Console.WriteLine($"Метод: {method.Name}, возвращает {method.ReturnType.Name}");
    
    // Исследуем параметры
    foreach (var param in method.GetParameters())
    {
        Console.WriteLine($"  Параметр: {param.Name} ({param.ParameterType.Name})");
    }
}

// Создание экземпляра по типу
object instance = Activator.CreateInstance(myType);
 
// Создание с использованием конкретного конструктора
ConstructorInfo ctor = myType.GetConstructor(new Type[] { typeof(string), typeof(int) });
object instanceWithParams = ctor.Invoke(new object[] { "Имя", 42 });

// Вызов метода
MethodInfo method = myType.GetMethod("CalculateValue");
object result = method.Invoke(instance, new object[] { 10, "data" });
 
// Работа со свойством
PropertyInfo property = myType.GetProperty("Name");
property.SetValue(instance, "Новое имя");
string name = (string)property.GetValue(instance);

// Доступ к приватному полю
FieldInfo privateField = myType.GetField("_secretValue", 
BindingFlags.NonPublic | BindingFlags.Instance);
int secretValue = (int)privateField.GetValue(instance);
privateField.SetValue(instance, 42);
 
// Вызов приватного метода
MethodInfo privateMethod = myType.GetMethod("InternalProcess", 
BindingFlags.NonPublic | BindingFlags.Instance);
privateMethod.Invoke(instance, new object[] { "data" });

// Получаем информацию о событии
EventInfo eventInfo = myType.GetEvent("DataChanged");
 
// Создаём делегат, соответствующий сигнатуре события
Type handlerType = eventInfo.EventHandlerType;
MethodInfo handlerMethod = typeof(MyClass).GetMethod("OnDataChanged");
Delegate handler = Delegate.CreateDelegate(handlerType, this, handlerMethod);
 
// Подписываемся на событие
MethodInfo addMethod = eventInfo.GetAddMethod();
addMethod.Invoke(instance, new object[] { handler });

try 
{
methodInfo.Invoke(instance, parameters);
} 
catch (TargetInvocationException ex) 
{
// Извлекаем и обрабатываем реальное исключение
Exception realException = ex.InnerException;
Console.WriteLine($"Метод вызвал исключение: {realException.Message}");
}

// Получение обобщённого определения типа
Type genericType = typeof(List<>);
 
// Создание конкретного типа на основе обобщённого
Type concreteType = genericType.MakeGenericType(typeof(string));
 
// Создание экземпляра обобщённого типа
object listInstance = Activator.CreateInstance(concreteType);

// Определяем кастомный атрибут
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public class DocumentationAttribute : Attribute
{
    public string Description { get; }
    public string Version { get; }
    
    public DocumentationAttribute(string description, string version = "1.0")
    {
        Description = description;
        Version = version;
    }
}
 
// Применяем его к классу
[Documentation("Сервис для работы с данными", "2.1")]
public class DataService
{
    // И к методу
    [Documentation("Загружает данные из указаного источника")]
    public void LoadData(string source) { /* ... */ }
}
 
// Получаем информацию об атрибутах через рефлексию
Type serviceType = typeof(DataService);
var classAttrs = serviceType.GetCustomAttributes(typeof(DocumentationAttribute), false);
if (classAttrs.Length > 0)
{
    var docAttr = (DocumentationAttribute)classAttrs[0];
    Console.WriteLine($"Класс: {docAttr.Description}, версия {docAttr.Version}");
}
 
// Получаем атрибуты метода
MethodInfo methodInfo = serviceType.GetMethod("LoadData");
var methodAttrs = methodInfo.GetCustomAttributes<DocumentationAttribute>();
foreach (var attr in methodAttrs)
{
    Console.WriteLine($"Метод: {attr.Description}");
}

// Простое кэширование метаданных
public static class TypeMetadataCache
{
    private static readonly MethodInfo _parseMethod = typeof(int).GetMethod(
        "Parse", new[] { typeof(string) });
 
    public static MethodInfo ParseMethod => _parseMethod;
}

// Продвинутое кэширование с ConcurrentDictionary
private static readonly ConcurrentDictionary<string, PropertyInfo> _propertyCache 
    = new ConcurrentDictionary<string, PropertyInfo>();
 
public static PropertyInfo GetPropertyCached(Type type, string propertyName)
{
    string key = $"{type.FullName}.{propertyName}";
    return _propertyCache.GetOrAdd(key, _ => type.GetProperty(propertyName));
}

// Получаем информацию о методе
MethodInfo methodInfo = typeof(Math).GetMethod("Max", new[] { typeof(int), typeof(int) });
 
// Создаём типизированный делегат
var maxDelegate = (Func<int, int, int>)Delegate.CreateDelegate(
    typeof(Func<int, int, int>), methodInfo);
 
// Вызываем делегат напрямую - намного быстрее, чем MethodInfo.Invoke
int result = maxDelegate(42, 99);

// Для метода экземпляра
MethodInfo substringMethod = typeof(string).GetMethod("Substring", new[] { typeof(int), typeof(int) });
var text = "Привет, мир!";
 
// Создаём делегат, привязанный к конкретному экземпляру
var substringDelegate = (Func<int, int, string>)Delegate.CreateDelegate(
    typeof(Func<int, int, string>), text, substringMethod);
 
// Вызываем без указания экземпляра - он уже "вшит" в делегат
string sub = substringDelegate(0, 6); // "Привет"

// Создаём динамический метод
DynamicMethod dm = new DynamicMethod(
    "AddNumbers",               // имя (не обязательно уникальное)
    typeof(int),                // возвращаемый тип
    new[] { typeof(int), typeof(int) },  // типы параметров
    typeof(Program).Module);    // модуль, с которым ассоциируется метод
 
// Получаем генератор IL-кода
ILGenerator il = dm.GetILGenerator();
 
// Генерируем инструкции IL
il.Emit(OpCodes.Ldarg_0);  // загружаем первый аргумент
il.Emit(OpCodes.Ldarg_1);  // загружаем второй аргумент
il.Emit(OpCodes.Add);      // складываем их
il.Emit(OpCodes.Ret);      // возвращаем результат
 
// Создаём делегат из динамического метода
var addDelegate = (Func<int, int, int>)dm.CreateDelegate(typeof(Func<int, int, int>));
 
// Вызываем как обычный делегат
int sum = addDelegate(40, 2); // 42

public string Serialize<T>(T obj)
{
    var result = new Dictionary<string, object>();
    Type type = typeof(T);
    
    // Обходим все публичные свойства
    foreach (var prop in type.GetProperties())
    {
        // Получаем значение свойства и добавляем в результирующий словарь
        var value = prop.GetValue(obj);
        result[prop.Name] = value;
    }
    
    return JsonSerializer.Serialize(result);
}
 
public T Deserialize<T>(string json) where T : new()
{
    var data = JsonSerializer.Deserialize<Dictionary<string, object>>(json);
    T result = new T();
    Type type = typeof(T);
    
    foreach (var prop in type.GetProperties())
    {
        if (data.TryGetValue(prop.Name, out var value))
        {
            // Конвертируем и устанавливаем значение
            prop.SetValue(result, Convert.ChangeType(value, prop.PropertyType));
        }
    }
    
    return result;
}

public List<IPlugin> LoadPlugins(string pluginsPath)
{
    var pluginInterface = typeof(IPlugin);
    var plugins = new List<IPlugin>();
 
    // Проверяем каждый файл в директории плагинов
    foreach (var file in Directory.GetFiles(pluginsPath, "*.dll"))
    {
        try
        {
            // Загружаем сборку
            var assembly = Assembly.LoadFrom(file);
            
            // Ищем типы, реализующие IPlugin
            var pluginTypes = assembly.GetTypes()
                .Where(t => pluginInterface.IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract);
                
            // Создаём экземпляры найденых типов
            foreach (var type in pluginTypes)
            {
                var plugin = (IPlugin)Activator.CreateInstance(type);
                plugins.Add(plugin);
            }
        }
        catch (Exception ex)
        {
            // Логируем ошибку и продолжаем с другими плагинами
            Console.WriteLine($"Ошибка загрузки плагина {file}: {ex.Message}");
        }
    }
    
    return plugins;
}

public object Resolve(Type type)
{
    // Получаем подходящий конструктор через рефлексию
    var constructor = type.GetConstructors()
        .OrderByDescending(c => c.GetParameters().Length)
        .First();
    
    // Для каждого параметра рекурсивно создаём зависимость
    var parameters = constructor.GetParameters()
        .Select(param => Resolve(GetImplementationType(param.ParameterType)))
        .ToArray();
    
    // Создаём и возвращаем экземпляр объекта
    return constructor.Invoke(parameters);
}
 
private Type GetImplementationType(Type abstractType)
{
    // Ищем зарегистрированную реализацию
    return _registrations.TryGetValue(abstractType, out var implementationType)
        ? implementationType
        : abstractType;
}

var mock = new Mock<IDataRepository>();
mock.Setup(m => m.GetUserById(42)).Returns(new User { Id = 42, Name = "Тестовый" });
 
// Использование мока в тестах
var service = new UserService(mock.Object);
var user = service.FindUser(42);
 
// Проверка вызовов
mock.Verify(m => m.GetUserById(42), Times.Once());

// Тестирование приватного метода
var privateMethod = typeof(Calculator).GetMethod("CalculateDiscount", 
BindingFlags.NonPublic | BindingFlags.Instance);
var instance = new Calculator();
var result = (decimal)privateMethod.Invoke(instance, new object[] { 100m, 0.2m });
Assert.AreEqual(80m, result);

dynamic obj = GetUnknownObject();
string result = obj.SomeMethod("param");  // Проверка существования метода откладывается до рантайма

// Создаем выражение, представляющее лямбду x => x + 1
ParameterExpression param = Expression.Parameter(typeof(int), "x");
Expression body = Expression.Add(param, Expression.Constant(1));
Expression<Func<int, int>> expr = Expression.Lambda<Func<int, int>>(body, param);
 
// Компилируем в исполняемый код
Func<int, int> increment = expr.Compile();
 
// Используем как обычную функцию
int result = increment(41);  // 42

dynamic person = new ExpandoObject();
person.Name = "Александр";
person.Age = 30;
person.SayHello = new Action(() => Console.WriteLine($"Привет, меня зовут {person.Name}"));
person.SayHello();  // Вызов динамически добавленного метода

public class DynamicRepository : DynamicObject
{
private Dictionary<string, object> _storage = new Dictionary<string, object>();
 
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
    return _storage.TryGetValue(binder.Name, out result);
}
 
public override bool TrySetMember(SetMemberBinder binder, object value)
{
    _storage[binder.Name] = value;
    return true;
}
}

// Создаём маппер из UserDto в User
public static Func<UserDto, User> CreateMapper()
{
    // Параметр для UserDto
    var parameter = Expression.Parameter(typeof(UserDto), "dto");
    
    // Создаём новый User с установленными свойствами
    var memberBindings = new List<MemberBinding>
    {
        Expression.Bind(
            typeof(User).GetProperty("Id"),
            Expression.Property(parameter, typeof(UserDto).GetProperty("Id"))
        ),
        Expression.Bind(
            typeof(User).GetProperty("Name"),
            Expression.Property(parameter, typeof(UserDto).GetProperty("FullName"))
        )
    };
    
    // Создаём выражение для инициализации объекта с привязками
    var initializer = Expression.MemberInit(
        Expression.New(typeof(User)), 
        memberBindings
    );
    
    // Компилируем в функцию
    return Expression.Lambda<Func<UserDto, User>>(initializer, parameter).Compile();
}
 
// Использование
var mapper = CreateMapper();
User user = mapper(userDto); // Быстро, как обычный код!

public static Expression<Func<User, bool>> BuildSearchExpression(string name, int? minAge)
{
    var parameter = Expression.Parameter(typeof(User), "u");
    Expression body = Expression.Constant(true);
    
    if (!string.IsNullOrEmpty(name))
    {
        var nameProperty = Expression.Property(parameter, "Name");
        var nameConstant = Expression.Constant(name);
        var nameContains = Expression.Call(nameProperty, "Contains", null, nameConstant);
        body = Expression.AndAlso(body, nameContains);
    }
    
    if (minAge.HasValue)
    {
        var ageProperty = Expression.Property(parameter, "Age");
        var ageConstant = Expression.Constant(minAge.Value);
        var ageComparison = Expression.GreaterThanOrEqual(ageProperty, ageConstant);
        body = Expression.AndAlso(body, ageComparison);
    }
    
    return Expression.Lambda<Func<User, bool>>(body, parameter);
}
 
// Использование с Entity Framework или LINQ-to-Objects
var expr = BuildSearchExpression("Алекс", 25);
var matchingUsers = dbContext.Users.Where(expr);

// Анализ исходного кода с помощью Roslyn
SyntaxTree tree = CSharpSyntaxTree.ParseText(@"
class MyClass { 
    void MyMethod() { } 
}");
 
var root = tree.GetRoot();
var classDeclaration = root.DescendantNodes().OfType<ClassDeclarationSyntax>().First();
var methodDeclaration = classDeclaration.DescendantNodes().OfType<MethodDeclarationSyntax>().First();
 
// Получаем имя метода из синтаксического дерева
string methodName = methodDeclaration.Identifier.Text; // "MyMethod"

// Генерация прокси-классов на основе интерфейсов в сборке
var assembly = Assembly.LoadFrom("MyAssembly.dll");
var interfaces = assembly.GetTypes().Where(t => t.IsInterface);
 
foreach (var interfaceType in interfaces)
{
    // Формируем синтаксическое дерево для прокси-класса
    var classCode = $@"
    public class {interfaceType.Name}Proxy : {interfaceType.FullName}
    {{
        // Реализация интерфейса
    }}";
    
    // Компилируем сгенерированный код с помощью Roslyn
    var syntaxTree = CSharpSyntaxTree.ParseText(classCode);
    // ...продолжение компиляции...
}

// Традиционная рефлексия
object obj = GetObject();
Type type = obj.GetType();
MethodInfo method = type.GetMethod("ProcessData");
object result = method.Invoke(obj, new object[] { "input" });
 
// Тот же код с dynamic
dynamic dynObj = GetObject();
var result = dynObj.ProcessData("input");

string json = @"{ ""Name"": ""Алексей"", ""Age"": 30 }";
dynamic person = JsonConvert.DeserializeObject(json);
Console.WriteLine($"{person.Name} - {person.Age} лет");