class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

        // 将命名方法 IsEven 作为参数传递给 FindAll 方法
        List<int> evenNumvers = numbers.FindAll(IsEven);

        foreach (var num in evenNumbers)
        {
            Console.WriteLine(num);
        }
    }

    // 定义一个独立的、命名的方法
    static bool IsEven(int number)
    {
        return (number %2) == 0;
    }
}

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

// 使用匿名方法，省略了方法名和返回类型声明
List<int> evenNumbers = numbers.FindAll(delegate (int number)
{
    return (number % 2) == 0;
});

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

// 使用 Lambda 表达式
List<int> evenNumbers = numbers.FindAll(number => number % 2 == 0);

(input-parameters) => expression

// 一个参数，可以省略括号
x => x * x

// 两个参数，必须加括号
(x, y) => x == y

// 显式指定参数类型（通常编译器能推断，但有时需要）
(int x, string s) => s.Length > x

(input-parameters) => { <sequence-of-statements> }

// 多条语句，使用 { }
(name, age) => {
    string greeting = $"Hello, {name}";
    Console.WriteLine(greeting);
    return age >= 18; // 显式 return
}

Func<int, int> f = x => x * 2;
Console.WriteLine(f(10));

private sealed class DisplayClass
{
    public int Multiply(int x) => x * 2;
}

f = new Func<int, int>(new DisplayClass().Multiply);

f = new Func<int, int>(<PrivateImplementationDetails>.LambdaMethod);

Expression<Func<int, int>> expr = x => x * 2;

BinaryExpression(
    ParameterExpression("x") * ConstantExpression(2)
)

int factor = 3;
Func<int, int> f= x => x * factor;

class DisplayClass
{
    public int factor;
    public int Multiply(int x) => x * factor;
}

var display = new DisplayClass { factor = 3 };
Func<int, int> f = new Func<int, int>(display.Multiply);

void Test()
{
    int counter = 0;
    Action inc = () => counter++;
    inc();
    Console.WriteLine(counter);
}

class DisplayClass
{
    public int counter;

    public void Inc() => counter++;
}

void Test()
{
    var display = new DisplayClass();
    display.counter = 0;
    Action inc = new Action(display.Inc);
    inc();
    Console.WriteLine(display.counter);
}

void Foo()
{
    int n = 0;
    Action a1 = () => n++;
    Action a2 = () => n--;
    a1();
    a2();
}

class DisplayClass
{
    public int n;
    public void A1() => n++;
    public void A2() => n--;
}

Func<int> MakeCounter()
{
    int count = 0;
    return () => ++count;
}

// 每次循环都会创建新的闭包对象
for (int i = 0 ; i < 10; i++)
    actions.Add(() => Console.WriteLine(i));

// 改写
for (int i = 0; i < 10; i++)
{
    int local = i;
    actions.Add(() => Console.WriteLine(local));
} 

var names = new List<string> { "Alice", "Bob", "Charlie" };

// Where：过滤
var shortNames = names.Where(name => name.Length < 5);

// Select：投影/转换
var nameLengths = names.Select(name => name.Length);

// OrderBy：排序
var sortedNames = names.OrderBy(name => name);

// Any/All：判断存在性
bool hasA = names.Any(name => name.StartsWith("A"));
bool allLone = names.All(name => name.Length > 3);

// 传统方式
button.Click += new EventHandler(Button_Click);
void Button_Click(object sender, EventArgs e) { ... }

// Lambda 方式
button.Click += (sender, e) => MessageBox.Show("Button clicked!");

Func<int, int, int> add = (a, b) => a + b;
int result = add(5, 3);

Action<string> logger = message => Console.WriteLine($"[LOG] {message}");
logger("This is a log");

// 启动一个后台任务
Task.Run(() => {
    // 执行一些耗时操作
    for (int i = 0; i < 10; i++)
    {
        Console.WriteLine($"Working... {i}");
        Thread.Sleep(500);
    }
});

Func<int, int> f = x => x * 2;

static int <lambda>(int x) => x * 2;
Func<int, int> f = new Func<int, int>(<lambda>);

