基于下单日期自动变更订单状态的Asp.net Core MVC实现方案

一、调整订单模型 #

首先确保订单模型包含状态和创建时间字段：

public class Order
{
    public int Id { get; set; }
    // 原有业务字段（如用户ID、商品列表等）
    public OrderStatus Status { get; set; }
    public DateTime CreatedAt { get; set; }
}

public enum OrderStatus
{
    Pending,
    Shipped,
    Delivered
}

用户下单时，直接设置Status = OrderStatus.Pending、CreatedAt = DateTime.UtcNow，保存到数据库即可。

二、两种实现方案 #

方案1：使用Asp.net Core托管服务（Hosted Service） #

适合轻量、无额外依赖的定时任务场景，通过后台循环扫描订单并处理状态。

1. 创建托管服务类

public class OrderStatusProcessor : BackgroundService
{
    private readonly IServiceScopeFactory _scopeFactory;
    private readonly ILogger<OrderStatusProcessor> _logger;

    public OrderStatusProcessor(IServiceScopeFactory scopeFactory, ILogger<OrderStatusProcessor> logger)
    {
        _scopeFactory = scopeFactory;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("订单状态处理服务已启动");

        while (!stoppingToken.IsCancellationRequested)
        {
            using var scope = _scopeFactory.CreateScope();
            var dbContext = scope.ServiceProvider.GetRequiredService<YourDbContext>();

            // 1. 下单满2天：Pending → Shipped
            var pendingOrders = await dbContext.Orders
                .Where(o => o.Status == OrderStatus.Pending && o.CreatedAt <= DateTime.UtcNow.AddDays(-2))
                .ToListAsync(stoppingToken);
            foreach (var order in pendingOrders)
            {
                order.Status = OrderStatus.Shipped;
                _logger.LogInformation($"订单[{order.Id}]状态更新为Shipped");
            }

            // 2. 下单满4天：Shipped → Delivered
            var shippedOrders = await dbContext.Orders
                .Where(o => o.Status == OrderStatus.Shipped && o.CreatedAt <= DateTime.UtcNow.AddDays(-4))
                .ToListAsync(stoppingToken);
            foreach (var order in shippedOrders)
            {
                order.Status = OrderStatus.Delivered;
                _logger.LogInformation($"订单[{order.Id}]状态更新为Delivered");
            }

            // 3. 删除已Delivered的订单（下单满4天）
            var deliveredOrders = await dbContext.Orders
                .Where(o => o.Status == OrderStatus.Delivered && o.CreatedAt <= DateTime.UtcNow.AddDays(-4))
                .ToListAsync(stoppingToken);
            dbContext.Orders.RemoveRange(deliveredOrders);
            _logger.LogInformation($"删除{deliveredOrders.Count}个已完成订单");

            await dbContext.SaveChangesAsync(stoppingToken);

            // 每隔1小时执行一次，可根据业务调整间隔
            await Task.Delay(TimeSpan.FromHours(1), stoppingToken);
        }

        _logger.LogInformation("订单状态处理服务已停止");
    }
}

2. 注册托管服务

在Program.cs中添加服务注册：

builder.Services.AddHostedService<OrderStatusProcessor>();

方案2：使用Hangfire（灵活调度任务） #

适合需要可视化管理任务、重试机制的场景，需依赖数据库存储任务信息。

1. 安装依赖包

通过NuGet安装：

Install-Package Hangfire.AspNetCore
Install-Package Hangfire.SqlServer

2. 配置Hangfire

在Program.cs中配置：

// 配置Hangfire存储（使用SQL Server）
builder.Services.AddHangfire(config =>
    config.UseSqlServerStorage(builder.Configuration.GetConnectionString("YourDbConnection")));
// 启动Hangfire服务
builder.Services.AddHangfireServer();

// 启用Hangfire仪表盘（可选，用于管理任务）
app.UseHangfireDashboard("/hangfire");

3. 下单时调度延迟任务

在订单创建服务中，为每个订单添加延迟任务：

public class OrderService
{
    private readonly YourDbContext _dbContext;
    private readonly IServiceScopeFactory _scopeFactory;

    public OrderService(YourDbContext dbContext, IServiceScopeFactory scopeFactory)
    {
        _dbContext = dbContext;
        _scopeFactory = scopeFactory;
    }

    public async Task CreateOrder(Order order)
    {
        order.Status = OrderStatus.Pending;
        order.CreatedAt = DateTime.UtcNow;
        await _dbContext.Orders.AddAsync(order);
        await _dbContext.SaveChangesAsync();

        // 2天后执行状态变更为Shipped
        BackgroundJob.Schedule(() => UpdateOrderStatus(order.Id, OrderStatus.Shipped), TimeSpan.FromDays(2));
        // 4天后执行状态变更为Delivered并删除订单
        BackgroundJob.Schedule(() => CompleteAndDeleteOrder(order.Id), TimeSpan.FromDays(4));
    }

    public async Task UpdateOrderStatus(int orderId, OrderStatus newStatus)
    {
        using var scope = _scopeFactory.CreateScope();
        var dbContext = scope.ServiceProvider.GetRequiredService<YourDbContext>();
        var order = await dbContext.Orders.FindAsync(orderId);
        if (order != null)
        {
            order.Status = newStatus;
            await dbContext.SaveChangesAsync();
        }
    }

    public async Task CompleteAndDeleteOrder(int orderId)
    {
        using var scope = _scopeFactory.CreateScope();
        var dbContext = scope.ServiceProvider.GetRequiredService<YourDbContext>();
        var order = await dbContext.Orders.FindAsync(orderId);
        if (order != null)
        {
            order.Status = OrderStatus.Delivered;
            dbContext.Orders.Remove(order);
            await dbContext.SaveChangesAsync();
        }
    }
}

三、注意事项 #

• 统一使用DateTime.UtcNow处理时间，避免时区差异导致的状态变更错误。
• 托管服务的执行间隔需平衡性能与实时性，建议生产环境设置为15-60分钟。
• 生产环境中需为任务添加异常捕获逻辑，避免单个任务失败导致服务崩溃。
• 若需保留订单历史数据，建议将删除操作改为归档至历史表，而非直接删除。

内容的提问来源于stack exchange，提问作者Omar Afify