StructureMap/nhibernate设置有问题：

我不断得到以下错误：

无法访问已释放的对象。 对象名称：“AdoTransaction”

设置遵循在中给出的示例

以下是IUnitOfWork类（与链接中的类完全相同）：

这是NHibernateModule（同样完全相同！）：

公共类NHibernateModule:IHttpModule，IDisposable
{
私人工作单位；
公共void Init（HttpApplication上下文）
{
context.BeginRequest+=ContextBeginRequest；
context.EndRequest+=ContextEndRequest；
}
私有void ContextBeginRequest（对象发送方，事件参数e）
{
_unitOfWork=ObjectFactory.GetInstance（）；
}
私有void ContextEndRequest（对象发送方，事件参数e）
{
处置（）；
}
公共空间处置（）
{
if（_unitOfWork==null）返回；
_unitOfWork.Commit（）；
_unitOfWork.Dispose（）；
}
}

这是我的回购协议：

 public class Repository<T> : IRepository<T>
{
    public readonly IUnitOfWork _uow;

    public Repository(IUnitOfWork uow)
    {
        _uow = uow;
    }

    public Repository()
    {

    }

    #region IRepository<T> Members

    public IList<T> GetAll()
    {
        using (var session = _uow.CurrentSession)
        {
            return session.CreateCriteria(typeof (T)).List<T>();
        }
    }

    public IList<T> FindAll<T>(IList<Expression<Func<T, bool>>> criteria)
    {
        var session = _uow.CurrentSession;

        var query = from item in session.SessionFactory.OpenSession().Query<T>()
                              select item;
        foreach (var criterion in criteria)
        {
            query = query.Where(criterion);
        }
        return query.ToList();
    }

    public T FindFirst<T>(IList<Expression<Func<T, bool>>> criteria)
    {

        var col = FindAll(criteria);

        if (col.Count > 0)
        {
            return col.First();
        }
        else
        {
            return default(T);
        }
    }

    public T Get(int id)
    {
        using (var session = _uow.CurrentSession)
        {
            return session.Get<T>(id);
        }
    }

    public void Save(T entity)
    {
        using (var session = _uow.CurrentSession)
        {
            session.Save(entity);
        }
    }

    public void Update(T entity)
    {
        using (var session = _uow.CurrentSession)
        {
            session.Update(entity);
            session.Flush();
        }
    }

    #endregion
}
}

公共类存储库：IRepository
{
公共只读IUnitOfWork；
公共存储库（IUnitOfWork uow）
{
_uow=uow；
}
公共存储库（）
{
}
#地区成员
公共IList GetAll（）
{
使用（var会话=_uow.CurrentSession）
{
return session.CreateCriteria（typeof（T））.List（）；
}
}
公共IList FindAll（IList标准）
{
var会话=_uow.CurrentSession；
var query=来自session.SessionFactory.OpenSession（）.query（）中的项
选择项目；
foreach（标准中的var标准）
{
query=query.Where（条件）；
}
返回query.ToList（）；
}
公共T FindFirst（IList标准）
{
var col=FindAll（标准）；
如果（列计数>0）
{
返回第一列（）；
}
其他的
{
返回默认值（T）；
}
}
公共T获取（int id）
{
使用（var会话=_uow.CurrentSession）
{
返回会话.Get（id）；
}
}
公共作废保存（T实体）
{
使用（var会话=_uow.CurrentSession）
{
session.Save（实体）；
}
}
公共无效更新（T实体）
{
使用（var会话=_uow.CurrentSession）
{
更新（实体）；
session.Flush（）；
}
}
#端区
}
}

这是我的引导程序：

 public class BootStrapper : IBootstrapper
{
    private static bool _hasStarted;

    public virtual void BootstrapStructureMap()
    {
        ObjectFactory.Initialize(x =>
        {
            x.Scan(s =>
            {
                s.TheCallingAssembly();
                s.AssemblyContainingType<User>();
                s.AssemblyContainingType<UserRepository>();
                s.AssemblyContainingType<NHibernateRegistry>();
                s.LookForRegistries();
            });

            // Repositories
            x.For<WmcStar.Data.IUserRepository>()
                .CacheBy(InstanceScope.HttpContext)
                .TheDefault.Is.OfConcreteType<UserRepository>();

            x.For<IDatabaseBuilder>().TheDefaultIsConcreteType<DatabaseBuilder>(); 

        });
    }

