asp.net-mvc - 使用 CaSTLe.Windsor 实现 UnitOfWork

Question

简单的问题。

How do I use UnitOfWork with Castle.Windsor, nHibernate, and ASP.NET MVC?

现在了解更多详细信息。在我寻求了解UnitOfWork的过程中模式，我很难遇到任何使用直接示例与 Castle.Windsor 结合使用的内容。 ，特别是关于它需要安装的方式。

这是我到目前为止的理解。

IUnitOfWork

• IUnitOfWork接口(interface)用于声明模式
• UnitOfWork上课必Commit和Rollback交易，并公开 Session .

话虽如此，这是我的 IUnitOfWork 。 (我正在使用Fluent nHibernate)

public interface IUnitOfWork : IDisposable
{
    ISession Session { get; private set; }
    void Rollback();
    void Commit();
}

这是我的 Castle.Windsor容器 Bootstrap (ASP.NET MVC)

public class WindsorContainerFactory
{
    private static Castle.Windsor.IWindsorContainer container;
    private static readonly object SyncObject = new object();

    public static Castle.Windsor.IWindsorContainer Current()
    {
        if (container == null)
        {
            lock (SyncObject)
            {
                if (container == null)
                {
                    container = new Castle.Windsor.WindsorContainer();

                    container.Install(new Installers.SessionInstaller());
                    container.Install(new Installers.RepositoryInstaller());
                    container.Install(new Installers.ProviderInstaller());
                    container.Install(new Installers.ControllerInstaller());
                }
            }

        }

        return container;
    }
}

现在，在我的 Global.asax 中文件，我有以下内容...

    protected void Application_Start()
    {
        AreaRegistration.RegisterAllAreas();

        RegisterGlobalFilters(GlobalFilters.Filters);
        RegisterRoutes(RouteTable.Routes);

        // Register the Windsor Container
        ControllerBuilder.Current
            .SetControllerFactory(new Containers.WindsorControllerFactory());
    }

存储库

现在我明白我需要通过ISession到我的存储库。那么，让我假设IMembershipRepository .

class MembershipRepository : IMembershipRepository
{
   private readonly ISession session;
   public MembershipRepository(ISession session)
   {
      this.session = session;
   }

   public Member RetrieveMember(string email)
   {
      return session.Query<Member>().SingleOrDefault( i => i.Email == email );
   }
}

所以我现在很困惑。使用此方法，ISession没有被正确破坏，并且 UnitOfWork永远不会被使用。

我获悉 UnitOfWork需要进入网络请求级别 - 但我找不到任何解释如何实际执行此操作的内容。我不使用ServiceLocator任何形式(当我尝试时，我被告知这也是不好的做法......)。

Confusion -- How does a UnitOfWork get created?

我只是不明白这一点，在 一般的。我的想法是我会 开始传递UnitOfWork进入 Repository构造函数 - 但如果它 必须进入网络请求，我不是 了解两者的关系。

更多代码

这是用于澄清的额外代码，只是因为我似乎有一个习惯，从不为我的问题提供正确的信息。

安装程序

public class ControllerInstaller : IWindsorInstaller
{
    public void Install(IWindsorContainer container, IConfigurationStore store)
    {
        container.Register(
            AllTypes.FromThisAssembly()
            .BasedOn<IController>()
            .Configure(c => c.LifeStyle.Transient));
    }
}

public class ProviderInstaller : IWindsorInstaller
{
    public void Install(IWindsorContainer container, IConfigurationStore store)
    {
        container.Register(
            Component
            .For<Membership.IFormsAuthenticationProvider>()
            .ImplementedBy<Membership.FormsAuthenticationProvider>()
            .LifeStyle.Singleton
        );
    }
}

public class RepositoryInstaller : IWindsorInstaller
{
    public void Install(IWindsorContainer container, IConfigurationStore store)
    {
        container.Register(
            Component
            .For<Membership.IMembershipRepository>()
            .ImplementedBy<Membership.MembershipRepository>()
            .LifeStyle.Transient
        );

        container.Register(
            Component
            .For<Characters.ICharacterRepository>()
            .ImplementedBy<Characters.CharacterRepository>()
            .LifeStyle.Transient
        );
    }
}

