Asp.Net Core Understanding Async And Await Complete Guide

Below, you'll find complete examples along with step-by-step instructions to help beginners get a grip on asynchronous programming in ASP.NET Core.

Step 1: Set Up Your ASP.NET Core Project

First, you need to create a new ASP.NET Core project. You can use Visual Studio or the .NET CLI for this. Here, we'll use ASP.NET Core 6.0 Web API as an example.

Using Visual Studio:

1. Open Visual Studio.
2. Click on Create a new project.
3. Choose ASP.NET Core Web API.
4. Configure your project (name, location, etc.) and click Create.
5. Select the target framework (e.g., .NET 6.0 (Long-term support)) and click Create.

Using .NET CLI:

1. Open a terminal (Command Prompt, PowerShell, or any other terminal of your choice).
2. Run the following command to create a new Web API project:

dotnet new webapi -n AsyncAwaitExample

3. Navigate to the project directory:

cd AsyncAwaitExample

Step 2: Create a Service for Asynchronous Operations

Next, create a service that will perform asynchronous operations. For simplicity, we'll simulate a long-running task using Task.Delay.

Create a new service interface:

Create a new interface called ITaskService in the Interfaces folder (you may need to create the folder first).

// Interfaces/ITaskService.cs
public interface ITaskService
{
    Task<string> PerformLongRunningTaskAsync();
}

Create the service implementation:

Now, create a class that implements ITaskService. This class will contain the method that uses async and await.

// Services/TaskService.cs
using Interfaces;
using System.Threading.Tasks;

public class TaskService : ITaskService
{
    public async Task<string> PerformLongRunningTaskAsync()
    {
        // Simulate a long-running task by waiting for 5 seconds
        await Task.Delay(5000);
        return "Task completed!";
    }
}

Step 3: Register the Service in Dependency Injection

You need to register the service in the Program.cs (or Startup.cs in older versions) file to make it available for dependency injection.

// Program.cs
using Interfaces;
using Services;
var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllers();

// Register the TaskService with the dependency injection system
builder.Services.AddSingleton<ITaskService, TaskService>();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

Step 4: Create a Controller to Use the Service

Create a new controller called TaskController to expose an endpoint that calls the asynchronous method.

// Controllers/TaskController.cs
using Interfaces;
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;

[ApiController]
[Route("api/[controller]")]
public class TaskController : ControllerBase
{
    private readonly ITaskService _taskService;

    public TaskController(ITaskService taskService)
    {
        _taskService = taskService;
    }

    [HttpGet("perform")]
    public async Task<IActionResult> Perform()
    {
        var result = await _taskService.PerformLongRunningTaskAsync();
        return Ok(result);
    }
}

Step 5: Test the Application

1. Run the application by clicking Start in Visual Studio or by executing the following command in the terminal:

dotnet run

2. Open your browser or use a tool like Postman to make a GET request to the endpoint:

https://localhost:5001/api/task/perform

3. You should receive the response "Task completed!" after a 5-second delay.

Explanation

• async: This modifier indicates that the method is asynchronous. An async method can suspend its execution before it reaches the end, allowing other operations to run during the suspension period.
• await: This keyword is used to asynchronously wait for a task to complete. The method in which await is used must also be marked with async.

When you make a request to the Perform action in TaskController, the control is returned to the caller immediately after Task.Delay is initiated. The await keyword causes it to wait asynchronously for the Delay to complete, effectively making the method non-blocking.

Conclusion

In this example, you learned how to use async and await in ASP.NET Core to perform asynchronous operations. This is particularly useful for tasks like I/O operations (database access, API calls, file operations) that can take a significant amount of time to complete. By using asynchronous programming, your application can handle more requests concurrently, improving its scalability and responsiveness.