    public static void Restart()
    {
        if (_hasStarted)
        {
            ObjectFactory.ResetDefaults();
        }
        else
        {
            Bootstrap();
            _hasStarted = true;
        }
    }

    public static void Bootstrap()
    {
        new BootStrapper().BootstrapStructureMap();
    }

}

公共类引导程序：IBootstrapper
{
私人静态文件已启动；
公共虚拟void BootstrapStructureMap（）
{
ObjectFactory.Initialize（x=>
{
x、 扫描（s=>
{
s、 装配件（）；
s、 AssemblyContainingType（）；
s、 AssemblyContainingType（）；
s、 AssemblyContainingType（）；
s、 查找注册表（）；
});
//存储库
x、 For（）
.CacheBy（InstanceScope.HttpContext）
.TheDefault.Is.of ConcreteType（）；
x、 For（）。默认的混凝土类型（）；
});
}
公共静态void Restart（）
{
如果（已开始）
{
ResetDefaults（）；
}
其他的
{
Bootstrap（）；
_hasStarted=true；
}
}
公共静态无效引导（）
{
新的引导程序（）.BootstrapStructureMap（）；
}
}

这是我的NHibernate注册表：

public class NHibernateRegistry : Registry
{
    public NHibernateRegistry()
    {
        var cfg = new Configuration()
             .SetProperty(NHibernate.Cfg.Environment.ReleaseConnections, "on_close")
             .SetProperty(NHibernate.Cfg.Environment.Dialect, typeof(NHibernate.Dialect.MsSql2005Dialect).AssemblyQualifiedName)
             .SetProperty(NHibernate.Cfg.Environment.ConnectionDriver, typeof(NHibernate.Driver.SqlClientDriver).AssemblyQualifiedName)
             .SetProperty(NHibernate.Cfg.Environment.ConnectionString, @"my connstring")
             .SetProperty(NHibernate.Cfg.Environment.ProxyFactoryFactoryClass, typeof(ProxyFactoryFactory).AssemblyQualifiedName)
             .AddAssembly(typeof(User).Assembly);

        var sessionFactory = cfg.BuildSessionFactory();

        For<Configuration>().Singleton().Use(cfg);

        For<ISessionFactory>().Singleton().Use(sessionFactory);


        For<ISession>().HybridHttpOrThreadLocalScoped()
            .Use(ctx => ctx.GetInstance<ISessionFactory>().OpenSession());

        For<IUnitOfWork>().HybridHttpOrThreadLocalScoped()
            .Use<UnitOfWork>();

        For<IDatabaseBuilder>().Use<DatabaseBuilder>();
        SetAllProperties(x => x.OfType<IUnitOfWork>());
    }
}

公共类NHibernateRegistry:注册表
{
公共NHibernateRegistry（）
{
var cfg=新配置（）
.SetProperty（NHibernate.Cfg.Environment.ReleaseConnections，“打开/关闭”）
.SetProperty（NHibernate.Cfg.Environment.dialogue，typeof（NHibernate.dialogue.mssql2005dialogue）.AssemblyQualifiedName）
.SetProperty（NHibernate.Cfg.Environment.ConnectionDriver，typeof（NHibernate.Driver.SqlClientDriver）.AssemblyQualifiedName）
.SetProperty（NHibernate.Cfg.Environment.ConnectionString，@“我的连接字符串”）
.SetProperty（NHibernate.Cfg.Environment.ProxyFactoryFactoryClass，typeof（ProxyFactoryFactory）.AssemblyQualifiedName）
.AddAssembly（类型（用户）.Assembly）；
var sessionFactory=cfg.BuildSessionFactory（）；
For（）.Singleton（）.Use（cfg）；
For（）.Singleton（）.Use（sessionFactory）；
For（）.HybridHttpOrthReadLocalScope（）的
.Use（ctx=>ctx.GetInstance（）.OpenSession（））；
For（）.HybridHttpOrthReadLocalScope（）的
.使用（）；
For（）.Use（）；
SetAllProperties（x=>x.OfType（））；
}
}