public class SessionInstaller : Castle.MicroKernel.Registration.IWindsorInstaller
{
    private static ISessionFactory factory;
    private static readonly object SyncObject = new object();

    public void Install(Castle.Windsor.IWindsorContainer container, IConfigurationStore store)
    {
        container.Register(
            Component.For<ISessionFactory>()
                .UsingFactoryMethod(SessionFactoryFactory)
                .LifeStyle.Singleton
            );

        container.Register(
            Component.For<ISession>()
            .UsingFactoryMethod(c => SessionFactoryFactory().OpenSession())
            .LifeStyle.Transient
        );
    }

    private static ISessionFactory SessionFactoryFactory()
    {
        if (factory == null)
            lock (SyncObject)
                if (factory == null)
                    factory = Persistence.SessionFactory.Map(System.Web.Configuration.WebConfigurationManager.ConnectionStrings["Remote"].ConnectionString);
        return factory;
    }
}

工作单元

这是我的UnitOfWork逐字上课。

public class UnitOfWork : IUnitOfWork
{
    private readonly ISessionFactory sessionFactory;
    private readonly ITransaction transaction;

    public UnitOfWork(ISessionFactory sessionFactory)
    {
        this.sessionFactory = sessionFactory;
        Session = this.sessionFactory.OpenSession();
        transaction = Session.BeginTransaction();
    }

    public ISession Session { get; private set; }

    public void Dispose()
    {
        Session.Close();
        Session = null;
    }

    public void Rollback()
    {
        if (transaction.IsActive)
            transaction.Rollback();
    }

    public void Commit()
    {
        if (transaction.IsActive)
            transaction.Commit();
    }
}

Answer 1

您的 NH session 已经是一个工作单元 http://nhforge.org/wikis/patternsandpractices/nhibernate-and-the-unit-of-work-pattern.aspx

所以我不确定为什么你需要进一步抽象它。 (如果阅读此答案的人知道为什么我很高兴听到，老实说我从未听说过您需要的任何原因......)

我将实现一个简单的“每个请求 session ”。我不知道你会如何使用 Windsor 来做到这一点，因为我从未使用过它，但是使用 StructureMap 就相当简单了。

我包装了结构图工厂来保存我的 session 工厂，并根据需要将 session 注入(inject)到存储库中。

    public static class IoC
    {
        static IoC()
        {
            ObjectFactory.Initialize(x =>
            {
                x.UseDefaultStructureMapConfigFile = false;

                // NHibernate ISessionFactory
                x.ForSingletonOf<ISessionFactory>()
                 .Use(new SessionFactoryManager().CreateSessionFactory());

                // NHibernate ISession
                x.For().HybridHttpOrThreadLocalScoped()
                 .Use(s => s.GetInstance<ISessionFactory>().OpenSession());

                x.Scan(s => s.AssembliesFromApplicationBaseDirectory());
            });

            ObjectFactory.AssertConfigurationIsValid();
        }

        public static T Resolve<T>()
        {
            return ObjectFactory.GetInstance<T>();
        }

        public static void ReleaseAndDisposeAllHttpScopedObjects()
        {
            ObjectFactory.ReleaseAndDisposeAllHttpScopedObjects();
        }
    }

在 Request_End 的 global.asax 文件中，我调用 ReleaseAndDisposeAllHttpScopedObjects() 方法。

        protected void Application_EndRequest(object sender, EventArgs e)
        {
            IoC.ReleaseAndDisposeAllHttpScopedObjects();
        }

因此，当我调用第一个存储库时， session 就会打开，并且当请求结束时， session 就会被丢弃。存储库有一个构造函数，它接受 ISession 并将其分配给一个属性。然后我只需解析存储库，如下所示:

var productRepository = IoC.Resolve<IProductRepository>();

希望有帮助。还有很多其他方法可以做到这一点，这对我有用。