在大量阅读 Repository 和 Data Mapper 之后，我决定在测试项目中实现这些模式。由于我是新手，所以我想了解您对我如何在一个简单项目中实现这些的看法。

杰里米·米勒说:

Do some sort of nontrivial, personal coding project where you can freely experiment with design patterns.

但我不知道我做的这些事情对不对。

这是我的项目结构:

如您所见，有许多文件夹，我将在下面详细描述它们。

• 域:项目域实体转到此处我有一个简单的 Personnel 类，它继承自 EntityBase 类，EntityBase 类有一个名为 Id 的属性。

  public int Id { get; set; }
  

• Infrustructure:这是一个包含两个类的简单数据访问层。 SqlDataLayer 是一个简单的类，它继承自一个名为DataLayer 的抽象类。在这里，我提供了一些功能，例如以下代码:

  public SQLDataLayer() {
      const string connString = "ConnectionString goes here";
      _connection = new SqlConnection(connString);
      _command = _connection.CreateCommand();
  }
  

将参数添加到命令参数集合:

    public override void AddParameter(string key, string value) {
        var parameter = _command.CreateParameter();
        parameter.Value = value;
        parameter.ParameterName = key;

        _command.Parameters.Add(parameter);
    }

执行数据读取器:

    public override IDataReader ExecuteReader() {
        if (_connection.State == ConnectionState.Closed)
            _connection.Open();

        return _command.ExecuteReader();
    }

等等。

• 存储库:我在这里尝试实现存储库模式。 IRepository 是一个通用接口(interface)

IRepository.cs :

public interface IRepository<TEntity> where TEntity : EntityBase
{
    DataLayer Context { get; }

    TEntity FindOne(int id);
    ICollection<TEntity> FindAll();

    void Delete(TEntity entity);
    void Insert(TEntity entity);
    void Update(TEntity entity);
}

存储库.cs:

public class Repository<TEntity> : IRepository<TEntity> where TEntity : EntityBase, new() {
    private readonly DataLayer _domainContext;
    private readonly DataMapper<TEntity> _dataMapper;
    public Repository(DataLayer domainContext, DataMapper<TEntity> dataMapper) {
        _domainContext = domainContext;
        _dataMapper = dataMapper;
    }
    public DataLayer Context {
        get { return _domainContext; }
    }
    public TEntity FindOne(int id)
    {
        var commandText = AutoCommand.CommandTextBuilder<TEntity>(CommandType.StoredProcedure, MethodType.FindOne);

        // Initialize parameter and their types
        Context.AddParameter("Id", id.ToString(CultureInfo.InvariantCulture));
        Context.SetCommandType(CommandType.StoredProcedure);
        Context.SetCommandText(commandText);

        var dbReader = Context.ExecuteReader();
        return dbReader.Read() ? _dataMapper.Map(dbReader) : null;
    }

我没有公开 IRepository 中未实现的方法。

在 Generic Repository 类中，我希望构造函数中的两个参数首先是对我的 SqlDataLayer 类的引用，其次是对 Entity DataMapper 的引用。 这些参数由继承自 Repository 类的每个 Entities Repository 类发送。例如:

public class PersonnelRepository : Repository<Personnel>, IPersonnelRepository {
    public PersonnelRepository(DataLayer domainContext, PersonnelDataMapper dataMapper)
        : base(domainContext, dataMapper) {

    }
}

正如您在 FindOne 方法中看到的，我尝试自动执行一些操作，例如创建 CommandText，然后我利用我的 DataLayer 类来配置命令，最后执行命令以获取 IDataReader。我将 IDataReader 传递到我的 DataMapper 类以映射到实体。

• DomainMapper:最后我将 IDataReader 的结果映射到实体，下面是我如何映射 Personnel 实体的示例:

  public class PersonnelDataMapper : DataMapper<Personnel> {
  public override Personnel Map(IDataRecord record) {
      return new Personnel {
          FirstName = record["FirstName"].ToString(),
          LastName = record["LastName"].ToString(),
          Address = record["Address"].ToString(),
          Id = Convert.ToInt32(record["Id"])
      };
  }}
  

用法:

    using (var context = new SQLDataLayer()) {
        _personnelRepository = new PersonnelRepository(context, new PersonnelDataMapper());
            var personnel  = _personnelRepository.FindOne(1);
    }

我知道我在这里犯了很多错误，这就是我来这里的原因。我需要您的建议，以了解我做错了什么或这个简单的测试项目有哪些优点。

提前致谢。

最佳答案

几点:

1. 总的来说，您的设计让我印象深刻。这部分证明了这一点，即您可以在其中进行更改，而对更改的类之外的任何类的影响很小(低耦合)。也就是说，它与 Entity Framework 的功能非常接近，因此虽然它是一个很好的个人项目，但我会考虑先使用 EF，然后再将其实现到生产项目中。

2. 可以使用反射将您的 DataMapper 类设为通用类(例如，GenericDataMapper<T>)。 Iterate over the properties of type T using reflection , 并动态地从数据行中获取它们。

3. 假设您确实制作了一个通用 DataMapper，您可以考虑制作一个 CreateRepository<T>() DataLayer 上的方法，让用户无需担心选择哪种类型的 Mapper 的细节。

4. 一个小批评 - 您假设所有实体都有一个名为“Id”的整数 ID，并且将设置一个存储过程来检索它们。您可以通过允许不同类型的主键来改进您的设计，同样可以通过使用泛型。

5. 您可能不希望按照您的方式重复使用 Connection 和 Command 对象。这不是线程安全的，即使是，您最终也会遇到一些围绕数据库事务的令人惊讶且难以调试的竞争条件。您应该为每个函数调用创建新的 Connection 和 Command 对象(确保在完成后处理它们)，或者围绕访问数据库的方法实现一些同步。

例如，我建议使用这个替代版本的 ExecuteReader:

public override IDataReader ExecuteReader(Command command) {
    var connection = new SqlConnection(connString);
    command.Connection = connection;
    return command.ExecuteReader();
}

您的旧版本重新使用了命令对象，这可能会导致多线程调用者之间出现竞争条件。您还想创建一个新连接，因为旧连接可能参与由不同调用者启动的事务。如果你想重用事务，你应该创建一个连接，开始一个事务，然后重用那个事务，直到你执行了所有你想与事务关联的命令。例如，您可以像这样创建 ExecuteXXX 方法的重载:

public override IDataReader ExecuteReader(Command command, ref SqlTransaction transaction) {
    SqlConnection connection = null;
    if (transaction == null) {
        connection = new SqlConnection(connString);
        transaction = connection.BeginTransaction();
    } else {
        connection = transaction.Connection;
    }
    command.Connection = connection;
    return command.ExecuteReader();
}    

// When you call this, you can pass along a transaction by reference.  If it is null, a new one will be created for you, and returned via the ref parameter for re-use in your next call:

SqlTransaction transaction = null;

// This line sets up the transaction and executes the first command
var myFirstReader = mySqlDataLayer.ExecuteReader(someCommandObject, ref transaction);

// This next line gets executed on the same transaction as the previous one.
var myOtherReader = mySqlDataLayer.ExecuteReader(someOtherCommandObject, ref transaction);

// Be sure to commit the transaction afterward!
transaction.Commit();

// Be a good kid and clean up after yourself
transaction.Connection.Dispose();
transaction.Dispose();

1. 最后但并非最不重要的一点是，在与 Jeremy 合作后，我相信他会说您应该对所有这些类(class)进行单元测试!

关于c# - 存储库和数据映射器模式，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/8844105/