NHibernate版本： 2.1
我正在使用看起来非常标准的HttpModule方法来实现ASP.NET + NHibernate应用程序中的每个请求会话。我正在尝试利用WebSessionContext，但它似乎没有正常工作。具体来说，对于应用程序上的第一个请求，一切都运行良好，但是其他请求会导致“会话关闭！”任何时候使用会话的异常。重置应用程序池允许另一个请求成功，然后更多“会话关闭！”。
有一些活动的部分，但我不知道如何管理上下文以缩小它...所以这就是一切！
在web.config中：
<property name="current_session_context_class">
NHibernate.Context.WebSessionContext, NHibernate
</property>
（我也尝试将它设置为'web'，结果相同。）
确认模块配置正确：
public class NHibernateSessionModule : IHttpModule
{
public void Dispose() { }
public void Init(HttpApplication context)
{
Debug.WriteLine("NHibernateSessionModule.Init()");
context.BeginRequest += context_BeginRequest;
context.EndRequest += context_EndRequest;
}
void context_BeginRequest(object sender, EventArgs e)
{
Debug.WriteLine("NHibernateSessionModule.BeginRequest()");
var session = NHibernateHelper.OpenSession();
session.BeginTransaction();
CurrentSessionContext.Bind(session);
}
void context_EndRequest(object sender, EventArgs e)
{
Debug.WriteLine("NHibernateSessionModule.EndRequest()");
var session = NHibernateHelper.GetCurrentSession();
if (session != null)
{
try
{
if (session.Transaction != null && session.Transaction.IsActive)
session.Transaction.Commit();
}
catch (Exception ex)
{
session.Transaction.Rollback();
throw new ApplicationException("Error committing database transaction", ex);
}
finally
{
session.Close();
}
}
CurrentSessionContext.Unbind(NHibernateHelper.SessionFactory);
}
}
我的小帮手：
public class NHibernateHelper
{
public static readonly ISessionFactory SessionFactory;
static NHibernateHelper()
{
try
{
Configuration cfg = new Configuration();
cfg.AddAssembly(Assembly.GetCallingAssembly());
SessionFactory = cfg.Configure().BuildSessionFactory();
}
catch (Exception ex)
{
Debug.WriteLine(ex);
throw new ApplicationException("NHibernate initialization failed", ex);
}
}
public static ISession GetCurrentSession()
{
return SessionFactory.GetCurrentSession();
}
public static ISession OpenSession()
{
return SessionFactory.OpenSession();
}
}
答案 0 :(得分：2)
NHibernate 1.2（来自NHibernate in Action）的示例显示unbind在关闭之前完成。
订购的这种变化是否有帮助？
var session = NHibernateHelper.GetCurrentSession();
CurrentSessionContext.Unbind(NHibernateHelper.SessionFactory);
...
session.Close();
答案 1 :(得分：1)
我使用以下NHibernate会话管理器。 （这最初来自CodeProject的文章，我已经修改过更强大。）Global.asax中没有初始化，只能通过web.config / hibernate.xml.cfg中的配置参数进行初始化。
using System.Runtime.Remoting.Messaging;
using System.Web;
using NHibernate;
using NHibernate.Cache;
using NHibernate.Cfg;
/// <summary>
/// Handles creation and management of sessions and transactions. It is a singleton because
/// building the initial session factory is very expensive. Inspiration for this class came
/// from Chapter 8 of Hibernate in Action by Bauer and King. Although it is a sealed singleton
/// you can use TypeMock (http://www.typemock.com) for more flexible testing.
/// </summary>
public sealed class NHibernateSessionManager
{
#region Thread-safe, lazy Singleton
/// <summary>
/// Gets an instance via a thread-safe, lazy singleton.
/// </summary>
/// <remarks>
/// See http://www.yoda.arachsys.com/csharp/singleton.html for more details about its implementation.
/// </remarks>
public static NHibernateSessionManager Instance
{
get
{
return Nested.NHibernateSessionManager;
}
}
/// <summary>
/// Prevents a default instance of the NHibernateSessionManager class from being created.
/// Initializes the NHibernate session factory upon instantiation.
/// </summary>
private NHibernateSessionManager()
{
this.InitSessionFactory();
}
/// <summary>
/// Assists with ensuring thread-safe, lazy singleton
/// </summary>
private class Nested
{
private Nested()
{
}
internal static readonly NHibernateSessionManager NHibernateSessionManager = new NHibernateSessionManager();
}
#endregion
private void InitSessionFactory()
{
this.sessionFactory = new Configuration().Configure().BuildSessionFactory();
}
/// <summary>
/// Allows you to register an interceptor on a new session. This may not be called if there is already
/// an open session attached to the HttpContext. If you have an interceptor to be used, modify
/// the HttpModule to call this before calling BeginTransaction().
/// </summary>
public static void RegisterInterceptor(IInterceptor interceptor)
{
ISession session = ContextSession;
if (session != null && session.IsOpen)
{
throw new CacheException(new System.Resources.ResourceManager(typeof(NHibernateSessionManager)).GetString("RegisterInterceptor_CacheException"));
}
GetSession(interceptor);
}
/// <summary>
/// Gets a session (without an interceptor). This method is not called directly; instead,
/// it gets invoked from other public methods.
/// </summary>
/// <returns></returns>
public static ISession GetSession()
{
return GetSession(null);
}
/// <summary>
/// Gets a session with or without an interceptor. This method is not called directly; instead,
/// it gets invoked from other public methods.
/// </summary>
/// <remarks>
/// Throws <see cref="HibernateException"/> if a reference to a session could not be retrieved.
/// </remarks>
private static ISession GetSession(IInterceptor interceptor)
{
ISession session = ContextSession;
if (session == null)
{
if (interceptor != null)
{
session = Instance.sessionFactory.OpenSession(interceptor);
}
else
{
session = Instance.sessionFactory.OpenSession();
}
ContextSession = session;
}
if (session == null)
{
throw new HibernateException("Session was null");
}
return session;
}
/// <summary>
/// Flushes anything left in the session, committing changes as long as no <see cref="NHibernate.AssertionFailure">NHibernate.AssertionFailure's</see> are thrown.
/// </summary>
/// <exception cref="System.Data.SqlClient.SqlException"></exception>
public static void FlushSession()
{
ISession session = ContextSession;
if (session != null && session.IsOpen)
{
// Due to a bug in Hibernate (see http://forum.hibernate.org/viewtopic.php?p=2293664#2293664) make sure Flush() is wrapped in a transaction
if (!HasOpenTransaction())
{
BeginTransaction();
}
try
{
session.Flush();
}
catch (NHibernate.AssertionFailure af)
{
if (af.Message == "null id in entry (don't flush the Session after an exception occurs)")
{
System.Diagnostics.Trace.TraceError("NHibernate.AssertionFailure: " + af.Message);
}
else
{
throw;
}
}
CommitTransaction();
}
ContextSession = null;
}
/// <summary>
/// Flushes anything left in the session and closes the connection.
/// </summary>
public static void CloseSession()
{
ISession session = ContextSession;
if (session != null && session.IsOpen)
{
FlushSession();
session.Close();
}
ContextSession = null;
}
/// <summary>
/// Begin an ITransaction (if one is not already active)
/// </summary>
public static void BeginTransaction()
{
ITransaction transaction = ContextTransaction;
if (transaction == null)
{
transaction = GetSession().BeginTransaction();
ContextTransaction = transaction;
}
}
/// <summary>
/// Begin an ITransaction (if one is not already active)
/// </summary>
/// <param name="isolationLevel"></param>
public static void BeginTransaction(System.Data.IsolationLevel isolationLevel)
{
ITransaction transaction = ContextTransaction;
if (transaction == null)
{
transaction = GetSession().BeginTransaction(isolationLevel);
ContextTransaction = transaction;
}
}
/// <summary>
/// Commit transaction, if a transaction is currently open. Automatic rollback if commit fails.
/// </summary>
public static void CommitTransaction()
{
ITransaction transaction = ContextTransaction;
try
{
if (HasOpenTransaction())
{
try
{
transaction.Commit();
}
catch (NHibernate.AssertionFailure af)
{
if (af.Message == "null id in entry (don't flush the Session after an exception occurs)")
{
System.Diagnostics.Trace.TraceError("NHibernate.AssertionFailure: " + af.Message);
}
else
{
throw;
}
}
ContextTransaction = null;
}
}
catch (HibernateException)
{
RollbackTransaction();
throw;
}
}
/// <summary>
/// Checks for an open <see cref="ITransaction"/>.
/// </summary>
/// <returns></returns>
public static bool HasOpenTransaction()
{
ITransaction transaction = ContextTransaction;
return transaction != null && transaction.IsActive && !transaction.WasCommitted && !transaction.WasRolledBack;
}
/// <summary>
/// Rollback transaction, closing the <see cref="ContextSession"/> if successful.
/// </summary>
public static void RollbackTransaction()
{
ITransaction transaction = ContextTransaction;
try
{
if (HasOpenTransaction())
{
transaction.Rollback();
}
ContextTransaction = null;
}
finally
{
if (ContextSession != null)
{
ContextSession.Close();
ContextSession = null;
}
}
}
/// <summary>
/// If within a web context, this uses <see cref="HttpContext" /> instead of the WinForms
/// specific <see cref="CallContext" />. Discussion concerning this found at
/// http://forum.springframework.net/showthread.php?t=572.
/// </summary>
private static ITransaction ContextTransaction
{
// this should be here, but it starts a chain of having to mark this ALL over. So we're ignoring it here.
// [System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityAction.LinkDemand, SkipVerification = true)]
get
{
if (IsInWebContext())
{
return (ITransaction)HttpContext.Current.Items[TRANSACTION_KEY];
}
else
{
return (ITransaction)CallContext.GetData(TRANSACTION_KEY);
}
}
// this should be here, but it starts a chain of having to mark this ALL over. So we're ignoring it here.
// [System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityAction.LinkDemand, SkipVerification = true)]
set
{
if (IsInWebContext())
{
HttpContext.Current.Items[TRANSACTION_KEY] = value;
}
else
{
CallContext.SetData(TRANSACTION_KEY, value);
}
}
}
/// <summary>
/// If within a web context, this uses <see cref="HttpContext" /> instead of the WinForms
/// specific <see cref="CallContext" />. Discussion concerning this found at
/// http://forum.springframework.net/showthread.php?t=572.
/// </summary>
private static ISession ContextSession
{
// [System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityAction.LinkDemand, SkipVerification = true)] // this should be here, but it starts a chain of having to mark this ALL over. So we're ignoring it here.
get
{
if (IsInWebContext())
{
return (ISession)HttpContext.Current.Items[SESSION_KEY];
}
else
{
return (ISession)CallContext.GetData(SESSION_KEY);
}
}
// [System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityAction.LinkDemand, SkipVerification = true)] // this should be here, but it starts a chain of having to mark this ALL over. So we're ignoring it here.
set
{
if (IsInWebContext())
{
HttpContext.Current.Items[SESSION_KEY] = value;
}
else
{
CallContext.SetData(SESSION_KEY, value);
}
}
}
private static bool IsInWebContext()
{
return HttpContext.Current != null;
}
private const string TRANSACTION_KEY = "CONTEXT_TRANSACTION";
private const string SESSION_KEY = "CONTEXT_SESSION";
private ISessionFactory sessionFactory;
}
答案 2 :(得分：0)
只是一个猜测，但是如果你将currentSessionContext.Unbind放在finally范围内，就在session.Close（）之后会发生什么？我不记得确切，但我相信在finally块完成后执行结束，所以如果是这样的话，会话仍然绑定到上下文，因此从不被驱逐......？