int counter = 0;
Func<int> next = () => ++counter;

class DisplayClass
{
    public int counter;
    public int <lambda>() => ++counter;
}

var obj = new DisplayClass();
obj.counter = 0;
Func<int> next = new Func<int>(obj.<lambda>);

// 编译器推断 number => number > 0 是一个 Func<int, bool>
Func<int, bool> isPositive = number => number > 0;

Expression<Func<int, int>> expr = x => x * 2;

LambdaExpression
 └── BinaryExpression (*)
     ├── ParameterExpression (x)
     └── ConstantExpression (2)

var param = Expression.Parameter(typeof(string), "x");
var property = Expression.Property(Expression.Constant(myObject), "Name");
var assignment = Expression.Assign(property, param);
var lambda = Expression.Lambda<Action<string>>(assignment, param).Compile();

lambda("New Name"); // 这行代码等价于 myObject.Name = "New Name";

Expression<Func<int, int>> expr = x => x * 2;

ParameterExpression p = Expression.Parameter(typeof(int), "x");
ConstantExpression c = Experssion.Constant(2);
BinaryExpression body = Expression.Multiply(p, c);
Expression<Func<int, int>> expr = Expression.Lambda<Func<int, int>>(body, p)

var func = expr.Compile(); // 生成 Func<int, int>
Console.WriteLine(func(5)); // 输出 10

var q = from u in db.Users
        where u.Age > 18 && u.Name.StartsWith("A");
        select u;

x => (x.Age > 18) && x.Name.StartsWith("A");

SELECT * FROM Users WHERE Age > 18 AND Name LIKE 'A%'

Expression<Func<int, bool>> expr = null;

if (rule == "greaterThan10")
    expr = x => x > 10;
else
    expr = x => x < 5;

var compiled = expr.Compile();
Console.WriteLine(compiled(8));

Expression<Func<int, bool>> e1 = x => x > 10;
Expression<Func<int, bool>> e2 = x => x < 5;
var body = Expression.OrElse(e1.Body, e2.Body);
var param = e1.Parameters[0];
var combined = Expression.Lambda<Func<int, bool>>(body, param);

class MyVisitor : ExpressionVisitor
{
    protected override Expression VisitConstant(ConstantExpression node)
    {
        if (node.Type == typeof(int))
            return Expression.Constant((int)node.Value * 10);
        return node;
    }
}

var modified = new MyVisitor().Visit(expr);
Console.WriteLine(modified);

// 一个接受字符串并返回整数的同步Lambda
Func<string, int> parse = (string s) => int.Parse(s);
Console.WriteLine(parse("123")); // 输出：123

// 一个无返回值的同步Lambda
button.Click += (sender, e) => MessageBox.Show("Clicked!");

// Error this
// 无法在同步Lambda中等待异步方法
Func<string, string> getWebpage = (string url) =>
{
    // HttpClient.GetStringAsync 返回 Task<string>
    // 无法直接“等待”这个Task
    var task = httpClient.GetStringAsync(url);
    return task.Result; // 会阻塞线程
}

// 这是一个异步Lambda，它不接收参数，返回一个Task
Func<Task> doSomethingAsync = async () =>
{
    Console.WriteLine("开始异步操作...");
    await Task.Delay(1000); // 模拟一个异步操作（如网络请求）
    Consolw.WriteLine("异步操作完成！");
};

// 调用时，需要等待它返回的Task
await doSomethingAsync();

// 这是一个异步Lambda，它接收一个string 参数，返回一个 Task<string>
Func<string, Task<string>> getWebpage = async (string url) =>
{
    using (var httpClient = new HttpClient())
    {
        // 等待异步HTTP请求
        string content = await httpClient.GetStringAsync(url);
        return content; // 注意：这里返回的是 string，但整个Lambda的返回值是 Task<string>
    }
};

// 调用
string html = await getWebpage("https://api.example.com/data");
Console.WriteLine(html);

// 例如，一个按钮点击事件
button.Click += async (sender, e) =>
{
    // 禁用按钮防止重复点击
    button.Enabled = false;

    try
    {
        // 执行一些异步工作
        await SomeAsyncOperation();
        MessageBox.Show("操作成功！");
    }
    finally
    {
        button.Enable = true;
    }
}

