如何使用 Fluent nhibernate 设置我的存储库？

Question

我正在尝试使用存储库模式，ninject for DI with Fluent nhibernate。

我把我的解决方案分成了 3 个项目，

web ui - controllers,view (I am using asp.net mvc 2.0)
framework - repository, domain, fluent mapping
tests - where my unit tests will go.

所以我已经设置好了。

Global.aspx

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

            RegisterRoutes(RouteTable.Routes);

            ControllerBuilder.Current.SetControllerFactory(new NinjectControllerFactory());
        }

所以我在我的应用程序中开始使用 ninject 控制器工厂。

NinjectControllerFactory

 public class NinjectControllerFactory : DefaultControllerFactory
    {
        // A Ninject "kernel" is the thing that can supply object instances
        private IKernel kernel = new StandardKernel(new T4GDemoSevice());

        // ASP.NET MVC calls this to get the controller for each request
        protected override IController GetControllerInstance(RequestContext context, Type controllerType)
        {
            if (controllerType == null)
                return null;
            return (IController)kernel.Get(controllerType);
        }

        // Configures how abstract service types are mapped to concrete implementations
        private class DemoSevice : NinjectModule
        {
            public override void Load()
            {
                Bind<ISessionFactory>().ToMethod(c => GetSessionFactory()).InSingletonScope();
                Bind<ISession>().ToMethod(c => c.Kernel.Get<ISessionFactory>().OpenSession()).InRequestScope();
                Bind<IUsers>().To<UsersRepo>().WithConstructorArgument("session",GetSessionFactory());
            }

            public static ISessionFactory GetSessionFactory()
            {
                return Fluently.Configure()
                    .Database(MsSqlConfiguration.MsSql2008.ConnectionString(c => c.FromConnectionStringWithKey("test")))
                    .Mappings(m => m.FluentMappings.AddFromAssemblyOf<T4G_Demo.Framework.Data.NhibernateMapping.UserMap>())
                    .BuildSessionFactory();
            }

        }
    }

在这里我设置了我的 ninject 东西。我做了一个设置流畅的方法。据我了解，每个网络请求这只应该发生一次（我认为它会发生，因为这只在应用程序启动时被调用），

但我不确定我的 GetSessionFactory 方法是否应该是静态的。

然后，我将 IUsers 接口绑定到 UserRepo 并传入构造函数参数。我猜测我的存储库需要 nhibernate 会话来执行某些操作。所以我不确定如何将它传递到我的存储库。

我认为我所拥有的可能是错误的，因为每个存储库都会得到它的配置？

存储库

public class UsersRepo : IUsers
    {
        private ISessionFactory session;
        public UsersRepo(ISessionFactory session)
        {
            this.session = session;
        }

        public void CreateUser(Domain.Users newUser)
        {
            var openSession = session.OpenSession();
            var transaction = openSession.BeginTransaction();
            openSession.SaveOrUpdate(newUser);
            transaction.Commit();
        }
    }

我尝试创建一个存储库，但我再次不确定如何使用会话来完成它。就像我必须打开它并开始交易一样。我不确定这是否应该在其他地方完成。

我也不确定在经过这些方法后是否应该处置它。我看到人们在 application_end() 中有 dispose 方法。

我的家庭控制器

private IUsers usersRepository;

         public HomeController(IUsers usersRepository)
        {
            this.usersRepository = usersRepository;
        }

        public ActionResult Index()
        {
            Users test = new Users()
            {
                OpenIdIdentifier = "123",
                Email = "[email protected]",

            };

           usersRepository.CreateUser(test);

            return View();
        }

最后，我刚刚制作了一个虚拟控制器，它创建一个虚拟用户并将其插入数据库。它有效，但就像我说的，会话部分让我感到困惑，因为我不知道如何传递它。

编辑

这是我到目前为止所想出的。它仍然不是我想要的（我宁愿每个请求都有一个会话），但它似乎正在工作。

Ninject 工厂

  public static ISessionFactory GetSessionFactory()
        {
            if (session == null)
            {
                return Fluently.Configure()
                .Database(MsSqlConfiguration.MsSql2008.ConnectionString(c => c.FromConnectionStringWithKey("test")))
                .Mappings(m => m.FluentMappings.AddFromAssemblyOf<T4G_Demo.Framework.Data.NhibernateMapping.UserMap>())
                //.ExposeConfiguration(BuidSchema)
                .BuildSessionFactory();


            }

            return session;              
        }

