LINQ 查询与异步编程

var numbers = new[] { 5, 2, 8, 1, 9, 3 };

// 查询语法（类 SQL）
var queryResult = from n in numbers
                  where n > 3
                  orderby n descending
                  select n * 10;

// 方法语法（等价）
var methodResult = numbers
    .Where(n => n > 3)
    .OrderByDescending(n => n)
    .Select(n => n * 10);

foreach (var n in methodResult)
{
    Console.WriteLine(n);
}

var source = new List<int> { 1, 2, 3 };
var query = source.Where(n => n > 1);     // 此刻不执行

source.Add(4);                            // 修改源数据

foreach (var n in query)                  // 遍历时才执行，能看到 4
{
    Console.Write(n);                     // 输出 234
}

// 立即执行：此刻求值并固化结果
var materialized = source.Where(n => n > 1).ToList();

// IEnumerable：内存求值，委托直接执行
IEnumerable<Order> local = orders.Where(o => o.Total > 100);

// IQueryable：表达式树，翻译成 SQL
IQueryable<Order> remote = db.Orders.Where(o => o.Total > 100);
// SELECT * FROM Orders WHERE Total > 100  ← 在数据库端过滤

// 分组聚合
var byCategory = products
    .GroupBy(p => p.Category)
    .Select(g => new { g.Key, Count = g.Count(), Total = g.Sum(p => p.Price) });

// 连接两个序列
var orderDetails = orders
    .Join(orderLines, o => o.Id, l => l.OrderId,
          (o, l) => new { o.Customer, l.Sku, l.Qty });

// 去重 + 取前 N
var recent = logs
    .Select(l => l.Host)
    .Distinct()
    .OrderByDescending(h => h)
    .Take(5);

// Any / All / Contains 快速判定
bool hasBig = orders.Any(o => o.Total > 1000);

// async 方法：await 不阻塞线程
public async Task<string> FetchAsync(HttpClient client, string url)
{
    string body = await client.GetStringAsync(url);
    return body;
}

// 并行发起多个独立请求
public async Task<int[]> FetchManyAsync(HttpClient client, string[] urls)
{
    var tasks = urls.Select(u => client.GetStringAsync(u)).ToArray();
    string[] bodies = await Task.WhenAll(tasks);
    return bodies.Select(b => b.Length).ToArray();
}

// async 方法内的异常：await 时被捕获、完成时重新抛出
public async Task<string> MaybeFailAsync(HttpClient client)
{
    try
    {
        return await client.GetStringAsync("https://api.example.com");
    }
    catch (HttpRequestException ex)
    {
        return "fallback";               // 捕获的是 await 后的异常
    }
}

// 不必要的 async：没有 await 就别标 async
public Task<int> NoAwaitAsync(int x)
{
    // 直接返回 Task，避免状态机分配
    return Task.FromResult(x * 2);
}

// 等价但多一次状态机分配
// public async Task<int> NoAwaitAsync(int x) => x * 2;

// ValueTask：同步完成时不分配堆对象
public ValueTask<int> TryGetAsync(int key, CancellationToken ct = default)
{
    if (cache.TryGetValue(key, out int value))
    {
        return new ValueTask<int>(value);   // 零分配
    }
    return new ValueTask<int>(LoadAsync(key, ct));
}

// 取消：传播到 HttpClient 与自定义循环
public async Task DownloadAsync(HttpClient client, string url,
                                CancellationToken ct)
{
    using var resp = await client.GetAsync(url, ct);
    await foreach (var chunk in resp.Content.ReadAsStreamWithCancellation(ct))
    {
        ct.ThrowIfCancellationRequested();   // 主动响应取消
        ProcessChunk(chunk);
    }
}

// 异步流：按页拉取，边拉边消费
public async IAsyncEnumerable<Order> StreamOrdersAsync(int pageSize,
    [EnumeratorCancellation] CancellationToken ct = default)
{
    int page = 0;
    while (true)
    {
        var batch = await GetPageAsync(page++, pageSize, ct);
        if (batch.Count == 0) yield break;
        foreach (var o in batch) yield return o;
    }
}

// 消费端
await foreach (var order in StreamOrdersAsync(100))
{
    Console.WriteLine(order.Id);
}

// PLINQ：CPU 密集集合运算并行化
var heavy = Enumerable.Range(0, 1_000_000)
    .AsParallel()
    .Select(x => ExpensiveCompute(x))
    .ToArray();