如何通过另一个请求终止ASP.NET中长时间运行的任务？

Absolutely, this is feasible—but you’ll need to work around ASP.NET’s stateless nature and implement proper task tracking and cancellation logic. Let’s break down how to make this work reliably:

Key Requirements to Pull This Off #

• Unique Task Identification: Since HTTP is stateless, you need a way to link the /abort request to the specific task started by /run. Generate a unique ID (like a Guid) when /run is called, return it to Client1, and have Client2 provide this ID when calling /abort.
• Trackable Cancellation Mechanism: Use CancellationTokenSource (CTS) to control the long-running task. When you start the task, pass its CancellationToken and store the CTS alongside the task ID so you can trigger cancellation later.
• Safe Task Storage: Store the CTS (or task references) in a place accessible across requests—for single-server apps, IMemoryCache works; for multi-server/scaled apps, use a distributed cache (like Redis) or a shared database to ensure all instances can access the task metadata.

A Simplified Example #

Here’s a rough sketch of how this might look in code:

1. /run Endpoint Logic #

[HttpPost("/run")]
public IActionResult StartLongRunningTask()
{
    var taskId = Guid.NewGuid().ToString();
    var cts = new CancellationTokenSource();
    
    // Store the CTS in memory cache (add expiration to avoid memory leaks)
    _memoryCache.Set(taskId, cts, new MemoryCacheEntryOptions { SlidingExpiration = TimeSpan.FromHours(1) });

    // Start the background task
    _ = Task.Run(async () =>
    {
        try
        {
            await LongRunningOperationAsync(cts.Token);
        }
        catch (OperationCanceledException)
        {
            // Handle cancellation cleanly
        }
        finally
        {
            // Clean up the cache entry once task completes/cancels
            _memoryCache.Remove(taskId);
        }
    }, cts.Token);

    return Ok(new { TaskId = taskId });
}

2. /abort Endpoint Logic #

[HttpPost("/abort")]
public IActionResult AbortTask([FromQuery] string taskId)
{
    if (!_memoryCache.TryGetValue<CancellationTokenSource>(taskId, out var cts))
    {
        return NotFound("Task not found (may have completed or expired)");
    }

    try
    {
        cts.Cancel();
        return Ok("Task cancellation requested");
    }
    catch (ObjectDisposedException)
    {
        return BadRequest("Task already completed or was cancelled");
    }
}

3. The Long-Running Task #

private async Task LongRunningOperationAsync(CancellationToken cancellationToken)
{
    for (int i = 0; i < 100; i++)
    {
        // Check for cancellation at regular intervals
        cancellationToken.ThrowIfCancellationRequested();
        
        // Do some work
        await Task.Delay(1000, cancellationToken);
    }
}

Critical Considerations #

• Memory Management: Always clean up cache entries when tasks complete or are cancelled to avoid memory leaks. Use cache expiration as a safety net.
• Multi-Server Scenarios: If your app runs on multiple instances, IMemoryCache won’t work (each instance has its own cache). Switch to a distributed cache like Redis to track cancellation signals across instances (you’ll need to serialize cancellation state instead of storing CancellationTokenSource directly).
• Task Reliability: For production use, consider IHostedService or BackgroundService instead of Task.Run—these are purpose-built for long-running tasks in ASP.NET and are more resilient to app restarts or process recycling.
• Error Handling: Handle cases where the task no longer exists (already completed, expired, or never started) in the /abort endpoint to return meaningful errors to clients.

内容的提问来源于stack exchange，提问作者Bercovici Adrian