// 尽量避免这样写，除非是顶级事件处理器
button.Click += async (sender, e) => { ... }; // 这是 async void

// 如果可以，使用返回Task的Lambda，并等待它

Func<Task<int>> getNumberAsync = async () =>
{
    await Task.Delay(100);
    return 42; // 这里返回int， 但 getNumberAsync的返回值是Task<int>
};

Func<Task> throwAsync = async () =>
{
    await Task.Delay(100);
    throw new InvalidOperationException("异步Lambda中的错误！");
};

try
{
    await throwAsync();
}
catch (InvalidOperationException ex)
{
    Console.WriteLine($"捕获到异常：{ex.Message}");
}

// 无法编译 Where期望一个返回bool的委托，而不是 Task<bool>
var results = data.Where(async x => await SomeAsyncCheck(x));

// 使用 System.Linq.Async包
IAsyncEnumerable<Data> filteredData = data
    .ToAsyncEnumerable()
    .WhereAwait(async x => await SomeAsyncCheck(x));

await foreach (var item in filteredData)
{
    Console.WriteLine(item);
}

var task = asyncLambda(); // 忘记 await
// task 在后台跑，异常不会在这里抛出

// 错误，不能await
var result = f2(5); // 返回的是 Task<int>

async (x) => { await Task.Delay(1000); return x * 2; }

(x) => {
    var stateMachine = new <Anonymous>d__Something();
    stateMachine.x = x;
    stateMachine.builder = AsyncTaskMethodBuilder<int>.Create();
    stateMachine.Start(ref stateMachine);
    return stateMachinebuilder.Task;
}

// 静态 Lambda 语法
Func<int, int, int> staticAdder = static (a, b) => a + b;

// 等同于这个静态方法
static int StaticAdd(int a, int b) => a + b;

class Calculator
{
    private int _instanceValue = 10;
    private static int _staticValue = 20;

    public void Test()
    {
        int localValue = 5;

        // ✔，只使用参数
        Func<int, int, int> adder = static (a, b) => a + b;

        // ✔，使用静态成员
        Func<int, int> staticMultiplier = static (x) => x * _staticValue;

        // 编译错误，不能捕获实例成员
        Func<int, int> instanceMultiplier = static (x) => x * _instanceValue;

        // 编译错误，不能捕获局部变量
        Func<int, int> localMultiplier = static (x) => x * localValue;

        // 编译错误，不能使用this
        Func<int, int> thisMultiplier = static (x) => x * this._instanceValue;
    }
}

var numbers = Enumeralbe.Range(1, 1000);

// 普通Lambda，可能分配闭包
var evenNumbers = numbers.Where(x => x & 2 == 0).ToList();

// 静态Lambda，无闭包分配，性能更好
var evenNumbersStatic = numbers.Where(static x => x % 2 == 0).ToList();

class EventProcessor
{
    private string _processorName = "Processor1";

    public void SetupEventHandlers()
    {
        // 危险，可能意外捕获 this，导致内存泄露
        SomeEvent += (sender, args) => Process(args, _processorName);

        // 安全，静态Lambda防止意外捕获
        SomeEvent += static (sender, args) => ProcessStatic(args);
        // ProcessStatic必须是静态方法
    }

    private void Process(EventArgs args, string name) { }
    private static void ProcessStatic(EventArgs args) { }
}

public void ProcessData(List<int> data)
{
    // 静态本地函数 + 静态 Lambda
    static bool IsPrime(int number)
    {
        // 使用静态Lambda进行数学计算
        Func<int, int, bool> hasDivisor = static (n, divisor) => n % divisor == 0;

        if (number < 2) return false;
        for (int i = 2; i * i <= number; i++)
        {
            if (hasDivisor(number, i)) return false;
        }
        return true;
    }
    
    var primes = data.Where(IsPrime).ToList();
}

button.Click += static (sender, args) => Console.WriteLine("Clicked!");

private static readonly Func<int, int> MultiplyBy2 = static x => x * 2;