在.NET MVC中实现后台线程处理长时间运行任务

你遇到的核心问题是：async/await只能解决请求上下文内的异步非阻塞，但无法应对超长时间（2小时+）的任务——这类任务会导致请求超时、应用池回收中断任务，必须将其移至独立的后台执行环境。以下是两种落地性强的方案：

方案1：使用Hangfire（轻量、带持久化的后台任务框架） #

Hangfire是专为.NET设计的后台任务库，支持任务持久化（重启不丢失）、进度监控、自动重试，非常适合长时间数据处理场景。

步骤与代码示例 #

1. 安装NuGet包

   Install-Package Hangfire.Core
   Install-Package Hangfire.SqlServer
   Install-Package Hangfire.AspNet
   

2. 配置Startup.cs

   using Hangfire;
   using Hangfire.SqlServer;
   
   public class Startup
   {
       public void ConfigureServices(IServiceCollection services)
       {
           // 配置Hangfire使用SQL Server存储任务（替换为你的连接字符串）
           services.AddHangfire(config => 
               config.UseSqlServerStorage("YourDatabaseConnectionString"));
           // 启动Hangfire后台服务
           services.AddHangfireServer();
   
           services.AddControllersWithViews();
       }
   
       public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
       {
           // 省略其他中间件配置...
   
           // 启用Hangfire仪表盘（访问路径：/hangfire，可监控任务状态）
           app.UseHangfireDashboard();
   
           app.UseEndpoints(endpoints =>
           {
               endpoints.MapControllerRoute(
                   name: "default",
                   pattern: "{controller=Home}/{action=Index}/{id?}");
           });
       }
   }
   

3. 定义后台任务逻辑

   public class DataProcessingJob
   {
       // 完整的数据获取-处理-存储流程
       public async Task RunFullProcessAsync()
       {
           // 1. 分批获取第三方数据（避免一次性加载海量数据占满内存）
           var rawDataBatches = await FetchThirdPartyDataInBatchesAsync();
           
           foreach (var batch in rawDataBatches)
           {
               // 2. 单批次数据计算
               var processedBatch = ProcessDataBatch(batch);
               // 3. 批量写入数据库
               await SaveBatchToDatabaseAsync(processedBatch);
           }
       }
   
       // 模拟分批获取第三方数据
       private async Task<List<List<string>>> FetchThirdPartyDataInBatchesAsync()
       {
           var batches = new List<List<string>>();
           // 模拟2小时的获取过程（实际替换为第三方API调用）
           for (int i = 0; i < 120; i++)
           {
               await Task.Delay(TimeSpan.FromMinutes(1));
               batches.Add(new List<string> { $"batch_{i}_data_1", $"batch_{i}_data_2" });
           }
           return batches;
       }
   
       // 模拟数据处理
       private List<object> ProcessDataBatch(List<string> batch)
       {
           return batch.Select(d => new { ProcessedValue = d + "_processed" }).ToList();
       }
   
       // 模拟数据库存储
       private async Task SaveBatchToDatabaseAsync(List<object> processedBatch)
       {
           await Task.Delay(TimeSpan.FromSeconds(30));
       }
   }
   

4. 在MVC控制器中触发任务

   public class HomeController : Controller
   {
       private readonly IBackgroundJobClient _hangfireClient;
   
       public HomeController(IBackgroundJobClient hangfireClient)
       {
           _hangfireClient = hangfireClient;
       }
   
       public IActionResult StartLongTasks()
       {
           // 触发第一个长时间任务
           _hangfireClient.Enqueue<DataProcessingJob>(job => job.RunFullProcessAsync());
           // 触发第二个长时间任务
           _hangfireClient.Enqueue<DataProcessingJob>(job => job.RunFullProcessAsync());
   
           return Content("后台任务已启动，可访问/hangfire查看进度");
       }
   }
   

方案2：使用.NET原生BackgroundService（无第三方依赖） #

如果不想引入外部库，可以用.NET自带的BackgroundService实现后台任务队列，适合轻量级、无需持久化的场景（若需持久化，可自行扩展数据库/Redis队列）。

步骤与代码示例 #

