NHibernate Windsor每个请求的实现

Question

I used NHibernate and Castle Windsor Injection in my project. My NHibernate implementation is like this:

Component.For<ISessionFactory>().UsingFactoryMethod(CreateSessionFactory).LifestyleSingleton(),
Component.For<IUnitOfWork>().ImplementedBy<UnitOfWork>().LifestyleSingleton(),
Component.For<ISession>().UsingFactoryMethod(k => k.Resolve<ISessionFactory>().OpenSession()).LifestylePerWebRequest(),

If I want to double refresh page or open some page on new tab, I will get error which is

ExecuteReader requires an open and available Connection. The connection's current state is closed.

Is there any mistake in my implementation? What is wrong? How can I solve that?

This is UnitOfWork Class: public UnitOfWork Current { get { if (_current == null) _current = new UnitOfWork(sessionFactory, Session); return _current; } } [ThreadStatic] private UnitOfWork _current;

    /// <summary>
    /// Gets Nhibernate session object to perform queries.
    /// </summary>
    public ISession Session { get; get; }

    /// <summary>
    /// Reference to the session factory.
    /// </summary>
    private readonly ISessionFactory sessionFactory;

    /// <summary>
    /// Reference to the currently running transcation.
    /// </summary>
    private ITransaction transaction;

    /// <summary>
    /// Creates a new instance of NhUnitOfWork.
    /// </summary>
    /// <param name="sessionFactory"></param>
    public UnitOfWork(ISessionFactory _sessionFactory, ISession _session)
    {
        sessionFactory = _sessionFactory;
        Session = _session;
    }

    /// <summary>
    /// Opens database connection and begins transaction.
    /// </summary>
    public void BeginTransaction(IsolationLevel isoLevel=IsolationLevel.ReadCommitted)
    {
        transaction = Session.BeginTransaction(isoLevel);
    }

    /// <summary>
    /// Commits transaction and closes database connection.
    /// </summary>
    public void Commit()
    {
        transaction.Commit();
    }

    /// <summary>
    /// Rollbacks transaction and closes database connection.
    /// </summary>
    public void Rollback()
    {
        transaction.Rollback();
    }

    public void Dispose()
    {
        //Session.Dispose();
    }

Answer 1

If you are doing this in a web project and your PerWebRequest windsor Lifestyle suggests that, I would get rid of your unit of work implementation and work directly with the request events from gloabl.asax. In the web, the unit of work is the request. I also like to wire up Windsor using installers. Here's a config that works for me.

public class MvcApplication : HttpApplication
{
    private const String Sessionkey = "current.session";
    private static IWindsorContainer Container { get; set; }
    private static ISessionFactory SessionFactory { get; set; }

    public static ISession CurrentSession
    {
        get { return (ISession) HttpContext.Current.Items[Sessionkey]; }
        private set { HttpContext.Current.Items[Sessionkey] = value; }
    }

    protected void Application_Start()
    {
        Version version = Assembly.GetExecutingAssembly().GetName().Version;
        Application["Version"] = String.Format("{0}.{1}", version.Major, version.Minor);
        Application["Name"] = ConfigurationManager.AppSettings["ApplicationName"];

        //create empty container
        //scan this assembly for any installers to register services/components with Windsor
        Container = new WindsorContainer().Install(FromAssembly.This());

        //API controllers use the dependency resolver and need to be initialized differently than the mvc controllers
        GlobalConfiguration.Configuration.DependencyResolver = new WindsorDependencyResolver(Container.Kernel);

        //tell ASP.NET to get its controllers from Castle
        ControllerBuilder.Current.SetControllerFactory(new WindsorControllerFactory(Container.Kernel));

        //initialize NHibernate
        ConnectionStringSettings connectionString = ConfigurationManager.ConnectionStrings[Environment.MachineName];

        if (connectionString == null)
            throw new ConfigurationErrorsException(String.Format("Connection string {0} is empty.",
                Environment.MachineName));

        if (String.IsNullOrWhiteSpace(connectionString.ConnectionString))
            throw new ConfigurationErrorsException(String.Format("Connection string {0} is empty.",
                Environment.MachineName));

        string mappingAssemblyName = ConfigurationManager.AppSettings["NHibernate.Mapping.Assembly"];

        if (String.IsNullOrWhiteSpace(mappingAssemblyName))
            throw new ConfigurationErrorsException(
                "NHibernate.Mapping.Assembly key not set in application config file.");

        var nh = new NHInit(connectionString.ConnectionString, mappingAssemblyName);
        nh.Initialize();
         SessionFactory = nh.SessionFactory;

        AutoMapConfig.RegisterMaps();
        AreaRegistration.RegisterAllAreas();
        FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
        RouteConfig.RegisterRoutes(RouteTable.Routes);
        BundleConfig.RegisterBundles(BundleTable.Bundles);
        ModelBinderConfig.RegisterModelBinders(ModelBinders.Binders);

        AntiForgeryConfig.UniqueClaimTypeIdentifier = ClaimTypes.NameIdentifier;
    }

    protected void Application_OnEnd()
    {
        //dispose Castle container and all the stuff it contains
        Container.Dispose();
    }

    protected void Application_BeginRequest() { CurrentSession = SessionFactory.OpenSession(); }

    protected void Application_EndRequest()
    {
        if (CurrentSession != null)
            CurrentSession.Dispose();
    }

} }

