车间管理系统上线后持续优化：生产流程调整（新增产线）、业务需求变化（定制化订单）功能升级方法

// 产线实体模型
public class ProductionLine
{
    public int Id { get; set; }
    public string LineCode { get; set; } // 产线编号
    public string Name { get; set; } // 产线名称
    public DateTime CommissioningDate { get; set; } // 投产日期
    public bool IsActive { get; set; } // 是否激活
    public int CapacityPerHour { get; set; } // 小时产能
    
    // 导航属性
    public virtual ICollection WorkStations { get; set; }
    public virtual ICollection ProductionOrders { get; set; }
}

// 数据库上下文扩展
public class WorkshopDbContext : DbContext
{
    public DbSet ProductionLines { get; set; }
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // 产线实体配置
        modelBuilder.Entity(entity =>
        {
            entity.HasKey(e => e.Id);
            entity.Property(e => e.LineCode).IsRequired().HasMaxLength(50);
            entity.Property(e => e.Name).IsRequired().HasMaxLength(100);
            entity.HasIndex(e => e.LineCode).IsUnique(); // 产线编号唯一索引
        });
    }
}

// 产线资源分配服务
public class ProductionLineService
{
    private readonly WorkshopDbContext _context;
    
    public ProductionLineService(WorkshopDbContext context)
    {
        _context = context;
    }
    
    // 根据产品类型和产能需求分配最优产线
    public ProductionLine AssignOptimalProductionLine(Product product, int requiredQuantity)
    {
        var availableLines = _context.ProductionLines
            .Where(pl => pl.IsActive && 
                   pl.CapacityPerHour >= requiredQuantity / 24.0) // 日产能检查
            .OrderByDescending(pl => pl.CapacityPerHour)
            .ToList();
            
        return availableLines.FirstOrDefault();
    }
    
    // 启用新产线
    public async Task ActivateNewLineAsync(int lineId)
    {
        var line = await _context.ProductionLines.FindAsync(lineId);
        if (line != null)
        {
            line.IsActive = true;
            await _context.SaveChangesAsync();
        }
    }
}

// 前端生产计划调整逻辑
class ProductionScheduler {
  // 插入紧急定制订单
  insertUrgentOrder(urgentOrder, existingSchedule) {
    const newSchedule = [...existingSchedule];
    // 查找合适的时间空隙
    const suitableSlot = this.findSuitableTimeSlot(urgentOrder, newSchedule);
    
    if (suitableSlot) {
      newSchedule.splice(suitableSlot.index, 0, urgentOrder);
      this.adjustAdjacentOrders(newSchedule, suitableSlot.index);
      return newSchedule;
    } else {
      throw new Error('无法安排紧急订单，请调整生产计划');
    }
  }
  
  // 调整相邻订单时间
  adjustAdjacentOrders(schedule, insertedIndex) {
    // 实现时间调整逻辑
    const previousOrder = schedule[insertedIndex - 1];
    const nextOrder = schedule[insertedIndex + 1];
    
    // 时间调整算法...
  }
}

// 定制化工艺路线服务
public class CustomizedProcessService
{
    private readonly WorkshopDbContext _context;
    
    public CustomizedProcessService(WorkshopDbContext context)
    {
        _context = context;
    }
    
    // 创建定制化工艺路线
    public async Task CreateCustomProcessAsync(Order order, ProductSpecification spec)
    {
        var baseProcess = await _context.ProcessRoutes
            .FirstOrDefaultAsync(pr => pr.ProductType == order.ProductType);
            
        var customProcess = new ProcessRoute
        {
            Name = $"{order.OrderNumber}_定制工艺",
            Description = $"订单{order.OrderNumber}的定制化工艺路线",
            Steps = this.GenerateCustomSteps(baseProcess, spec)
        };
        
        _context.ProcessRoutes.Add(customProcess);
        await _context.SaveChangesAsync();
        
        return customProcess;
    }
    
    // 生成定制化工序
    private List GenerateCustomSteps(ProcessRoute baseProcess, ProductSpecification spec)
    {
        // 根据产品规格生成定制化工序逻辑
        var customSteps = new List();
        
        // 实现定制逻辑...
        return customSteps;
    }
}

// 数据迁移服务
public class DataMigrationService
{
    public async Task MigrateProductionDataAsync(int oldLineId, int newLineId)
    {
        using var transaction = await _context.Database.BeginTransactionAsync();
        
        try
        {
            // 迁移生产数据
            var ordersToMigrate = await _context.ProductionOrders
                .Where(o => o.LineId == oldLineId && o.Status == OrderStatus.Pending)
                .ToListAsync();
                
            foreach (var order in ordersToMigrate)
            {
                order.LineId = newLineId;
                order.MigrationDate = DateTime.Now;
            }
            
            await _context.SaveChangesAsync();
            await transaction.CommitAsync();
        }
        catch (Exception ex)
        {
            await transaction.RollbackAsync();
            throw new Exception($"数据迁移失败: {ex.Message}");
        }
    }
}

// 系统性能监控
class SystemPerformanceMonitor {
  constructor() {
    this.metrics = {
      responseTime: [],
      errorRate: 0,
      throughput: 0
    };
  }
  
  // 记录关键指标
  recordMetric(metricName, value) {
    if (this.metrics[metricName] !== undefined) {
      this.metrics[metricName].push({
        value,
        timestamp: new Date()
      });
      
      // 保持最近1000条记录
      if (this.metrics[metricName].length > 1000) {
        this.metrics[metricName].shift();
      }
    }
  }
  
  // 生成性能报告
  generatePerformanceReport() {
    return {
      avgResponseTime: this.calculateAverage(this.metrics.responseTime),
      maxErrorRate: this.calculateMaxErrorRate(),
      throughputTrend: this.calculateThroughputTrend()
    };
  }
}