最后是我的global.asax：

    public class Global : System.Web.HttpApplication
{

    protected void Application_Start(object sender, EventArgs e)
    {
        BootStrapper.Bootstrap();
        new SchemaExport(ObjectFactory.GetInstance<Configuration>()).Execute(false, true, false);
        ObjectFactory.GetInstance<IDatabaseBuilder>().RebuildDatabase();

        AutoMapper.Mapper.CreateMap<WmcStar.Model.User, WmcStar.Data.Dto.User>();
    }
}

公共类全局：System.Web.HttpApplication
{
受保护的无效应用程序\u启动（对象发送方，事件参数e）
{
BootStrapper.Bootstrap（）；
新SchemaExport（ObjectFactory.GetInstance（））.Execute（false、true、false）；
ObjectFactory.GetInstance（）.RebuildDatabase（）；
AutoMapper.Mapper.CreateMap（）；
}
}

有人知道这是什么原因吗

---

w://

也许它与StructureMap和NHibernate的组合无关，而与您的代码有关？我猜测您没有看到代码，但很可能您正在处理一个事务，然后尝试访问它。

也许它与StructureMap和NHibernate的组合无关，而与您的代码有关？我在猜测时没有看到代码，但很可能您正在处理一个事务，然后尝试访问它。

我不知道导致异常的确切问题是什么，但我发现了一些潜在问题：

在请求结束时提交工作单元，并在提交失败时回滚

在请求期间引发异常时回滚工作单元

不要在结束时调用dispose

public class NHibernateRegistry : Registry
{
    public NHibernateRegistry()
    {
        var cfg = new Configuration()
             .SetProperty(NHibernate.Cfg.Environment.ReleaseConnections, "on_close")
             .SetProperty(NHibernate.Cfg.Environment.Dialect, typeof(NHibernate.Dialect.MsSql2005Dialect).AssemblyQualifiedName)
             .SetProperty(NHibernate.Cfg.Environment.ConnectionDriver, typeof(NHibernate.Driver.SqlClientDriver).AssemblyQualifiedName)
             .SetProperty(NHibernate.Cfg.Environment.ConnectionString, @"my connstring")
             .SetProperty(NHibernate.Cfg.Environment.ProxyFactoryFactoryClass, typeof(ProxyFactoryFactory).AssemblyQualifiedName)
             .AddAssembly(typeof(User).Assembly);

        var sessionFactory = cfg.BuildSessionFactory();

        For<Configuration>().Singleton().Use(cfg);

        For<ISessionFactory>().Singleton().Use(sessionFactory);


        For<ISession>().HybridHttpOrThreadLocalScoped()
            .Use(ctx => ctx.GetInstance<ISessionFactory>().OpenSession());

        For<IUnitOfWork>().HybridHttpOrThreadLocalScoped()
            .Use<UnitOfWork>();

        For<IDatabaseBuilder>().Use<DatabaseBuilder>();
        SetAllProperties(x => x.OfType<IUnitOfWork>());
    }
}

    public class Global : System.Web.HttpApplication
{

    protected void Application_Start(object sender, EventArgs e)
    {
        BootStrapper.Bootstrap();
        new SchemaExport(ObjectFactory.GetInstance<Configuration>()).Execute(false, true, false);
        ObjectFactory.GetInstance<IDatabaseBuilder>().RebuildDatabase();

        AutoMapper.Mapper.CreateMap<WmcStar.Model.User, WmcStar.Data.Dto.User>();
    }
}

using (var transaction = _session.BeginTransaction())
{
  var user = ObjectFactory.GetNamedInstance<User>("CurrentUser");
  var myObjects = _session.QueryOver<myObject>().Where(x => x.User == CurrentUser).Future();
  transaction.Commit();
}

var user = ObjectFactory.GetNamedInstance<User>("CurrentUser");
using (var transaction = _session.BeginTransaction())
{
  var myObjects = _session.QueryOver<MyObject>().Where(x => x.User == CurrentUser).Future();
  transaction.Commit();
}