您的模型缺少的最重要的东西是行为。你的类只保存数据，有时在不应该的时候使用公共设置器（如Basket.Id）。域实体必须定义对其数据进行操作的方法。
您做对的是，您拥有包含其子项的聚合根（例如，带有私有项目列表的篮子）。聚合应该被视为一个原子，因此每次将篮子加载或持久保存到数据库时，您都会将篮子和项目视为一个整体。这甚至会让你的事情变得更容易。
这是我的一个非常相似领域的模型：
public class Cart : AggregateRoot
{
private const int maxQuantityPerProduct = 10;
private const decimal minCartAmountForCheckout = 50m;
private readonly List<CartItem> items = new List<CartItem>();
public Cart(EntityId customerId) : base(customerId)
{
CustomerId = customerId;
IsClosed = false;
}
public EntityId CustomerId { get; }
public bool IsClosed { get; private set; }
public IReadOnlyList<CartItem> Items => items;
public decimal TotalAmount => items.Sum(item => item.TotalAmount);
public Result CanAdd(Product product, Quantity quantity)
{
var newQuantity = quantity;
var existing = items.SingleOrDefault(item => item.Product == product);
if (existing != null)
newQuantity += existing.Quantity;
if (newQuantity > maxQuantityPerProduct)
return Result.Fail("Cannot add more than 10 units of each product.");
return Result.Ok();
}
public void Add(Product product, Quantity quantity)
{
CanAdd(product, quantity)
.OnFailure(error => throw new Exception(error));
for (int i = 0; i < items.Count; i++)
{
if (items[i].Product == product)
{
items[i] = items[i].Add(quantity);
return;
}
}
items.Add(new CartItem(product, quantity));
}
public void Remove(Product product)
{
var existing = items.SingleOrDefault(item => item.Product == product);
if (existing != null)
items.Remove(existing);
}
public void Remove(Product product, Quantity quantity)
{
var existing = items.SingleOrDefault(item => item.Product == product);
for (int i = 0; i < items.Count; i++)
{
if (items[i].Product == product)
{
items[i] = items[i].Remove(quantity);
return;
}
}
if (existing != null)
existing = existing.Remove(quantity);
}
public Result CanCloseForCheckout()
{
if (IsClosed)
return Result.Fail("The cart is already closed.");
if (TotalAmount < minCartAmountForCheckout)
return Result.Fail("The total amount should be at least 50 dollars in order to proceed to checkout.");
return Result.Ok();
}
public void CloseForCheckout()
{
CanCloseForCheckout()
.OnFailure(error => throw new Exception(error));
IsClosed = true;
AddDomainEvent(new CartClosedForCheckout(this));
}
public override string ToString()
{
return $"{CustomerId}, Items {items.Count}, Total {TotalAmount}";
}
}
以及项目的类：
public class CartItem : ValueObject<CartItem>
{
internal CartItem(Product product, Quantity quantity)
{
Product = product;
Quantity = quantity;
}
public Product Product { get; }
public Quantity Quantity { get; }
public decimal TotalAmount => Product.UnitPrice * Quantity;
public CartItem Add(Quantity quantity)
{
return new CartItem(Product, Quantity + quantity);
}
public CartItem Remove(Quantity quantity)
{
return new CartItem(Product, Quantity - quantity);
}
public override string ToString()
{
return $"{Product}, Quantity {Quantity}";
}
protected override bool EqualsCore(CartItem other)
{
return Product == other.Product && Quantity == other.Quantity;
}
protected override int GetHashCodeCore()
{
return Product.GetHashCode() ^ Quantity.GetHashCode();
}
}
需要注意的一些重要事项：
-
Cart 和 CartItem 是一回事。它们作为一个单元从数据库中加载，然后在一个事务中按原样持久化；
- 数据和操作（行为）紧密相连。这实际上不是 DDD 规则或指南，而是面向对象的编程原则。这就是 OO 的全部意义所在；
- 可以对模型执行的每个操作都表示为聚合根中的一个方法，而聚合根在处理其内部对象时会处理所有这些操作。它控制着一切，每一个操作都必须经过root；
- 对于每个可能出错的操作，都有一个验证方法。例如，您有
CanAdd 和 Add 方法。此类的消费者应首先调用CanAdd 并将可能的错误传播给用户。如果在没有事先验证的情况下调用Add，则Add 将与CanAdd 进行检查，如果违反任何不变量，则抛出异常，并且抛出异常是正确的做法，因为在没有事先验证的情况下到达Add首先检查CanAdd 代表软件中的错误，由程序员提交的错误；
-
Cart 是一个实体，它有一个 Id，但 CartItem 是一个没有 Id 的 ValueObject。客户可以重复购买相同的商品，但它仍然是不同的购物车，但具有相同属性（数量、价格、商品名称）的 CartItem 始终是相同的 - 它是其属性的组合，构成了它的身份.
所以，考虑一下我的域的规则：
- 用户不能将超过 10 个单位的每个产品添加到购物车中；
- 用户只有在购物车中有至少 50 美元的产品时才能进行结帐。
这些是由聚合根强制执行的，没有办法以任何可能破坏不变量的方式滥用类。
您可以在此处查看完整模型：Shopping Cart Model
回到你的问题
更新购物篮（可能部分商品数量已更改）
在Basket 类中有一个方法，负责操作对篮子项目的更改（添加、删除、更改数量）。
添加/设置新订单
似乎一个订单将驻留在另一个限界上下文中。在这种情况下，您将拥有像 Basket.ProceedToCheckout 这样的方法，它将自己标记为已关闭并传播一个 DomainEvent，而这又会在 Order Bounded Context 中被拾取并添加/创建一个 Order。
但是，如果您决定域中的 Order 与 Basket 属于同一 BC 的一部分，则您可以拥有一个 DomainService 来同时处理两个聚合：它将调用 Basket.ProceedToCheckout 并且，如果没有抛出错误，它将从中创建一个Order 聚合。请注意，这是一个跨越两个聚合的操作，因此它已从聚合移至 DomainService。
请注意，此处不需要数据库事务以确保域状态的正确性。
您可以调用Basket.ProceedToCheckout，通过将Closed 属性设置为true 来更改其内部状态。那么订单的创建可能会出错，您将不需要回滚篮子。
您可以修复软件中的错误，客户可以再次尝试结帐，您的逻辑将简单地检查购物篮是否已经关闭并有相应的订单。如果没有，它将只执行必要的步骤，跳过那些已经完成的步骤。这就是我们所说的幂等性。
删除购物篮（或在 DB 中删除标记）
你真的应该多考虑一下。与领域专家交谈，因为我们不会删除现实世界中的任何内容，而且您可能不应该删除您领域中的购物篮。因为这是最有可能对业务有价值的信息，比如知道哪些篮子被丢弃了，然后是营销部门。可以通过折扣促销活动来吸引这些客户，以便他们购买。
我建议您阅读这篇文章：Don't Delete - Just Don't，作者是 Udi Dahan。他深入研究了这个主题。
使用特定支付网关通过信用卡支付
支付网关是基础设施，您的域不应该对此一无所知（甚至接口也应该在另一层声明）。在软件架构方面，更具体地说是在洋葱架构中，我建议您定义这些类：
namespace Domain
{
public class PayOrderCommand : ICommand
{
public Guid OrderId { get; }
public PaymentInformation PaymentInformation { get; }
public PayOrderCommand(Guid orderId, PaymentInformation paymentInformation)
{
OrderId = orderId;
PaymentInformation = paymentInformation;
}
}
}
namespace Application
{
public class PayOrderCommandHandler : ICommandHandler<PayOrderCommand>
{
private readonly IPaymentGateway paymentGateway;
private readonly IOrderRepository orderRepository;
public PayOrderCommandHandler(IPaymentGateway paymentGateway, IOrderRepository orderRepository)
{
this.paymentGateway = paymentGateway;
this.orderRepository = orderRepository;
}
public Result Handle(PayOrderCommand command)
{
var order = orderRepository.Find(command.OrderId);
var items = GetPaymentItems(order);
var result = paymentGateway.Pay(command.PaymentInformation, items);
if (result.IsFailure)
return result;
order.MarkAsPaid();
orderRepository.Save(order);
return Result.Ok();
}
private List<PaymentItems> GetPaymentItems(Order order)
{
// TODO: convert order items to payment items.
}
}
public interface IPaymentGateway
{
Result Pay(PaymentInformation paymentInformation, IEnumerable<PaymentItems> paymentItems);
}
}
我希望这能给你一些见解。