Asp.net mvc 什么会导致NHibernate'；s Save方法以静默方式失败？

我的任务是接管一个现有的ASP.NET MVC 2.0 web应用程序，该应用程序是由第三方开发人员开发的，他不再提供任何帮助。有一项要求是向项目中添加一些功能，这要求项目升级到.NET 4.5，该升级已经执行

MSSQL 2008 R2数据库访问的基础站点已使用NHibernate版本2.0.1.4000以及Castle和FluentNHibernate实现

这是我参与的第一个使用NHibernate的项目，我遇到了一个困扰我的问题。在升级到.NET 4.5之前，该问题并不存在

除一个数据库操作外，所有数据库操作均正常工作。保存特定对象(

Opportunity

type）到数据库（此对象直接映射到Opportunity数据库表）失败。在保存（在本例中为SQL UPDATE语句）之前，对象设置了新值。但数据库中的记录保存后总是具有旧值

连接log4net以查看调试代码表明记录确实已更新，但在UPDATE语句中使用了旧值

令人惊讶的是，

Opportunity

对象最初是使用相同的保存方法保存的（尽管是通过不同的操作方法），这样就可以保存到数据库中

所以我的问题是，什么会导致这种情况发生？既然我不是NHibernate专家，那么NHibernate版本是否与.NET4.5完全不兼容？或者任何人都可以提供一个指针，指出问题可能是什么？我很乐意展示任何代码，但由于代码太多，我需要知道是什么。下面是一个开始：

Global.asax对NHibernate的引用如下：

private static void MvcApplication_BeginRequest(object sender, System.EventArgs e)
{
    NHibernateSessionManager.Instance.BeginTransaction();
}

private static void MvcApplication_EndRequest(object sender, System.EventArgs e)
{
    NHibernateSessionManager.Instance.CommitTransaction();
}

NHibernateSessionManager

类定义为（

Opportunity

源自

DomainBase

）：

公共密封类NHibernateSessionManager
{
私人ISessionFactory sessionFactory；
私有配置；
#区域线程安全、懒惰的单例
公共静态NHibernateSessionManager实例
{
得到
{
返回Nested.nHibernateSessionManager；
}
}
私人NHibernateSessionManager（）
{
InitSessionFactory（）；
}
私有类嵌套
{
内部静态只读NHibernateSessionManager NHibernateSessionManager=新的NHibernateSessionManager（）；
}
#端区
私有void InitSessionFactory（）
{
var autoMappings=AutoPersistenceModel.mapentiesfromsassemblyof（）的
。其中（类型=>
typeof（DomainBase）.IsAssignableFrom（类型）&&
type.IsClass&&
！type.IsAbstract）
.带设置（s=>
{
s、 IsBaseType=type=>
type==typeof（DomainBase）；
})
.UseOverridesFromAssemblyOf（）的
.ConventionDiscovery.Add（DefaultLazy.AlwaysTrue（））
.ConventionDiscovery.Add（）
.ConventionDiscovery.Add（）
.ConventionDiscovery.Add（）；
sessionFactory=fluntly.Configure（）
.数据库（MsSqlConfiguration.MsSql2005
.ConnectionString（c=>c.FromConnectionStringWithKey（“默认”））
.UseReflectionOptimizer（）
.Cache（c=>c.UseQueryCache（）.UseMininMapputs（）.ProviderClass（））
.ShowSql（））
.Mappings（m=>m.AutoMappings.Add（AutoMappings））
.ExposeConfiguration（设置配置）
.BuildSessionFactory（）；
}
专用void SetConfiguration（配置cfg）
{
config=cfg；
}
公共无效注册侦听器（侦听器侦听器）
{
ISession会话=线程会话；
if（session！=null&&session.IsOpen）
{
抛出新的CacheException（“一旦会话已经打开，就不能注册拦截器”）；
}
GetSession（拦截器）；
}
公共无效生成模式（）
{
新SchemaExport（config）.Execute（false，true，false，false）；
}
公共会话GetSession（）
{
返回GetSession（null）；
}
专用ISession GetSession（IInterceptor侦听器）
{
ISession会话=线程会话；
if（会话==null）
{
if（拦截器！=null）
{
session=sessionFactory.OpenSession（拦截器）；
}
其他的
{
session=sessionFactory.OpenSession（）；
}
线程会话=会话；
}
返回会议；
}
公共会话（）
{
ISession会话=线程会话；
threadSession=null；
if（session！=null&&session.IsOpen）
{
session.Close（）；
}
}
公共无效开始生效（）
{
ITransaction事务=线程事务；
if（事务==null）
{
事务=GetSession（）.BeginTransaction（）；
线程事务=事务；
}
}
公共无效委托交易（）
{
ITransaction事务=线程事务；
尝试
{
if（transaction！=null&&！transaction.WasCommitted&&！transaction.wasrollledback）
{
Commit（）；
threadTransaction=null；
}
}
捕获（休眠异常）
{
回滚事务（）；
投掷；
}
}
公共无效回滚事务（）
{
ITransaction事务=线程事务；
尝试
{
threadTransaction=null；
if（transaction！=null&&！transaction.WasCommitted&&！transaction.W
public sealed class NHibernateSessionManager
{
    private ISessionFactory sessionFactory;
    private Configuration config;

    #region Thread-safe, lazy Singleton

    public static NHibernateSessionManager Instance
    {
        get
        {
            return Nested.nHibernateSessionManager;
        }
    }

    private NHibernateSessionManager()
    {
        InitSessionFactory();
    }

    private class Nested
    {
        internal static readonly NHibernateSessionManager nHibernateSessionManager = new NHibernateSessionManager();
    }

    #endregion


    private void InitSessionFactory()
    {
        var autoMappings = AutoPersistenceModel.MapEntitiesFromAssemblyOf<DomainBase>()
            .Where(type =>
                   typeof(DomainBase).IsAssignableFrom(type) &&
                   type.IsClass &&
                   !type.IsAbstract)
            .WithSetup(s =>
                           {
                               s.IsBaseType = type =>
                                              type == typeof (DomainBase);
                           })
            .UseOverridesFromAssemblyOf<OpportunityMappingOverride>()
            .ConventionDiscovery.Add(DefaultLazy.AlwaysTrue())
            .ConventionDiscovery.Add<CascadeAllHasOneConvention>()
            .ConventionDiscovery.Add<CascadeAllHasManyConvention>()
            .ConventionDiscovery.Add<CascadeAllReferenceConvention>();

        sessionFactory = Fluently.Configure()
            .Database(MsSqlConfiguration.MsSql2005
                        .ConnectionString(c => c.FromConnectionStringWithKey("Default"))
                        .UseReflectionOptimizer()
                        .Cache(c => c.UseQueryCache().UseMininmalPuts().ProviderClass<SysCacheProvider>())
                        .ShowSql())
            .Mappings(m => m.AutoMappings.Add(autoMappings))
            .ExposeConfiguration(SetConfiguration)
            .BuildSessionFactory();
    }

    private void SetConfiguration(Configuration cfg)
    {
        config = cfg;
    }

    public void RegisterInterceptor(IInterceptor interceptor)
    {
        ISession session = threadSession;

        if (session != null && session.IsOpen)
        {
            throw new CacheException("You cannot register an interceptor once a Session has already been opened");
        }

        GetSession(interceptor);
    }

    public void GenerateSchema()
    {
        new SchemaExport(config).Execute(false, true, false, false);
    }

    public ISession GetSession()
    {
        return GetSession(null);
    }

    private ISession GetSession(IInterceptor interceptor)
    {
        ISession session = threadSession;

        if (session == null)
        {
            if (interceptor != null)
            {
                session = sessionFactory.OpenSession(interceptor);
            }
            else
            {
                session = sessionFactory.OpenSession();
            }

            threadSession = session;
        }

        return session;
    }

    public void CloseSession()
    {
        ISession session = threadSession;
        threadSession = null;

        if (session != null && session.IsOpen)
        {
            session.Close();
        }
    }

    public void BeginTransaction()
    {
        ITransaction transaction = threadTransaction;

        if (transaction == null)
        {
            transaction = GetSession().BeginTransaction();
            threadTransaction = transaction;
        }
    }

    public void CommitTransaction()
    {
        ITransaction transaction = threadTransaction;

        try
        {
            if (transaction != null && !transaction.WasCommitted && !transaction.WasRolledBack)
            {
                transaction.Commit();
                threadTransaction = null;
            }
        }
        catch (HibernateException)
        {
            RollbackTransaction();
            throw;
        }
    }

    public void RollbackTransaction()
    {
        ITransaction transaction = threadTransaction;

        try
        {
            threadTransaction = null;

            if (transaction != null && !transaction.WasCommitted && !transaction.WasRolledBack)
            {
                transaction.Rollback();
            }
        }
        finally
        {
            CloseSession();
        }
    }

    private static ITransaction threadTransaction
    {
        get
        {
            return (ITransaction)CallContext.GetData("THREAD_TRANSACTION");
        }
        set
        {
            CallContext.SetData("THREAD_TRANSACTION", value);
        }
    }

    private static ISession threadSession
    {
        get
        {
            return (ISession)CallContext.GetData("THREAD_SESSION");
        }
        set
        {
            CallContext.SetData("THREAD_SESSION", value);
        }
    }
}

    private static ITransaction threadTransaction
    {
        get
        {
            try
            {
                return (ITransaction)System.Web.HttpContext.Current.Items["THREAD_TRANSACTION"];
            }
            catch
            {
                return (ITransaction)CallContext.GetData("THREAD_TRANSACTION");
            }
        }
        set
        {
            try
            {
                System.Web.HttpContext.Current.Items["THREAD_TRANSACTION"] = value;
            }
            catch
            {
                CallContext.SetData("THREAD_TRANSACTION", value);
            }
        }
    }

    private static ISession threadSession
    {
        get
        {
            try
            {
                return (ISession)System.Web.HttpContext.Current.Items["THREAD_SESSION"];
            }
            catch
            {
                return (ISession)CallContext.GetData("THREAD_SESSION");
            }
        }
        set
        {
            try
            {
                System.Web.HttpContext.Current.Items["THREAD_SESSION"] = value;
            }
            catch
            {
                CallContext.SetData("THREAD_SESSION", value);
            }
        }
    }