我一直认为,如果调用一个异步函数,线程就会开始执行这个异步函数,直到它看到等待。我不想无所事事地等待,而是想让它进入调用堆栈,看看调用方是否在等待。如果没有,它将执行代码。

考虑以下(简化)代码:

async Task<string> FetchCustomerNameAsync(int customerId)
{
    // check if customerId is positive:
    if (customerId <= 0) throw new ArgumentOutofRangeException(nameof(customerId);

    // fetch the Customer and return the name:
    Customer customer = await FetchCustomerAsync(customerId);
    return customer.Name;
}

如果我的异步函数调用 FetchCustomerNameAsync(+1) 不等待:

var myTask = FetchCustmerNameAsync(+1);
DoSomethingElse();
string customerName = await myTask;

• FetchCustomerNameAsync ,以参数值+1调用
• 获取客户名称同步 检测到 customerId 是肯定的,所以没有例外
• 获取客户名称同步 FetchCustomerAsync
• DoSomethingElse()

// call with invalid parameter; do not await
var myTask = FetchCustmerNameAsync(-1);      // <-- note the minus 1!
Debug.Assert(false, "Exception expected");

Debug.Assert

Microsoft about usage of local functions in C# 7

async Task DemoLocalFunctionsInAwaitAsync()
    {
        // using local functions after parameterchecks gives errors immediately

        // No exception before await:
        Task<int> task1 = OldMethodWithoutLocalFunction(null);
        // See? no exception

        // New method: exception even if no await
        try
        {
            Task<int> task2 = NewMethodUsingLocalFunction(null);
            // no await, yet an exception
            Debug.Assert(false, "expected exception");
        }
        catch (ArgumentNullException)
        {
            // this exception is expected
        }

        try
        {
            // await the first task that did not throw an exception: expect the exception
            await task1;
            Debug.Assert(false, "expected exception");
        }
        catch (ArgumentNullException)
        {
            // this exception is expected
        }
    }

    async Task<int> OldMethodWithoutLocalFunction(Customer c)
    {
        // this does not throw exception before awaited
        if (c == null) throw new ArgumentNullException(nameof(c));
        await Task.CompletedTask;
        return c.CustomerId;
    }

    async Task<int> NewMethodUsingLocalFunction(Customer c)
    {
        // this method gives an exception even if not awaited yet
        if (c == null) throw new ArgumentNullException(nameof(c));
        return await LocalFetchCustomerIdAsync(c);

        async Task<int> LocalFetchCustomerIdAsync(Customer customer)
        {
            await Task.CompletedTask;
            return customer.CustomerId;
        }
    }