在涉足领域驱动设计时，我遇到了如何识别领域模型中的聚合根的情况。
我有以下三个类，对一个简单的待办事项列表进行建模：
public class List {
private IList<Task> _tasks;
public List() { ... }
public string Name { get; set; } }
public IEnumerable<Task> Tasks() { ... }
public void AddTask(string descr) { ... }
public void RemoveTask(Task t) { ... }
public Task GetRandomTask() { ... }
}
public class Task {
private IList<Update> _updates;
public Task(string descr) { ... }
public string Description { get; }
public bool IsClosed { get; }
public IEnumerable<Update> Updates() { ... }
public void AddUpdate(string descr, bool close) { ... }
}
public class Update {
public Update(string descr) { ... }
public string Description { get; }
}
我可以对模型进行以下说明：
- 更新仅存在于任务的上下文中。
- 任务仅存在于列表的上下文中。
因此，列表似乎是唯一的聚合根。 （事实上，我的数据访问层只允许加载/保存 List 对象。）但是，我看不出如何将 Task 类中当前存在的 UI 干净地推送到 List 类。目前，我的 List 类正在分发对 Task 对象的引用，允许调用者修改它们。
这是否意味着任务也是一个聚合根，即使它的存在依赖于包含列表？
提前致谢。
Dabbling with domain driven design, I've run into a situation regarding how to identify aggregate roots within my domain model.
I have the following three classes, modelling a simple to-do list:
public class List {
private IList<Task> _tasks;
public List() { ... }
public string Name { get; set; } }
public IEnumerable<Task> Tasks() { ... }
public void AddTask(string descr) { ... }
public void RemoveTask(Task t) { ... }
public Task GetRandomTask() { ... }
}
public class Task {
private IList<Update> _updates;
public Task(string descr) { ... }
public string Description { get; }
public bool IsClosed { get; }
public IEnumerable<Update> Updates() { ... }
public void AddUpdate(string descr, bool close) { ... }
}
public class Update {
public Update(string descr) { ... }
public string Description { get; }
}
I can state the following about the model:
- An Update exists only within the context of a Task.
- A Task exists only within the context of a List.
List, therefore, would seem to be the only aggregate root. (Indeed my data access layer will only allow load/save of List objects.) However I can't see how I can cleanly push the UI that currently exists on my Task class, on to the List class. At the moment my List class is handing out references to Task objects, allowing the caller to modify them.
Does this imply that Task is also an aggregate root, even if it's existence is dependent on a containing List?
Thanks in advance.
发布评论
评论（2）
我认为在这种情况下你可以有 1 或 2 个聚合。这完全取决于您在列表中的任务是否大；以及你的更新会不会很大。
如果任务或更新不会增长很多，一个聚合
root(List)就可以了。否则，您可以将它们分成两个聚合
root(List, Task)，其中List可以添加Task，而Task可以添加更新。In my opinion you can have either 1 or 2 aggregate in this cases. It's all depends your task in the list will be large or not; as well as your update will be large or not.
If task or update will not grow a lot, one aggregate
root(List)will be fine.Else you can separate them to two aggregate
root(List, Task)whereListcan addTaskandTaskcan addUpdate.我认为识别聚合的最佳方法是事件风暴或用户故事映射。
I think best ways to identify your aggregates are event storming or user story mapping.