如何使用依赖注入将工作单元容器传递到存储库的构造函数中

Question

我正在尝试弄清楚如何在 ASP.NET Web 应用程序中完成存储库模式的实现。

目前，我为每个域类定义了一个存储库接口，用于定义方法，例如加载和保存该类的实例。

每个存储库接口都由一个执行 NHibernate 功能的类来实现。 Castle Windsor根据web.config将类的DI整理到界面中。下面提供了一个已实现类的示例：

  public class StoredWillRepository : IStoredWillRepository
  {
    public StoredWill Load(int id)
    {
      StoredWill storedWill;
      using (ISession session = NHibernateSessionFactory.OpenSession())
      {
        storedWill = session.Load<StoredWill>(id);
        NHibernateUtil.Initialize(storedWill);
      }
      return storedWill;
    }

    public void Save(StoredWill storedWill)
    {
      using (ISession session = NHibernateSessionFactory.OpenSession())
      {
        using (ITransaction transaction = session.BeginTransaction())
        {
          session.SaveOrUpdate(storedWill);
          transaction.Commit();
        }
      }
    }
  }

正如前面的线程所指出的，存储库类需要接受工作单元容器（即 ISession），而不是在每个方法中实例化它。

我预计工作单元容器将在需要时由每个 aspx 页面创建（例如，在属性中）。

当 Windsor 为我创建工作单元容器实例时，如何指定将其传递到 StoredWillRepository 的构造函数中？

或者这种模式完全错误？

再次感谢您的建议。

大卫

Answer 1

我有一个基于 NHibernate 构建的持久性框架，在一些 Web 应用程序中使用。它将 NH 实现隐藏在 IRepository 和 IRepository 接口后面，并使用 Unity 提供的具体实例（因此理论上我可以将 NHibernate 替换为 Entity）框架相当容易）。

由于 Unity 不支持（或者至少我使用的版本不支持）除了依赖注入本身之外的构造函数参数的传入，因此不可能传入现有的 NH ISession；但我确实希望 UOW 中的所有对象共享相同的 ISession。

我通过使用一个控制存储库类来解决这个问题，该类在每个线程的基础上管理对 ISession 的访问：

    public static ISession Session
    {
        get
        {
            lock (_lockObject)
            {
                // if a cached session exists, we'll use it
                if (PersistenceFrameworkContext.Current.Items.ContainsKey(SESSION_KEY))
                {
                    return (ISession)PersistenceFrameworkContext.Current.Items[NHibernateRepository.SESSION_KEY];
                }
                else
                {
                    // must create a new session - note we're not caching the new session here... that's the job of
                    // BeginUnitOfWork().
                    return _factory.OpenSession(new NHibernateInterceptor());
                }
            }
        }
    }

在此示例中，PersistenceFrameworkContext.Current.Items 访问 IList

然后，我有 BeginUnitOfWork 和 EndUnitOfWork 方法来处理 UOW - 我明确禁止嵌套 UOW，因为坦率地说，管理起来很痛苦。

    public void BeginUnitOfWork()
    {
        lock (_lockObject)
        {
            if (PersistenceFrameworkContext.Current.Items.ContainsKey(SESSION_KEY))
                EndUnitOfWork();

            ISession session = Session;
            PersistenceFrameworkContext.Current.Items.Add(SESSION_KEY, session);
        }
    }

    public void EndUnitOfWork()
    {
        lock (_lockObject)
        {
            if (PersistenceFrameworkContext.Current.Items.ContainsKey(SESSION_KEY))
            {
                ISession session = (ISession)PersistenceFrameworkContext.Current.Items[SESSION_KEY];
                PersistenceFrameworkContext.Current.Items.Remove(SESSION_KEY);
                session.Flush();
                session.Dispose();
            }
        }
    }