我添加了一个 if 语句来检查会话是否已启动。所以这样应该可以解决每次启动SessionFactory的问题。

我的存储库看起来像这样

 public class UsersRepo : IUsers
    {
        private ISession openSession;
        private ISessionFactory session;
        public UsersRepo(ISessionFactory session)
        {
            this.openSession = session.OpenSession();
            this.session = session;
        }

        public void CreateUser(Users newUser)
        {
          openSession = NhibernateUtilities.OpenIfClosed(session, openSession);
          openSession.SaveOrUpdate(newUser);         
        }

        public Users GetUser(Guid userId)
        {
            openSession = NhibernateUtilities.OpenIfClosed(session, openSession);
            var query = from b in openSession.Query<Users>()
                        where b.UserId == userId
                        select b;
            return query.SingleOrDefault();
        }

        public void DeleteUser(Users user)
        {
            openSession = NhibernateUtilities.OpenIfClosed(session, openSession);
            openSession.Delete(user);
        }

        public void SaveOrUpdate()
        {
            using (openSession)
            {
                using (var transaction = openSession.BeginTransaction())
                {
                    transaction.Commit();
                }
            }
        }

因此，在每种方法中，我都会检查会话是否打开，如果没有，则通过此方法打开一个会话。

 public static ISession OpenIfClosed(ISessionFactory session, ISession openSession)
        {
            if (openSession.IsOpen == false)
            {
                return session.OpenSession();
            }

            return openSession;
        }

就像我说的，我很想摆脱这种方法，但我不确定如何将会话转移到存储库。因此，在有人可以向我展示之前，我想我现在必须这样做。

Answer 1

首先，您可能会考虑使用 Ninject.Web.Mvc 扩展，因为它已经具有 NinjectControllerFactory 和一个为您连接控制器工厂的 NinjectHttpApplication 。这还允许您在应用程序中创建 IKernel，这是它应该在的位置，而不是在控制器工厂中。

其次，SessionFactory 的创建成本非常高，因此在应用程序的生命周期内只应执行一次，即单例。

这是我在应用程序中使用的模块：

public class RepositoriesModule : Ninject.Modules.NinjectModule
{
    public override void Load()
    {
        // NHibernate
        Bind<ISessionFactory>().ToProvider<SessionFactoryBuilder>()
            .InSingletonScope();

        Bind<ISession>()
            .ToMethod( CreateSession )
            .InRequestScope();

        // Model Repositories
        Bind( typeof( IRepository<> ) ).To( typeof( NHibernateRepository<> ) ).InScope( HttpOrThread );
        Bind<IGameRepository>().To<GameRepository>();
        Bind<ILogRepository>().To<LogRepository>();
        Bind<IMemberRepository>().To<MemberRepository>();

        Bind<IScopeManager>().To<ScopeManager>();
    }

    private ISession CreateSession( Ninject.Activation.IContext context )
    {
        var session = context.Kernel.Get<ISessionFactory>().OpenSession();
        session.EnableFilter( DigitalLights.Model.FluentLogicalDeleteFilter.FilterName );
        return session;
    }

}

兴趣点 - ISessionFactory 与 Singleton 范围内的 Provider 绑定。 Provider 在启动时简单地创建 SessionFactory。这是提供者的样子。

/// <summary>
/// factory builder that uses FluentNHibernate to configure and return a SessionFactory
/// </summary>
public class SessionFactoryBuilder : Ninject.Activation.IProvider
{
    private ISessionFactory _sessionFactory;

    /// <summary>
    /// constructor configures a SessionFactory based on the configuration passed in
    /// </summary>
    /// <param name="configuration"></param>
    public SessionFactoryBuilder()
    {
        /// setup configuration here

        var fluentConfig = Fluently.Configure()
            .Database( MsSqlConfiguration.MsSql2005.ConnectionString( connectionString ) );

        this._sessionFactory = fluentConfig.BuildSessionFactory();
    }

    #region IProvider Members

    public object Create( Ninject.Activation.IContext context )
    {
        return _sessionFactory;
    }

    public Type Type
    {
        get { return typeof( ISessionFactory ); }
    }

    #endregion
}

接下来，NHibernate ISession 通过 CreateSession 方法创建，该方法从内核检索 ISessionFactory。 ISession 的范围仅限于请求。然后，存储库实现只需在其构造函数中请求 ISession 即可。

另外，在我的应用程序中，在 BeginRequest 中启动 ITransaction，在 EndRequest 中提交 ITransaction，以确保会话保持并关闭。