全链路运营管理系统架构设计指南：数据层、业务层、应用层逻辑拆解

// 运营订单数据模型
public class OperationOrder
{
    public int Id { get; set; }
    public string OrderNumber { get; set; }
    public OrderStatus Status { get; set; }
    public decimal Amount { get; set; }
    public DateTime CreatedTime { get; set; }
    public DateTime? CompletedTime { get; set; }
    
    // 导航属性
    public virtual ICollection Items { get; set; }
}

// 数据上下文定义
public class OperationDbContext : DbContext
{
    public DbSet Orders { get; set; }
    public DbSet OrderItems { get; set; }
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // 配置实体关系和约束
        modelBuilder.Entity()
            .HasMany(o => o.Items)
            .WithOne(i => i.Order);
    }
}

// 通用仓储接口
public interface IRepository where T : class
{
    Task GetByIdAsync(int id);
    Task<>> GetAllAsync();
    Task AddAsync(T entity);
    Task UpdateAsync(T entity);
    Task DeleteAsync(int id);
}

// 订单仓储实现
public class OrderRepository : IRepository
{
    private readonly OperationDbContext _context;
    
    public OrderRepository(OperationDbContext context)
    {
        _context = context;
    }
    
    public async Task GetByIdAsync(int id)
    {
        return await _context.Orders
            .Include(o => o.Items)
            .FirstOrDefaultAsync(o => o.Id == id);
    }
}

// 订单业务服务接口
public interface IOrderService
{
    Task CreateOrderAsync(OrderCreateRequest request);
    Task ProcessOrderAsync(int orderId);
    Task CancelOrderAsync(int orderId);
}

// 订单业务服务实现
public class OrderService : IOrderService
{
    private readonly IRepository _orderRepository;
    
    public OrderService(IRepository orderRepository)
    {
        _orderRepository = orderRepository;
    }
    
    public async Task CreateOrderAsync(OrderCreateRequest request)
    {
        // 业务规则验证
        if (request.Items == null || !request.Items.Any())
        {
            return OrderResult.Failed("订单项目不能为空");
        }
        
        // 创建订单实体
        var order = new OperationOrder
        {
            OrderNumber = GenerateOrderNumber(),
            Status = OrderStatus.Pending,
            Amount = request.Items.Sum(i => i.Price * i.Quantity),
            CreatedTime = DateTime.UtcNow
        };
        
        await _orderRepository.AddAsync(order);
        return OrderResult.Success(order.Id);
    }
}

// 工作单元接口
public interface IUnitOfWork
{
    Task SaveChangesAsync();
    Task BeginTransactionAsync();
    Task CommitTransactionAsync();
    Task RollbackTransactionAsync();
}

// 业务逻辑中的事务应用
public class OrderProcessingService
{
    private readonly IUnitOfWork _unitOfWork;
    private readonly IOrderService _orderService;
    
    public async Task ProcessComplexOrderAsync(OrderProcessRequest request)
    {
        await _unitOfWork.BeginTransactionAsync();
        try
        {
            // 执行多个业务操作
            var result1 = await _orderService.ProcessOrderAsync(request.OrderId);
            var result2 = await _inventoryService.UpdateStockAsync(request.Items);
            
            if (result1.Success && result2.Success)
            {
                await _unitOfWork.CommitTransactionAsync();
            }
            else
            {
                await _unitOfWork.RollbackTransactionAsync();
            }
        }
        catch (Exception ex)
        {
            await _unitOfWork.RollbackTransactionAsync();
            throw;
        }
    }
}

// 订单API控制器
[ApiController]
[Route("api/[controller]")]
public class OrdersController : ControllerBase
{
    private readonly IOrderService _orderService;
    
    public OrdersController(IOrderService orderService)
    {
        _orderService = orderService;
    }
    
    [HttpPost]
    public async Task CreateOrder([FromBody] OrderCreateRequest request)
    {
        // 参数验证
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }
        
        var result = await _orderService.CreateOrderAsync(request);
        
        if (result.Success)
        {
            return Ok(new { orderId = result.Data });
        }
        
        return BadRequest(new { error = result.Message });
    }
    
    [HttpGet("{id}")]
    public async Task GetOrder(int id)
    {
        var order = await _orderService.GetOrderDetailsAsync(id);
        if (order == null)
        {
            return NotFound();
        }
        return Ok(order);
    }
}

// API服务封装
interface OrderCreateRequest {
  items: OrderItem[];
  customerId: number;
}

interface OrderResponse {
  orderId: number;
  orderNumber: string;
  status: string;
}

class OrderApiService {
  private baseUrl = '/api/orders';
  
  async createOrder(request: OrderCreateRequest): Promise {
    const response = await fetch(this.baseUrl, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(request)
    });
    
    if (!response.ok) {
      throw new Error('订单创建失败');
    }
    
    return await response.json();
  }
  
  async getOrder(orderId: number): Promise {
    const response = await fetch(`${this.baseUrl}/${orderId}`);
    if (!response.ok) {
      throw new Error('订单查询失败');
    }
    return await response.json();
  }
}

// 在React组件中使用
const OrderCreationComponent: React.FC = () => {
  const [loading, setLoading] = useState(false);
  
  const handleCreateOrder = async (orderData: OrderCreateRequest) => {
    setLoading(true);
    try {
      const orderApi = new OrderApiService();
      const result = await orderApi.createOrder(orderData);
      console.log('订单创建成功:', result);
    } catch (error) {
      console.error('订单创建失败:', error);
    } finally {
      setLoading(false);
    }
  };
  
  return (
    // 组件JSX内容
  );
};