Question

我对如何使用异步和异步组合感到困惑，尤其是在asp.net核心

中

这是案例1：

这是控制器中的代码

    private readonly InfoService _infoService;
    public HomeController(InfoService infoService)
    {
        _infoService = infoService;
    }
    public IActionResult Index()
    {
        //Create a stopwatch for getting excution time  
        var watch = new Stopwatch();
        watch.Start();
        var country = _infoService.GetCountry();
        var state = _infoService.GetState();
        var city = _infoService.GetCity(state);
        watch.Stop();
        ViewBag.WatchMilliseconds = watch.ElapsedMilliseconds;
        ViewBag.Data = city;
        return View();
    }

    public async Task<IActionResult> About()
    {
        //Create a stopwatch for getting excution time  
        var watch = new Stopwatch();
        watch.Start();
        var country =  _infoService.GetCountryAsync();
        var state =  _infoService.GetStateAsync();
        var city =  _infoService.GetCityAsync();
        var content = await country;
        var count = await state;
        var name = await city;
        watch.Stop();
        ViewBag.WatchMilliseconds = watch.ElapsedMilliseconds;
        ViewBag.Data = name;
        return View();
    }

这是Infoservice中的代码

    public string GetCountry()
    {
        Thread.Sleep(3000); //Use - when you want to block the current thread.  
        return "VietNam";
    }
    public async Task<string> GetCountryAsync()
    {
        await Task.Delay(3000); //Use - when you want a logical delay without blocking the current thread.  
        return "VietNam";
    }
    public string GetState()
    {
        Thread.Sleep(5000); //Use - when you want to block the current thread.  
        return "the North";
    }
    public async Task<string> GetStateAsync()
    {
        await Task.Delay(5000); //Use - when you want a logical delay without blocking the current thread.  
        return "the North";
    }
    public string GetCity()
    {
        Thread.Sleep(6000); //Use - when you want to block the current thread.  
        return "HaNoi";
    }
    public async Task<string> GetCityAsync()
    {
        await Task.Delay(6000); //Use - when you want a logical delay without blocking the current thread.  
        return "HaNoi";
    }

运行索引操作，需要 14003 ms

运行关于操作，需要 6016 ms

在这种情况下，我认为它在关于 action =＆gt;中并行运行擅长异步

案例2 ：

我在关于操作

中更改了一些代码

  var watch = new Stopwatch();
  watch.Start();
  var country = await _infoService.GetCountryAsync();
  var state = await _infoService.GetStateAsync();
  var city = await _infoService.GetCityAsync();
  watch.Stop();
  ViewBag.WatchMilliseconds = watch.ElapsedMilliseconds;
  return View();

此案例的结果：

运行索引操作，需要 14003 ms

运行关于操作，需要＆gt; 14008毫秒，它随时改变低或高，通常是索引操作中的更高时间

那么本案的关于行动会发生什么？两种关于操作

的区别

在两种情况下关于操作的多请求/并发时会发生什么和不同

[我知道与索引行动相比，它不是阻止线程

这是案例3：

我想在关于操作时如何使用async

从 country 的值返回州
从国家/地区获取 city ，状态已退回

我目前正在使用这种方式：

  var country = await _infoService.GetCountryAsync();
  var state = await _infoService.GetStateAsync(country);
  var city = await _infoService.GetCityAsync(country,state);

那里有什么问题吗？在这种情况下有多个并发请求时会发生什么？

[我认为它可能在多个并发请求中有价值或无价值]

在这种情况下，使用异步的最佳方法是什么？

谢谢！

Answer 1

写作时

var country = await _infoService.GetCountryAsync();
var state = await _infoService.GetStateAsync();
var city = await _infoService.GetCityAsync();

你要等待你的任务。在任务完成之前，控制流不会传递给下一个操作员。所以在这个意义上它与同步代码非常相似：

var country = _infoService.GetCountry();
var state = _infoService.GetState();
var city = _infoService.GetCity(state);

但是对于异步版本，如果某些I / O操作会阻止进一步执行，则该线程将返回到线程池，并可被其他操作使用。

关于案例3：

您可以使用Task.WhenAll()让任务并行运行并等待所有任务完成：

var countryTask =  _infoService.GetCountryAsync();
var stateTask =  _infoService.GetStateAsync();
var cityTask =  _infoService.GetCityAsync();

await Task.WhenAll(new[] { countryTask, stateTask, cityTask });

任务完成后，您可以使用Task.Result属性获取结果：

var country = countryTask.Result;

但是，不要在未完成的任务上调用Task.Result或Task.Wait()，因为它会阻塞线程并使异步模型贬值。

ASP.NET Core中的异步和异步组合

1 个答案: