C# WebApi异步操作，是否必须通过所有调用链创建异步方法？

我正在尝试使我的WebApi异步，以便在访问数据库时不阻止处理请求的ASP.net线程。因此，我创建了以下代码。据我所知，当调用此操作时，将创建一个远离ASP.net线程池的新线程来处理

GetBalance

方法，并且过去处理此操作请求的线程将被释放并返回到池中，直到GetBalance方法完成其IO为止，供其他请求使用。这是正确的吗

    public async Task<Account> Balance(int number)
    {
        Task<Account> task = GetBalanceAsync(number);
        await task;

        return task.Result;
    }

    Task<Account> GetBalanceAsync(int number)
    {
        return Task.Factory.StartNew(() => GetBalance(number));
    }

    Account GetBalance(int number)
    {
        using (AccountServices accountService = new AccountServices())
        {
            Account account = accountService.Find(number);

            return account;
        }
    }

我读过的一些文章建议我的异步调用必须经过所有调用链，直到到达最低级别的异步调用，在本例中是实体框架异步调用。另一方面，下面代码创建的新线程仍将在ASP.net线程池中创建，我将释放一个线程来占用另一个线程，这将破坏在异步等待中为提高此WebApi的可伸缩性所做的全部工作

有人能解释一下这是怎么回事吗？如果我的理解是正确的

    public async Task<Account> Balance(int number)
    {
        Task<Account> task = GetBalanceAsync(number);
        await task;

        return task.Result;
    }

    Task<Account> GetBalanceAsync(int number)
    {
        return Task.Factory.StartNew(() => GetBalance(number));
    }

    Account GetBalance(int number)
    {
        using (AccountServices accountService = new AccountServices())
        {
            Account account = accountService.Find(number);

            return account;
        }
    }

公共异步任务平衡（整数）
{
任务任务=GetBalanceAsync（编号）；
等待任务；
返回任务。结果；
}
任务GetBalanceAsync（整数）
{
返回Task.Factory.StartNew（（）=>GetBalance（number））；
}
账户余额（整数）
{
使用（AccountServices accountService=new AccountServices（））
{
Account=accountService.Find（编号）；
返回帐户；
}
}

只有一个线程池。ASP.NET请求仅在常规线程池线程上运行

据我所知，当调用此操作时，将创建一个远离ASP.net线程池的新线程来处理GetBalance方法，并且过去处理此操作请求的线程将被释放并返回到池中，直到GetBalance方法完成其IO为止，供其他请求使用。这是正确的吗

    public async Task<Account> Balance(int number)
    {
        Task<Account> task = GetBalanceAsync(number);
        await task;

        return task.Result;
    }

    Task<Account> GetBalanceAsync(int number)
    {
        return Task.Factory.StartNew(() => GetBalance(number));
    }

    Account GetBalance(int number)
    {
        using (AccountServices accountService = new AccountServices())
        {
            Account account = accountService.Find(number);

            return account;
        }
    }

对,；您的代码正在从线程池中获取一个线程（

StartNew

），然后将一个线程返回到线程池（

wait

）

我读过的一些文章建议我的异步调用必须经过所有调用链，直到到达最低级别的异步调用，在本例中是实体框架异步调用。另一方面，下面代码创建的新线程仍将在ASP.net线程池中创建，我将释放一个线程来占用另一个线程，这将破坏在异步等待中为提高此WebApi的可伸缩性所做的全部工作

。发布的代码增加了复杂性和开销，并且比同步代码的性能更差：

public Account Balance(int number)
{
  return GetBalance(number);
}

Account GetBalance(int number)
{
  using (AccountServices accountService = new AccountServices())
  {
    return accountService.Find(number);
  }
}

完全异步解决方案将具有更好的可扩展性：

public async Task<Account> Balance(int number)
{
  return await GetBalanceAsync(number);
}

Task<Account> GetBalanceAsync(int number)
{
  using (AccountServices accountService = new AccountServices())
  {
    return await accountService.FindAsync(number);
  }
}

公共异步任务平衡（整数）
{
返回等待GetBalanceAsync（编号）；
}
任务GetBalanceAsync（整数）
{
使用（AccountServices accountService=new AccountServices（））
{
return wait accountService.FindAsync（数字）；
}
}

只有一个线程池。ASP.NET请求仅在常规线程池线程上运行

据我所知，当调用此操作时，将创建一个远离ASP.net线程池的新线程来处理GetBalance方法，并且过去处理此操作请求的线程将被释放并返回到池中，直到GetBalance方法完成其IO为止，供其他请求使用。这是正确的吗

    public async Task<Account> Balance(int number)
    {
        Task<Account> task = GetBalanceAsync(number);
        await task;

        return task.Result;
    }

    Task<Account> GetBalanceAsync(int number)
    {
        return Task.Factory.StartNew(() => GetBalance(number));
    }

    Account GetBalance(int number)
    {
        using (AccountServices accountService = new AccountServices())
        {
            Account account = accountService.Find(number);

            return account;
        }
    }

对,；您的代码正在从线程池中获取一个线程（

StartNew

），然后将一个线程返回到线程池（

wait

）

我读过的一些文章建议我的异步调用必须经过所有调用链，直到到达最低级别的异步调用，在本例中是实体框架异步调用。另一方面，下面代码创建的新线程仍将在ASP.net线程池中创建，我将释放一个线程来占用另一个线程，这将破坏在异步等待中为提高此WebApi的可伸缩性所做的全部工作

。发布的代码增加了复杂性和开销，并且比同步代码的性能更差：

public Account Balance(int number)
{
  return GetBalance(number);
}

Account GetBalance(int number)
{
  using (AccountServices accountService = new AccountServices())
  {
    return accountService.Find(number);
  }
}

完全异步解决方案将具有更好的可扩展性：

public async Task<Account> Balance(int number)
{
  return await GetBalanceAsync(number);
}

Task<Account> GetBalanceAsync(int number)
{
  using (AccountServices accountService = new AccountServices())
  {
    return await accountService.FindAsync(number);
  }
}

公共异步任务平衡（整数）
{
返回等待GetBalanceAsync（编号）；
}
任务GetBalanceAsync（整数）
{
使用（AccountServices accountService=new AccountServices（））
{
return wait accountService.FindAsync（数字）；
}
}