1. 创建任务队列类

   // 线程安全的任务队列，用于接收控制器提交的任务
   public class BackgroundTaskQueue
   {
       private readonly BlockingCollection<Func<CancellationToken, Task>> _workItems = new();
   
       // 提交任务到队列
       public void QueueWorkItem(Func<CancellationToken, Task> workItem)
       {
           if (workItem == null) throw new ArgumentNullException(nameof(workItem));
           _workItems.Add(workItem);
       }
   
       // 后台服务从队列取任务
       public Func<CancellationToken, Task> Dequeue(CancellationToken cancellationToken)
       {
           return _workItems.Take(cancellationToken);
       }
   }
   

2. 实现后台服务

   public class DataProcessingService : BackgroundService
   {
       private readonly ILogger<DataProcessingService> _logger;
       private readonly BackgroundTaskQueue _taskQueue;
   
       public DataProcessingService(ILogger<DataProcessingService> logger, BackgroundTaskQueue taskQueue)
       {
           _logger = logger;
           _taskQueue = taskQueue;
       }
   
       protected override async Task ExecuteAsync(CancellationToken stoppingToken)
       {
           _logger.LogInformation("数据处理后台服务已启动");
   
           while (!stoppingToken.IsCancellationRequested)
           {
               // 从队列获取任务
               var workItem = await Task.Run(() => _taskQueue.Dequeue(stoppingToken), stoppingToken);
   
               try
               {
                   // 执行任务
                   await workItem(stoppingToken);
               }
               catch (Exception ex)
               {
                   _logger.LogError(ex, "后台任务执行失败");
               }
           }
   
           _logger.LogInformation("数据处理后台服务已停止");
       }
   }
   

3. 配置Startup.cs注册服务

   public void ConfigureServices(IServiceCollection services)
   {
       // 注册任务队列（单例）
       services.AddSingleton<BackgroundTaskQueue>();
       // 注册后台服务
       services.AddHostedService<DataProcessingService>();
   
       services.AddControllersWithViews();
   }
   

4. 控制器触发任务

   public class HomeController : Controller
   {
       private readonly BackgroundTaskQueue _taskQueue;
   
       public HomeController(BackgroundTaskQueue taskQueue)
       {
           _taskQueue = taskQueue;
       }
   
       public IActionResult StartLongTasks()
       {
           // 提交第一个任务
           _taskQueue.QueueWorkItem(async token =>
           {
               await RunDataProcessAsync(token);
           });
   
           // 提交第二个任务
           _taskQueue.QueueWorkItem(async token =>
           {
               await RunDataProcessAsync(token);
           });
   
           return Content("后台任务已提交至队列");
       }
   
       // 数据处理核心逻辑（支持取消）
       private async Task RunDataProcessAsync(CancellationToken token)
       {
           var rawDataBatches = await FetchThirdPartyDataInBatchesAsync(token);
           foreach (var batch in rawDataBatches)
           {
               if (token.IsCancellationRequested) break;
               var processedBatch = ProcessDataBatch(batch);
               await SaveBatchToDatabaseAsync(processedBatch, token);
           }
       }
   
       // 以下方法同方案1，省略重复代码...
       private async Task<List<List<string>>> FetchThirdPartyDataInBatchesAsync(CancellationToken token)
       {
           var batches = new List<List<string>>();
           for (int i = 0; i < 120; i++)
           {
               await Task.Delay(TimeSpan.FromMinutes(1), token);
               batches.Add(new List<string> { $"batch_{i}_data_1", $"batch_{i}_data_2" });
           }
           return batches;
       }
   
       private List<object> ProcessDataBatch(List<string> batch)
       {
           return batch.Select(d => new { ProcessedValue = d + "_processed" }).ToList();
       }
   
       private async Task SaveBatchToDatabaseAsync(List<object> processedBatch, CancellationToken token)
       {
           await Task.Delay(TimeSpan.FromSeconds(30), token);
       }
   }
   

关键注意事项 #

1. 任务持久化：Hangfire默认将任务存储在数据库，重启后不会丢失；原生BackgroundService的内存队列会在应用重启时丢失任务，若需持久化可扩展为数据库/Redis队列。
2. 分批处理：海量数据必须分批获取、处理、存储，避免一次性加载全部数据导致内存溢出。
3. 取消与超时：所有长时间操作需支持CancellationToken，处理应用停止或任务取消逻辑。
4. 应用池配置：IIS应用池默认会定期回收，需调整回收时间避免中断任务；或直接将后台服务部署为Windows Service（.NET Core支持）。
5. 错误重试：Hangfire支持配置自动重试策略；原生方案需自行实现重试逻辑（如循环重试+间隔）。

内容的提问来源于stack exchange，提问作者ajay grandhi