最后，一对方法提供对特定于域类型的存储库的访问：（

    public IRepository<T> For<T>()
        where T : PersistentObject<T>
    {
        return Container.Resolve<IRepository<T>>();
    }

    public TRepository For<T, TRepository>()
        where T : PersistentObject<T>
        where TRepository : IRepository<T>
    {
        return Container.Resolve<TRepository>();
    }

这里，PersistentObject 是提供 ID 和 Equals 支持的基类。）

因此，对给定存储库的访问是在 然后，该模式

NHibernateRepository.For<MyDomainType>().Save();

被外观化，以便您可以使用

MyDomainType.Repository.Save();

给定类型有专门存储库的情况（即需要的内容超出了从 IRepository 可以获得的内容），然后我创建一个从 IRepository，一个继承自我的 IRepository 实现的扩展实现，在域类型本身中，我使用 Repository 覆盖静态 Repository 属性code>new

    new public static IUserRepository Repository
    {
        get
        {
            return MyApplication.Repository.For<User, IUserRepository>();
        }
    }

（MyApplication [在实际产品中被称为不太令人讨厌的东西] 是一个外观类，负责通过 Unity 提供 Repository 实例，因此您不依赖于域类中的特定 NHibernate 存储库实现。）

这为我提供了通过 Unity 实现存储库实现的完全可插入性、在代码中轻松访问存储库而无需跳过任何环节，以及透明的每线程 ISession管理。

还有比上面更多的代码（并且我已经大大简化了示例代码），但您已经了解了总体思路。

MyApplication.Repository.BeginUnitOfWork();
User user = User.Repository.FindByEmail("[email protected]");
user.FirstName = "Joe"; // change something
user.LastName = "Bloggs";
// you *can* call User.Repository.Save(user), but you don't need to, because...
MyApplication.Repository.EndUnitOfWork();
// ...causes session flush which saves the changes automatically

在我的 Web 应用程序中，我有每个请求的会话，因此在 BeginRequest 和 EndRequest 中调用 BeginUnitOfWork 和 EndUnitOfWork > 分别。

Answer 2

我有一个与你的非常相似的结构，这是我解决你的问题的方法：

1）为了在每个方法上指定我的容器，我有一个单独的类（“SessionManager")，然后我通过静态属性调用它。通过这样做，下面是使用我的 Save 实现的示例：

private static ISession NHibernateSession
{
    get { return SessionManager.Instance.GetSession(); }
}

public T Save(T entity)
{
    using (var transaction = NHibernateSession.BeginTransaction())
    {
        ValidateEntityValues(entity);
        NHibernateSession.Save(entity);

        transaction.Commit();
    }

    return entity;
}

2) 我的容器不是在每个 ASPX 页面上创建的。我在 global.asax 页面上实例化了我所有的 NHibernate 优点。

** 更多的事情出现了 **

3) 你不需要有一个助手来实例化 Load。您不妨使用 Get 而不是 Load。更多信息@ Load 和 Get 之间的区别。

4）使用当前的代码，您必须为您需要的每个域对象（StoredWillRepository、PersonRepository、CategoryRepository 等？）重复几乎相同的代码，这看起来很麻烦。您很好地使用通用类 通过 NHibernate 进行操作，例如：

public class Dao<T> : IDao<T>
{
    public T SaveOrUpdate(T entity)
    {
        using (var transaction = NHibernateSession.BeginTransaction())
        {
            NHibernateSession.SaveOrUpdate(entity);
            transaction.Commit();
        }

        return entity;
    }
}

在我的实现中，我可以使用 类似于：

Service<StoredWill>.Instance.SaveOrUpdate(will);

Answer 3

从技术上讲，我的问题的答案是使用container.Resolve的重载，它允许您将构造函数参数指定为匿名类型：

IUnitOfWork unitOfWork = [Code to get unit of work];
_storedWillRepository = container.Resolve<IStoredWillRepository>(new { unitOfWork = unitOfWork });

但是让我们面对现实吧，其他人提供的答案信息丰富得多。