// Потрібно встановити 1000 властивостей User з ResultSet бази даних
for (int i = 0; i < 1000; i++)
{
    PropertyInfo prop = typeof(User).GetProperty("Name");
    prop.SetValue(users[i], resultSet[i].Name); // ❌ ПОВІЛЬНО
}

using System.Linq.Expressions;

// Звичайний делегат (компілюється в IL одразу)
Func<int, int, int> add = (a, b) => a + b;

// Expression Tree (представлення коду як даних)
Expression<Func<int, int, int>> addExpr = (a, b) => a + b;

// Можна інспектувати структуру
Console.WriteLine(addExpr.Body); // "(a + b)"
Console.WriteLine(addExpr.Body.NodeType); // Add

using System.Linq.Expressions;
using System.Reflection;

// 1. Визначити параметр
ParameterExpression userParam = Expression.Parameter(typeof(User), "user");

// 2. Доступ до властивості
PropertyInfo nameProp = typeof(User).GetProperty("Name")!;
MemberExpression nameAccess = Expression.Property(userParam, nameProp);

// 3. Створити лямбду
Expression<Func<User, string>> lambda =
    Expression.Lambda<Func<User, string>>(nameAccess, userParam);

// 4. Компілювати в делегат
Func<User, string> compiledGetter = lambda.Compile();

// 5. Використати (швидко, як прямий виклик)
User user = new() { Name = "Alice" };
string name = compiledGetter(user); // "Alice"

// Параметри
ParameterExpression userParam = Expression.Parameter(typeof(User), "user");
ParameterExpression valueParam = Expression.Parameter(typeof(string), "value");

// Доступ до властивості
MemberExpression nameProperty = Expression.Property(userParam, "Name");

// Присвоєння
BinaryExpression assignment = Expression.Assign(nameProperty, valueParam);

// Лямбда
Expression<Action<User, string>> lambda =
    Expression.Lambda<Action<User, string>>(assignment, userParam, valueParam);

// Компіляція
Action<User, string> compiledSetter = lambda.Compile();

// Використання
User user = new();
compiledSetter(user, "Bob"); // user.Name = "Bob"
Console.WriteLine(user.Name); // "Bob"

using BenchmarkDotNet.Attributes;
using System.Linq.Expressions;
using System.Reflection;

[MemoryDiagnoser]
public class PropertyAccessBenchmark
{
    private User _user = new() { Name = "Test" };
    private PropertyInfo _propertyInfo = typeof(User).GetProperty("Name")!;
    private Func<User, string> _compiledGetter;

    public PropertyAccessBenchmark()
    {
        // Compile once
        var param = Expression.Parameter(typeof(User));
        var property = Expression.Property(param, _propertyInfo);
        var lambda = Expression.Lambda<Func<User, string>>(property, param);
        _compiledGetter = lambda.Compile();
    }

    [Benchmark(Baseline = true)]
    public string DirectAccess() => _user.Name;

    [Benchmark]
    public string ReflectionCached() => (string)_propertyInfo.GetValue(_user)!;

    [Benchmark]
    public string ReflectionUncached()
    {
        var prop = typeof(User).GetProperty("Name")!;
        return (string)prop.GetValue(_user)!;
    }

    [Benchmark]
    public string CompiledExpression() => _compiledGetter(_user);
}

ParameterExpression userParam = Expression.Parameter(typeof(User), "user");
MethodInfo toStringMethod = typeof(object).GetMethod("ToString")!;

// Виклик методу на об'єкті
MethodCallExpression methodCall = Expression.Call(userParam, toStringMethod);

var lambda = Expression.Lambda<Func<User, string>>(methodCall, userParam);
Func<User, string> compiled = lambda.Compile();

User user = new() { Name = "Alice" };
Console.WriteLine(compiled(user)); // "User { Name = Alice }"

MethodInfo parseMethod = typeof(int).GetMethod("Parse", new[] { typeof(string) })!;
ConstantExpression input = Expression.Constant("42");

// Статичний виклик (obj = null)
MethodCallExpression parseCall = Expression.Call(null, parseMethod, input);

var lambda = Expression.Lambda<Func<int>>(parseCall);
Func<int> compiled = lambda.Compile();

int result = compiled(); // 42

ParameterExpression x = Expression.Parameter(typeof(int), "x");
ConstantExpression five = Expression.Constant(5);
ConstantExpression big = Expression.Constant("big");
ConstantExpression small = Expression.Constant("small");

BinaryExpression condition = Expression.GreaterThan(x, five);
ConditionalExpression ternary = Expression.Condition(condition, big, small);

var lambda = Expression.Lambda<Func<int, string>>(ternary, x);
Func<int, string> compiled = lambda.Compile();

Console.WriteLine(compiled(10)); // "big"
Console.WriteLine(compiled(3));  // "small"

public static class FastActivator<T>
{
    private static readonly Func<T> _factory;

    static FastActivator()
    {
        Type type = typeof(T);
        ConstructorInfo ctor = type.GetConstructor(Type.EmptyTypes)!;

        // Expression: () => new T()
        NewExpression newExpr = Expression.New(ctor);
        var lambda = Expression.Lambda<Func<T>>(newExpr);
        _factory = lambda.Compile();
    }

    public static T Create() => _factory();
}

// Benchmark
[Benchmark(Baseline = true)]
public User ActivatorCreate() => Activator.CreateInstance<User>();

[Benchmark]
public User FastActivatorCreate() => FastActivator<User>.Create();

using System.Linq.Expressions;

// Замінити всі константи на подвоєні значення
public class DoubleConstantsVisitor : ExpressionVisitor
{
    protected override Expression VisitConstant(ConstantExpression node)
    {
        if (node.Type == typeof(int))
        {
            int value = (int)node.Value!;
            return Expression.Constant(value * 2);
        }
        return base.VisitConstant(node);
    }
}

// Використання
Expression<Func<int, int>> original = x => x + 5;
DoubleConstantsVisitor visitor = new();
Expression modified = visitor.Visit(original);

Func<int, int> compiled = ((Expression<Func<int, int>>)modified).Compile();
Console.WriteLine(compiled(10)); // 10 + 10 = 20 (бо 5 * 2 = 10)

var invoker = MethodInvoker<User>.Create("SetName");
invoker(user, "Alice");

List<User> users = GetUsers();
List<UserDto> dtos = CollectionMapper.Map<User, UserDto>(users);

var builder = new PredicateBuilder<User>();
builder.And(u => u.Age > 18);
builder.Or(u => u.IsAdmin);
Func<User, bool> predicate = builder.Compile();