Asp.Net Core Using Tasks And Cancellation Tokens Complete Guide

Prerequisites

• Basic knowledge of ASP.NET Core.
• Basic understanding of C# and asynchronous programming.

Example Overview

In this example, we will create an ASP.NET Core web application that:

1. Starts a long-running task using Task.Run when the user navigates to the /Process endpoint.
2. Allows the user to cancel this task via the /Cancel endpoint.

Steps

Step 1: Create an ASP.NET Core Web Application

First, let's create a new ASP.NET Core Web API project.

Command Line (dotnet)

dotnet new webapi -n AspNetCoreTasksAndCancellationTokenExample
cd AspNetCoreTasksAndCancellationTokenExample

Step 2: Define a Background Service

We will create a service that manages our long-running task and its cancellation token.

1. Create a BackgroundService.cs file in the Services folder inside your project.

Services/BackgroundService.cs

using Microsoft.Extensions.Logging;
using System.Threading;
using System.Threading.Tasks;

public class BackgroundService
{
    private readonly ILogger<BackgroundService> _logger;
    private CancellationTokenSource _cancellationTokenSource;
    private Task _backgroundTask;

    public BackgroundService(ILogger<BackgroundService> logger)
    {
        _logger = logger;
        _cancellationTokenSource = new CancellationTokenSource();
    }

    public void StartProcessing()
    {
        if (_backgroundTask != null && _backgroundTask.Status == TaskStatus.Running)
        {
            _logger.LogInformation("Task is already running.");
            return;
        }
        
        _cancellationTokenSource = new CancellationTokenSource();
        _backgroundTask = Task.Run(AsyncLongRunningProcess, _cancellationTokenSource.Token);
        _logger.LogInformation("Process started.");
    }

    private async Task AsyncLongRunningProcess()
    {
        try
        {
            var cancellationToken = _cancellationTokenSource.Token;
            for (var i = 0; i < 100; i++)
            {
                cancellationToken.ThrowIfCancellationRequested();

                // Simulate work with Delay and LogInformation
                await Task.Delay(200, cancellationToken);
                _logger.LogInformation($"Processing iteration {i + 1}.");
            }

            _logger.LogInformation("Process completed successfully.");
        }
        catch (OperationCanceledException ex)
        {
            _logger.LogWarning(ex, "Process was cancelled.");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "An error occurred during the process.");
        }
    }

    public void CancelProcessing()
    {
        if (_backgroundTask == null || _backgroundTask.Status != TaskStatus.Running)
        {
            _logger.LogInformation("No running task to cancel.");
            return;
        }

        _cancellationTokenSource.Cancel();
        // Optionally, wait the task to be cancelled.
        try
        {
            _backgroundTask.Wait();
        }
        catch (AggregateException)
        {
            // Expected exception from the canceled task
            _logger.LogInformation("Waited for task to be cancelled.");
        }

        _logger.LogInformation("Process cancelled.");
    }
}

Step 3: Register the Service in Startup.cs

Next, let's register our service with ASP.NET Core dependency injection system.

Program.cs

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
            });
}

Startup.cs

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Serilog;

namespace AspNetCoreTasksAndCancellationTokenExample
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            // Register BackgroundService as a singleton.
            services.AddSingleton<BackgroundService>();

            services.AddControllers();
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseRouting();

            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }
    }
}

Step 4: Add Controllers to Handle HTTP Requests

Now, we add controllers to start and cancel the task.

Controllers/TaskController.cs

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using System.Threading.Tasks;

[ApiController]
[Route("[controller]")]
public class TaskController : ControllerBase
{
    private readonly BackgroundService _backgroundService;
    private readonly ILogger<TaskController> _logger;

    public TaskController(BackgroundService backgroundService, ILogger<TaskController> logger)
    {
        _backgroundService = backgroundService;
        _logger = logger;
    }

    [HttpPost("process")]
    public IActionResult Process()
    {
        _backgroundService.StartProcessing();
        _logger.LogInformation("Received request to start processing.");
        return Ok("Processing started.");
    }

    [HttpPost("cancel")]
    public IActionResult Cancel()
    {
        _backgroundService.CancelProcessing();
        _logger.LogInformation("Received request to cancel processing.");
        return Ok("Processing cancelled.");
    }
}

Step 5: Set Up Logging (Optional)

For better logging in this example, you might want to set up Serilog.

Program.cs Make sure to install the Serilog.AspNetCore package via NuGet:

dotnet add package Serilog.AspNetCore

Then configure Serilog:

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Serilog;

public class Program
{
    public static void Main(string[] args)
    {
        Log.Logger = new LoggerConfiguration()
            .MinimumLevel.Debug()
            .WriteTo.Console()
            .CreateLogger();

        try
        {
            Log.Information("Starting web host");
            CreateHostBuilder(args).Build().Run();
        }
        catch (Exception ex)
        {
            Log.Fatal(ex, "Host terminated unexpectedly");
        }
        finally
        {
            Log.CloseAndFlush();
        }
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .UseSerilog() // Use Serilog
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
            });
}

Step 6: Test the Endpoints

With the application running, you can test the endpoints:

1. Start the Process Send a POST request to http://localhost:<port>/task/process using a tool like Postman or curl.

   curl -X POST http://localhost:<port>/task/process
   

2. Cancel the Process While the process is running, send another POST request to http://localhost:<port>/task/cancel.

   curl -X POST http://localhost:<port>/task/cancel
   

You should see logs in the console indicating that the process started, and then either completed or was cancelled based on when you made the cancel request.

Summary

This example covers the basics of using tasks (Task.Run) and cancellation tokens (CancellationTokenSource) within an ASP.NET Core application to manage long-running processes. The BackgroundService class is responsible for starting and cancelling the task. The TaskController provides HTTP endpoints to control these operations.