Domain driven design 哪个层负责为实体的子对象实现懒散加载策略

假设您有一个顺序作为聚合根。订单包含一个或多个行项目

我的理解是，当请求时，存储库负责实例化订单对象

可以在创建订单对象时加载行项目（即时加载），也可以在客户端代码访问行项目集合时填充行项目集合（延迟加载）

如果我们使用的是即时加载，那么在创建订单时，存储库代码似乎会负责将行项目水合

---

但是，如果我们使用延迟加载，那么在访问LineItems集合时如何调用存储库，而不从order域类创建对存储库的依赖关系

主要问题在于

存储库

仅获取聚合根（表示聚合）的能力，因此不能使用

存储库

获取行项目。这可能导致聚合封装冲突

我建议如下：

//域级别：
公共接口IOrderItemList{
IEnumerable GetItems（）；
}
公共阶级秩序{
私有IOrderItemList\u orderItems；
公共IEnumerable订单项
{get{return}orderItems.GetItems（）}；
公共秩序（IOrderItemList orderItems）
{
_orderItems=orderItems；
}
}
公共类OrderItemList:IOrderItemList
{
私人IList_订单项目；
公共IEnumerable GetItems（）{
返回_orderItems；//或其他逻辑
}
//其他实施细节
}
//数据级
公共类OrderItemListProxy:IOrderItemList
{
//链接到“真实”对象
私有OrderItemList\u OrderItemList；
私有int_orderId；
//或者：
//私有OrderEntity\u OrderEntity；
//ORM上下文
私有DbContext _context；
public OrderItemListProxy（int-orderId，DbContext上下文）
{
_orderId=orderId；
_上下文=上下文；
}
公共IEnumerable GetItems（）{
如果（_orderItemList==null）
{
var orderItemEntities=DbContext.Orders
.Single（order=>order.Id==\u orderId）.OrderItems；
var orderItems=orderItemEntites.Select（…）；
//或者：使用工厂从OrderItemEntity创建OrderItem
_orderItemList=新的orderItemList（orderItems）；
}
返回_orderItemList.GetItems（）；
}
}
公共类OrderRepository
{
//ORM上下文
私有DbContext _context；
订单GetOrder（int-id）
{
var orderEntity=_context.Single（order=>order.Id==Id）；
var order=new order（new OrderItemListProxy（id，_context））
//或者：
//变量顺序=新顺序（新OrderItemListProxy（orderEntity，_上下文））
...
//初始化其他字段
...
}
//其他方法
...
}

这里最重要的是，

IOrderItemList

对应于域层，而

OrderItemListProxy

对应于数据层

最后,

您可以使用

IList

而不是自定义

IOrderItemList

或其他适当的界面

代理实现可能有所不同

我没有提供使用db上下文的最佳实践，这可能取决于您使用的技术

---

我一直在努力避免延迟加载。但是如果你必须这样做，那么这是正确的方法。