我应该使用泛型来简化我的 DAL 吗？

我是 NHibernate 的新手，不太擅长 C#，但我正在学习。我有一个DataProvider类，它使用 NHibernate 3 为我的应用程序提供数据。它的结构几乎与Steve Bohlen 的 NHibernate 之夏视频.

我注意到我将要大量重复我的代码，并且我想简化我的代码DataProvider。例如，我有两个商务课程，名为Instrument and Broker。添加方法Instrument in my DataProvider is:

    public int AddInstrument(Instrument instrument)
    {
        using (ITransaction tx = _session.BeginTransaction())
        {
            try
            {
                int newId = (int)_session.Save(instrument);
                _session.Flush();
                tx.Commit();
                return newId;
            }
            catch (NHibernate.HibernateException)
            {
                tx.Rollback();
                throw;
            }
        }
    }

and the AddBroker类看起来非常相似（只需查找并替换）。所以我想也许我可以使用泛型来解决这个问题。就像是：

public class DataProvider <TEntity>
{
    public int AddEntity(TEntity entity)
    {
        using (ITransaction tx = _session.BeginTransaction())
        {
            try
            {
                int newId = (int)_session.Save(entity);
                _session.Flush();
                tx.Commit();
                return newId;
            }
            catch (NHibernate.HibernateException)
            {
                tx.Rollback();
                throw;
            }
        }
    }    
}

有了这个我可以传递一个Broker, an Instrument或者任何事情，我可以节省很多重复的代码。我遇到的问题是在我的Test类我创建一个新的DataProvider每次测试都像这样运行：

    #region Fields

    private DataProvider _provider;
    private SessionManager _sessionManager;
    private NHibernate.ISession _session;

    #endregion

    [SetUp]
    public void Setup()
    {
        DatabaseSetUp();

        _session = _sessionManager.GetSession();
        _provider = new DataProvider(_session);    // problem here
    }

使用泛型我必须将对象类型传递给我的DataProvider。你能想办法解决这个问题吗？我是一名新手程序员，我想知道我是否走在正确的道路上。我应该做一些完全不同的事情吗？

UPDATE

我尝试实施 Groo 的答案，但遇到了一些问题。这就是我所做的。

IRepo.cs

interface IRepo<T>
{
    int Add<Entity>(Entity entity);
    void Delete<Entity>(Entity entity);
    void GetById<Entity>(int Id);
}

BaseRepo.cs

public abstract class BaseRepo <T> : IRepo <T>
{
    private ISession _session;

    #region SessionManagement

    public BaseRepo(ISession session)
    {
        _session = session;
    }

    public ISession Session
    {
        set { _session = value; }
    }

    #endregion

    public int Add<Entity>(Entity entity)
    {
        using (ITransaction tx = _session.BeginTransaction())
        {
            try
            {
                int newId = (int)_session.Save(entity);
                _session.Flush();
                tx.Commit();
                return newId;
            }
            catch (NHibernate.HibernateException)
            {
                tx.Rollback();
                throw;
            }
        }
    }

    // other methods omitted for brevity
}

IRepoFactory.cs

interface IRepoFactory
{
    IInstrumentRepo CreateInstrumentRepo(ISession s);
}

RepoFactory.cs

public class RepoFactory : IRepoFactory
{
    public IInstrumentRepo CreateInstrumentRepo(ISession s) // problem here
    {
        return new InstrumentRepo(s);
    }

}

IInstrumentRepo.cs

interface IInstrumentRepo : IRepo<Instrument>
{

}

InstrumentRepo.cs

public class InstrumentRepo : BaseRepo<Instrument>, IInstrumentRepo
{
    public InstrumentRepo(ISession s) : base(s) { }
}

在 RepoFactory.cs 中我收到此错误：

Inconsistent accessibility: return type 'MooDB.Data.IInstrumentRepo' is less accessible than method 'MooDB.Data.RepoFactory.CreateInstrumentRepo(NHibernate.ISession)'

我有什么想法吗？

首先，为了解决您的测试设置问题：术语“存储库”可能表明它应该是一个长期存在的持久对象，但 DAL 操作中使用的存储库实际上应该是生命周期短的轻量级无状态对象：您在需要时实例化一个，并在完成后立即将其丢弃。当您考虑这是性能方面时，您可以轻松地每秒实例化数百万个它们。

结合NHibernate的短暂Session例如，当一切就位时，您的代码应如下所示：

using (var session = SessionManager.OpenSession())
{
    // create an instrument repo
    IInstrumentRepo instruments = DAL.RepoFactory.CreateInstrumentRepo(session);
    var guitar = instruments.Find(i => i.Type == "Guitar");

    // create a customer repo
    ICustomerRepo customers = DAL.RepoFactory.CreateCustomerRepo(session);
    var cust = customers.Find(c => c.Name == "Mark")

    // do something -> changes will be persisted by NH when session is disposed
    cust.Instruments.Add(guitar);
}

这就是总体思路。现在，让我更详细地解释一下：

1. 您可能已经注意到，每个存储库都有自己的界面，并且是通过存储库工厂创建的。使用工厂创建存储库意味着您可以轻松创建模拟存储库工厂，这将创建存储库的任何自定义实现以进行测试。

2. 每个repo接口都继承自base接口通用接口，IRepo<T>。这允许您在 99% 的情况下使用通用存储库，但仍然留有空间来实现特定于以下内容的自定义查询方法：Customer仅实体：

   public interface IInstrumentRepo : IRepo<Instrument>
   { 
       // nothing to do here
   }
   
   public interface ICustomerRepo : IRepo<Customer>
   {
       // but we'll need a custom method here
       void FindByAddress(string address);
   }
   
   public interface IRepo<T> 
   {
       T GetById(object id);
       T Save(T item);
   }
   

3. 这意味着在大多数情况下，您的存储库实现将简单地继承自抽象基类（我将其命名为BaseRepo，但这本质上就是你的DataProvider类现在正在做）：

   class InstrumentRepo : BaseRepo<Instrument>, IInstrumentRepo
   {
       // no need to implement anything here except pass the session downwards
       public InstrumentRepo(ISession s) : base(s) { }
   }
   

4. 当被要求时，您的工厂只需要实例化正确的存储库：

   public class RepoFactory : IRepoFactory
   {
        public IInstrumentRepo CreateInstrumentRepo(ISession s)
        {
            return new InstumentRepo(s);
        }
   }
   

5. 你需要在以下情况中使用单例模式：DAL类来保存工厂（有更好的方法可以使用 DI 来做到这一点，但现在就可以了）：

   public static class DAL 
   {
       // repo factory is pretty lightweight, so no need for fancy
       // singleton patterns
   
       private static readonly IRepoFactory _repoFactory = new RepoFactory();
       public static IRepoFactory RepoFactory
       { 
           get { return _repoFactory; }
       }
   }