C# foreach中异步调用用Result可执行switch 换await则不执行的原因

你遇到的现象完全是async/await的执行规则和当前代码结构不匹配导致的，核心有两点：

1. await的作用域限制与lambda语法规则 #

await关键字只能在被async修饰的方法/lambda内部生效，不能跨lambda的作用域边界被外层方法的async上下文“穿透”。
你当前的代码结构是：

public async Task<ProcessResults> Validate(OrdersToBeProcessed model)
{
    // 外层是Validate方法的async上下文
    return await Task.Run(() => 
    {
        // 这里是Task.Run的同步lambda作用域，本身没有async修饰
        foreach (var item in union)
        {
            // 直接在这里写await，已经脱离了外层Validate的async上下文
            ProcessedOrder ret = await ValidateAsync(item);
            // switch逻辑
        }
    });
}

如果你直接把.Result替换成await，首先会触发C#编译器的语法错误——你必须手动给这个Task.Run传入的lambda加上async修饰符才能编译通过，这就会触发第二个问题。

2. 错误的async lambda导致执行流提前终止 #

Task.Run的重载匹配规则是关键：

• 传入同步无返回值委托（Action）：返回Task，不会等待委托内部的异步操作
• 传入同步有返回值委托（Func<TResult>）：返回Task<TResult>
• 传入异步委托（Func<Task<TResult>>）：返回Task<TResult>，会等待委托内部的异步操作完成

你加上async修饰符之后，如果没有正确调整lambda的返回类型（比如误写成async void，或者返回值不符合预期），Task.Run会匹配到Action对应的重载，直接返回一个已完成的Task。
此时外层Validate方法里的await Task.Run(...)会立刻执行完成并返回，完全不会等待你lambda内部的foreach、ValidateAsync调用等逻辑执行。这就是你看到“程序直接跳转回foreach、switch不执行”的直接原因。

补充说明：为什么用.Result时一切正常？
.Result是同步阻塞API，会硬卡住当前线程，直到关联的异步操作完成才会继续执行后续代码。这种写法在你当前的代码结构下能“跑通”，但在ASP.NET场景下极易触发线程池饥饿、死锁问题，属于绝对要避免的反模式。

你完全不需要把整个业务逻辑包裹在Task.Run中——因为ValidateAsync、WCF调用本身已经是异步实现，用Task.Run包裹同步代码只会平白浪费线程池资源。
正确的写法调整如下：

1. 去掉Validate方法里的Task.Run包裹，直接将方法本身作为异步逻辑的承载
2. 直接在Validate的async上下文中使用await调用ValidateAsync，无需跨lambda边界
3. 彻底移除所有.Result、.Wait()类的同步阻塞调用

调整后的核心逻辑示例：

public async Task<ProcessResults> Validate(OrdersToBeProcessed model)
{
    ProcessResults result = new ProcessResults();
    bool useOurID = (model.CodeType == 1);
    
    // 直接执行逻辑，不需要Task.Run包裹
    List<string> ordersList = SplitOrders(model.Orders);
    List<string> buffer = ordersList.Distinct().ToList();
    List<Order> ordersList = new List<Order>(buffer.Count());

    buffer.ForEach(item =>
    {
        var tmp = new Order();
        if (useOurID)
            tmp.ID = Convert.ToInt64(item);
        else
            tmp.CompanyId = item;
        ordersList.Add(tmp);
    });

    List<Order> foundOrders = _dic[useOurID](buffer);
    result.SuccessfullOrders = new List<ProcessedOrder>();
    result.NotFoundOrders = new List<ProcessedOrder>();
    result.NotAllowedOrders = new List<ProcessedOrder>();

    List<Order> union = foundOrders.MergeAndReplace(ordersList).ToList();

    foreach (var item in union)
    {
        // 直接用await调用，当前在Validate方法的async上下文中，完全合法
        ProcessedOrder ret = await ValidateAsync(item); 

        switch (ret.ProcessedResult)
        {
            case ProcessedResultEnum.CanBeProcessed:
                result.SuccessfullOrders.Add(ret);
                break;
            case ProcessedResultEnum.OrderNotFound:
                result.NotFoundOrders.Add(ret);
                break;
            case ProcessedResultEnum.CannotBeProcessed:
                result.NotAllowedOrders.Add(ret);
                break;
        }
    }
    return result;
}

内容的提问来源于stack exchange，提问作者Valmir Cinquini