如何使用异步和等待，以便它将创建一个不同的任务或每个请求

Question

I am new in asp.net core and in asynchronous programming. below is my code

protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
    var work = await TaskQueue.DequeueAsync(stoppingToken);
    while (!stoppingToken.IsCancellationRequested)
    {
        redirect(work);
    }
}

public async Task redirect(Func<CancellationToken, Task> work)
{
    await work();
}

So here when i run program and debug it cursor first go in ExecuteAsync method and from while loop it goes in redirect method. redirect method is asynchronous still it will wait on work method. so i think that it is not running asynchronous.

i expect that when cursor go in work method it will start a new task(Thread).

Answer 1

when i run program and debug it

The behavior you're observing is Visual Studio trying to be helpful. It has special code to handle asynchronous methods, so that when you say "step to the next line", it won't suddenly transfer to some completely unrelated method; it will step to the next line in that method .

i expect that when cursor go in work method it will start a new task(Thread).

Tasks are not threads. In particular, tasks created by async methods do not run on threads; they are just state objects that can notify other code when the async method has completed.

I recommend reading my async intro , and follow it up with async best practices .

Answer 2

There are couple of misunderstanding in the way you have trying to use Async-Await , there is enough content on web, following are the specific details:

So here when i run program and debug it cursor first go in ExecuteAsync method and from while loop it goes in redirect method. redirect method is asynchronous still it will wait on work method. so i think that it is not running asynchronous

What await does is release the calling context, while the processing goes in the background, which helps system remains responsive, thus system has scalability / thread pool to cater to further requests, so only thing await doesn't do is block the calling thread / context, in debugger as seen in your code it will wait to finish.

Now what kind of processing does work do is it IO or Compute

If it's IO , that's where Async processing on a server is genuinely used, since thread pool thread is released and if used along with ConfigureAwait(false) it needn't re enter same context to process the response, which is expected by libraries. If it's compute, then it works well for a UI like WPF, since Ui thread remains responsive, but still processing takes away threads from current pool and that has limited / scarce availability.

Regarding your code

• In current form its a blocking code, since in the while loop you are calling redirect(work) , which in turn does await work , it release the caller, but awaiting it to complete before next Async operation can be executed
• Ideal way is to collect all tasks in a collection like List<Task> and when await the Task.WhenAll , that's when all aggregated tasks go together, while you asynchronously wait at the single representative Task for all of them to complete, that would still not a blcoking / call as in current code, but blocking for complete aggregated List, it is specified by @TheGeneral in the comments, thus helps in better processing since all tasks go together
• Also await work() is not correct, compilation error, this needs a Cancellation Token as I/p Parameter
• In current code ideally redirect(work) shall also be awaited, async await shall be across the chain of calls

Modified version of your code

With an assumption that you needs Task.WhenAll and you are doing IO based async, following shall be your code:

protected override async Task ExecuteAsync(CancellationToken stoppingQueueToken,CancellationToken stopWorkToken)
{
      var work = await TaskQueue.DequeueAsync(stoppingQueueToken);
      List<Task> taskList = new List<Task>();
      while (!stoppingQueueToken.IsCancellationRequested)
      {  
         taskList.Add(redirect(work, stopWorkToken));
      }

      await Task.WhenAll(taskList);
}

public async Task redirect(Func<CancellationToken, Task> work, CancellationToken stopWorkToken)
{
    await work(stopWorkToken);
}

I have taken some liberty to introduce the Extra Cancellation Token for work Cancellation, since work processing only starts once while loop is exited, before that its just aggregating the tasks, then they are all processed in background together, assuming IO for maximum benefit. Here also debugger will block, but for all tasks together single call

If you persist with current code, then you just need to make following are the changes:

protected override async Task ExecuteAsync(CancellationToken stoppingQueueToken)
{
    var work = await TaskQueue.DequeueAsync(stoppingQueueToken);
    List<Task> taskList = new List<Task>();
    while (!stoppingQueueToken.IsCancellationRequested)
    {
        await redirect(work, stoppingQueueToken);
    }
}

public async Task redirect(Func<CancellationToken, Task> work, CancellationToken stoppingQueueToken)
{
    await work(stoppingQueueToken);
}

• This code is going one after another, still async and releasing the calling context, but not all together. Debugger will block as you have already seen.

Few more details

• Task and Thread are not same and interchangeable, multiple Tasks may be executed on same Thread
• Cancellation Token is cooperative, it doesn't cancel an already started Task, either should be cancelled before Task begins or needs to be explicitly checked and Thrown to stop the Task Execution, ThrowIfCancellationRequested