C# 从CRUD迁移到DDD

现在，我想根据DDD的指示，尝试从我的模型对象开始，但我在理解如何迁移我的思维模式时遇到了一些困难，因为我无法将我在具体案例中发现的示例转过来

我的主要概念是活动，每个活动都有一个指示性代码、一个描述、一个随时间变化的状态以及每个结果的四分之一

用户希望能够查看从活动中雇佣的所有州的历史记录，以及进行更改的日期。此外，他们还希望能够创建新状态，更改现有状态的描述，并可能防止使用其中一些状态，同时保持以前活动的值

每个季度，用户都希望能够插入一个结果，其中包含结果和建议、评级和结果制定日期

评级必须是用户可自由维护的列表

按照我的老方法，我会创建如下类：

public class Activity
{
    public int ID;
    public string Desc;
    public IList<ActivityStatus> ActivityStatusList;
    public IList<Result> ResultList;
}

public class ActivityStatus
{
    public Activity Activity;
    public Status Status;
    public DateTime StartDate;
    public DateTime EndDate;
}

public class Status
{
    public int ID;
    public string Desc;
    public bool Valid;
}

public class Result
{
    public Activity Activity;
    public int Quarter;
    public string Outcome;
    public string Recommendations;
    public Rating Rating;
}

public class Rating
{
    public int ID;
    public string Desc;
    public bool Valid;
}

公共课堂活动
{
公共int ID；
公共字符串描述；
公共IList活动状态列表；
公共IList结果列表；
}
公共类活动状态
{
公共活动；
公众地位；
公共日期时间开始日期；
公共日期时间结束日期；
}
公共阶级地位
{
公共int ID；
公共字符串描述；
公共布尔有效；
}
公开课成绩
{
公共活动；
公共国际季度；
公共字符串结果；
公众建议；
公众评级；
}
公共等级评定
{
公共int ID；
公共字符串描述；
公共布尔有效；
}

然后，我将使用NHibernate实现一个DataAccessLayer，将该类映射到一个新的db（从该类创建），并添加存储库，以向所有该对象授予用户CRUD操作

根据DDD，有更好的方法吗？

我建议阅读或至少阅读

DDD主要关注领域逻辑，并首先以面向对象的方式对此进行建模。持久性是一个技术问题，它不应该是您设计的起点，也（通常）不应该决定您将如何设计域类。

我建议您阅读或至少阅读

---

DDD主要关注领域逻辑，并首先以面向对象的方式对此进行建模。持久性是一个技术问题，它不应该是您设计的起点，也（通常）不应该决定您将如何设计域类。

如果您渴望编写代码并且相信自己很好地理解域，我建议使用BDD测试优先的方法。使用简单的英语描述您的业务流程，然后使用模拟、设计模式、控制反转等工具逐步填充步骤和功能

---

如果您不熟悉DDD，背景阅读是必须的。阅读EagleBeak建议的书，掌握原理并自己进行实验。

如果你渴望编码并且相信自己很好地理解这个领域，我建议使用BDD测试优先的方法。使用简单的英语描述您的业务流程，然后使用模拟、设计模式、控制反转等工具逐步填充步骤和功能

---

如果您不熟悉DDD，背景阅读是必须的。阅读EagleBeak建议的书，掌握原理，自己做实验。

我不知道是否有更好的方法，但你所说的是以DDD方式解决这个问题的一种方法

在我的数据访问层中，我通常使用职责的抽象工厂。这样我就可以为数据访问插入一个特定的实现，比如NHibernate

public interface IRepositoryFactory {
  T Repository<T>();
};

public class NHibernateRepositoryFactory {
  T Repository<T>() {
    ..... // find class that implements T in Assemblies with reflection
    return repository;
  }
};

public static class Persistence {
  IRepositoryFactory Factory { get; set; }
};

公共接口IRepositoryFactory{
T存储库（）；
};
公营NHibernaterepository工厂{
T存储库（）{
..…//查找在具有反射的程序集中实现T的类
返回存储库；
}
};
公共静态类持久性{
IRepositoryFactory{get；set；}
};

通过这种方式，您可以调用存储库，而无需引用任何特定的实现：

User user = Persistence.Factory.Get<IUserRepository>().FindByEmail("john@tt.com");
user.name = "James";
Persistence.Factory.Get<IUserRepository>().save(user);

User User=Persistence.Factory.Get（）.FindByEmail（“john@tt.com");
user.name=“James”；
Persistence.Factory.Get（）.save（用户）；

如上所述，将抽象工厂用于存储库的另一个优点是，您可以通过为存储库插入一个伪实现来测试代码

public class FakeRepositoryFactory {
  T Repository<T>() {
    ..... // find class that implements T in Assemblies of fake repositories
    return repository;
  }
};

public class FakeUserRepository : public IUserRepository {
    User FindByEmail(string email) {
      // create mocked user for testing purposes ....
      return userMock;
    }
};

公共类FakeRepositoryFactory{
T存储库（）{
..…//在伪存储库的程序集中查找实现T的类
返回存储库；
}
};
公共类FakeUserRepository:公共IUserRepository{
用户FindByEmail（字符串电子邮件）{
//为测试目的创建模拟用户。。。。
返回userMock；
}
};

---

您的代码不会也不应该知道用户数据是从哪里来的。这种方式可以通过透明的方式从一种方式切换到另一种方式。

我不知道是否有更好的方式，但您所说的是以DDD方式解决此问题的一种方式

在我的数据访问层中，我通常使用职责的抽象工厂。这样我就可以为数据访问插入一个特定的实现，比如NHibernate

public interface IRepositoryFactory {
  T Repository<T>();
};

public class NHibernateRepositoryFactory {
  T Repository<T>() {
    ..... // find class that implements T in Assemblies with reflection
    return repository;
  }
};

public static class Persistence {
  IRepositoryFactory Factory { get; set; }
};

公共接口IRepositoryFactory{
T存储库（）；
};
公营NHibernaterepository工厂{
T存储库（）{
..…//查找在具有反射的程序集中实现T的类
返回存储库；
}
};
公共静态类持久性{
IRepositoryFactory{get；set；}
};

通过这种方式，您可以调用存储库，而无需引用任何特定的实现：

User user = Persistence.Factory.Get<IUserRepository>().FindByEmail("john@tt.com");
user.name = "James";
Persistence.Factory.Get<IUserRepository>().save(user);

User User=Persistence.Factory.Get（）.FindByEmail（“john@tt.com");
user.name=“James”；
Persistence.Factory.Get（）.save（用户）；

使用抽象工厂进行存储的另一个优点