智能订餐系统高并发场景优化：节假日 / 企业团餐高峰期如何保障稳定运行？技术方案解析

// 订单数据模型示例
public class Order
{
    public int Id { get; set; }
    public string OrderNumber { get; set; }
    public DateTime OrderTime { get; set; }
    public decimal TotalAmount { get; set; }
    public int UserId { get; set; }
    public User User { get; set; }
    
    // 使用Fluent API配置索引
    internal static void Configure(EntityTypeBuilder builder)
    {
        builder.HasIndex(o => o.OrderTime); // 为查询时间范围建立索引
        builder.HasIndex(o => o.UserId);    // 为用户查询建立索引
    }
}

// 数据库上下文配置
public class DiningContext : DbContext
{
    public DbSet Orders { get; set; }
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity(Order.Configure);
        
        // 其他实体配置...
    }
}

// 缓存服务实现示例
public class MenuCacheService
{
    private readonly IMemoryCache _memoryCache;
    private readonly IDistributedCache _distributedCache;
    
    public MenuCacheService(IMemoryCache memoryCache, 
                           IDistributedCache distributedCache)
    {
        _memoryCache = memoryCache;
        _distributedCache = distributedCache;
    }
    
    public async Task GetMenuAsync(int menuId)
    {
        // 首先尝试从内存缓存获取
        if (_memoryCache.TryGetValue($"menu_{menuId}", out Menu menu))
            return menu;
            
        // 内存缓存未命中，尝试分布式缓存
        var cachedData = await _distributedCache.GetStringAsync($"menu_{menuId}");
        if (cachedData != null)
        {
            menu = JsonSerializer.Deserialize(cachedData);
            _memoryCache.Set($"menu_{menuId}", menu, TimeSpan.FromMinutes(5));
            return menu;
        }
        
        // 缓存未命中，从数据库加载
        menu = await _dbContext.Menus.FindAsync(menuId);
        if (menu != null)
        {
            // 更新两级缓存
            _memoryCache.Set($"menu_{menuId}", menu, TimeSpan.FromMinutes(5));
            await _distributedCache.SetStringAsync($"menu_{menuId}", 
                JsonSerializer.Serialize(menu), 
                new DistributedCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1) });
        }
        
        return menu;
    }
}

// 订单处理服务示例
public class OrderProcessingService
{
    private readonly IMessageQueue _messageQueue;
    
    public async Task ProcessOrderAsync(Order order)
    {
        // 同步处理核心业务逻辑
        await ValidateOrderAsync(order);
        await ProcessPaymentAsync(order);
        await UpdateInventoryAsync(order);
        
        // 异步发送通知
        _messageQueue.Publish("order_created", new
        {
            OrderId = order.Id,
            UserId = order.UserId,
            OrderTime = order.OrderTime
        });
    }
    
    // 消息消费者处理异步任务
    [MessageHandler("order_created")]
    public async Task HandleOrderCreatedEvent(OrderCreatedEvent @event)
    {
        await _notificationService.SendOrderConfirmation(@event.OrderId);
        await _analyticsService.TrackOrderEvent(@event);
    }
}