Here's my NhInit class

public class NHInit : NHibernateInitializer
{
    public NHInit(String connectionString, String mappingAssemblyName) : base(connectionString, mappingAssemblyName)
    {
    }
}

NHibernateInitializer

public abstract class NHibernateInitializer : IDomainMapper
{
    protected Configuration Configure;
    private ISessionFactory _sessionFactory;
    private readonly ModelMapper _mapper = new ModelMapper();
    private Assembly _mappingAssembly;
    private readonly String _mappingAssemblyName;
    private readonly String _connectionString;

    protected NHibernateInitializer(String connectionString, String mappingAssemblyName)
    {
        if (String.IsNullOrWhiteSpace(connectionString))
            throw new ArgumentNullException("connectionString", "connectionString is empty.");

        if (String.IsNullOrWhiteSpace(mappingAssemblyName))
            throw new ArgumentNullException("mappingAssemblyName", "mappingAssemblyName is empty.");

        _mappingAssemblyName = mappingAssemblyName;
        _connectionString = connectionString;
    }

    public ISessionFactory SessionFactory
    {
        get
        {
            return _sessionFactory ?? (_sessionFactory = Configure.BuildSessionFactory());
        }
    }

    private Assembly MappingAssembly
    {
        get
        {
            return _mappingAssembly ?? (_mappingAssembly = Assembly.Load(_mappingAssemblyName));
        }
    }

    public void Initialize()
    {
        Configure = new Configuration();
        Configure.EventListeners.PreInsertEventListeners = new IPreInsertEventListener[] { new EventListener() };
        Configure.EventListeners.PreUpdateEventListeners = new IPreUpdateEventListener[] { new EventListener() };
        Configure.SessionFactoryName(System.Configuration.ConfigurationManager.AppSettings["SessionFactoryName"]);
        Configure.DataBaseIntegration(db =>
                                      {
                                          db.Dialect<MsSql2008Dialect>();
                                          db.Driver<SqlClientDriver>();
                                          db.KeywordsAutoImport = Hbm2DDLKeyWords.AutoQuote;
                                          db.IsolationLevel = IsolationLevel.ReadCommitted;
                                          db.ConnectionString = _connectionString;
                                          db.BatchSize = 20;
                                          db.Timeout = 10;
                                          db.HqlToSqlSubstitutions = "true 1, false 0, yes 'Y', no 'N'";
                                      });
        Configure.SessionFactory().GenerateStatistics();

        Map();
    }

    public virtual void InitializeAudit()
    {
        var enversConf = new Envers.Configuration.Fluent.FluentConfiguration();

        enversConf.Audit(GetDomainEntities());

        Configure.IntegrateWithEnvers(enversConf);
    }

    public void CreateSchema()
    {
        new SchemaExport(Configure).Create(false, true);
    }

    public void DropSchema()
    {
        new SchemaExport(Configure).Drop(false, true);
    }

    private void Map()
    {
        _mapper.AddMappings(MappingAssembly.GetExportedTypes());
        Configure.AddDeserializedMapping(_mapper.CompileMappingForAllExplicitlyAddedEntities(), "MyWholeDomain");
    }

    public HbmMapping HbmMapping
    {
        get { return _mapper.CompileMappingFor(MappingAssembly.GetExportedTypes()); }
    }

    public IList<HbmMapping> HbmMappings
    {
        get { return _mapper.CompileMappingForEach(MappingAssembly.GetExportedTypes()).ToList(); }
    }

    /// <summary>
    /// Gets the domain entities.
    /// </summary>
    /// <returns></returns>
    /// <remarks>by default anything that derives from EntityBase and isn't abstract or generic</remarks>
    protected virtual IEnumerable<System.Type> GetDomainEntities()
    {
        List<System.Type> domainEntities = (from t in MappingAssembly.GetExportedTypes()
                                            where typeof(EntityBase<Guid>).IsAssignableFrom(t)
                                            && (!t.IsGenericType || !t.IsAbstract)
                                            select t
                                           ).ToList();

        return domainEntities;
    }
}

SessionInstaller

public class SessionInstaller : IWindsorInstaller
{
    public void Install(IWindsorContainer container, IConfigurationStore store)
    {
        container
            .Register(Component.For<ISession>().UsingFactoryMethod(() => MvcApplication.CurrentSession)
                .LifeStyle
                .PerWebRequest);
    }
}

ControllersInstaller

public class ControllersInstaller : IWindsorInstaller
{
    public void Install(IWindsorContainer container, IConfigurationStore store)
    {
        container.Register(Classes.FromThisAssembly()
            .BasedOn<IController>()
            .LifestyleTransient());
    }
}

Controller Factory

public class WindsorControllerFactory : DefaultControllerFactory
{
    // Fields
    private readonly IKernel _kernel;

    // Methods
    public WindsorControllerFactory(IKernel kernel)
    {
        if (kernel == null)
            throw new ArgumentNullException("kernel");

        _kernel = kernel;
    }

    protected override IController GetControllerInstance(RequestContext context, Type controllerType)
    {
        if (controllerType == null)
            throw new HttpException(0x194,
                string.Format(
                    "The controller for path '{0}' could not be found or it does not implement IController.",
                    context.HttpContext.Request.Path));

        return (IController) _kernel.Resolve(controllerType);
    }
}