关于NHibernate会话管理器

您好，我是nhibernate的新手，我正在尝试为一个web应用程序创建一个会话管理器，它允许我在新客户端调用它时使用它。我找到了一个会话管理器，这对我来说很好，但我不知道如何在我的web API中运行它，因为它们只给出代码，没有实现。有人能帮我吗

using System.Web;
using NHibernate;
using NHibernate.Cache;
using NHibernate.Cfg;
using System.Runtime.Remoting.Messaging;

namespace BLLEwidencjaTest
{
  public class NHibernateSessionManager
  {
    private static Configuration _configuration;
    public static NHibernateSessionManager Instance
    {
        get
        {
            return Nested.NHibernateSessionManager;
        }
    }
    private NHibernateSessionManager()
    {
        InitSessionFactory();
    }
    private class Nested
    {
        static Nested() { }
        internal static readonly NHibernateSessionManager NHibernateSessionManager =
            new NHibernateSessionManager();
    }
    private void InitSessionFactory()
    {
        _configuration = new Configuration();
        _configuration.Configure();
        _configuration.AddAssembly(typeof(NHibernateSessionManager).Assembly);
        sessionFactory = _configuration.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 void RegisterInterceptor(IInterceptor interceptor)
    {
        ISession session = ContextSession;

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

        GetSession(interceptor);
    }
    public 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>
    private ISession GetSession(IInterceptor interceptor)
    {
        ISession session = ContextSession;

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

            ContextSession = session;
        }

        //Check.Ensure(session != null, "session was null");

        return session;
    }
    /// <summary>
    /// Flushes anything left in the session and closes the connection.
    /// </summary>
    public void CloseSession()
    {
        ISession session = ContextSession;

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

        ContextSession = null;
    }
    public void BeginTransaction()
    {
        ITransaction transaction = ContextTransaction;

        if (transaction == null)
        {
            transaction = GetSession().BeginTransaction();
            ContextTransaction = transaction;
        }
    }
    public void CommitTransaction()
    {
        ITransaction transaction = ContextTransaction;

        try
        {
            if (HasOpenTransaction())
            {
                transaction.Commit();
                ContextTransaction = null;
            }
        }
        catch (HibernateException)
        {
            RollbackTransaction();
            throw;
        }
    }
    public bool HasOpenTransaction()
    {
        ITransaction transaction = ContextTransaction;

        return transaction != null && !transaction.WasCommitted && !transaction.WasRolledBack;
    }
    public void RollbackTransaction()
    {
        ITransaction transaction = ContextTransaction;

        try
        {
            if (HasOpenTransaction())
            {
                transaction.Rollback();
            }

            ContextTransaction = null;
        }
        finally
        {
            CloseSession();
        }
    }
    /// <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 ITransaction ContextTransaction
    {
        get
        {
            if (IsInWebContext())
            {
                return (ITransaction)HttpContext.Current.Items[TRANSACTION_KEY];
            }
            else
            {
                return (ITransaction)CallContext.GetData(TRANSACTION_KEY);
            }
        }
        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 ISession ContextSession
    {
        get
        {
            if (IsInWebContext())
            {
                return (ISession)HttpContext.Current.Items[SESSION_KEY];
            }
            else
            {
                return (ISession)CallContext.GetData(SESSION_KEY);
            }
        }
        set
        {
            if (IsInWebContext())
            {
                HttpContext.Current.Items[SESSION_KEY] = value;
            }
            else
            {
                CallContext.SetData(SESSION_KEY, value);
            }
        }
    }
    private bool IsInWebContext()
    {
        return HttpContext.Current != null;
    }

    private const string TRANSACTION_KEY = "CONTEXT_TRANSACTION";
    private const string SESSION_KEY = "CONTEXT_SESSION";
    private ISessionFactory sessionFactory;
  }
}

使用System.Web；
使用NHibernate；
使用NHibernate.Cache；
使用NHibernate.Cfg；
使用System.Runtime.Remoting.Messaging；
名称空间BLLEwidencjaTest
{
公共类NHibernateSessionManager
{
私有静态配置_配置；
公共静态NHibernateSessionManager实例
{
得到
{
返回Nested.NHibernateSessionManager；
}
}
私人NHibernateSessionManager（）
{
InitSessionFactory（）；
}
私有类嵌套
{
静态嵌套（）{}
内部静态只读NHibernateSessionManager NHibernateSessionManager=
新的NHibernateSessionManager（）；
}
私有void InitSessionFactory（）
{
_配置=新配置（）；
_Configure.Configure（）；
_AddAssembly（typeof（NHibernateSessionManager）.Assembly）；
sessionFactory=_配置。BuildSessionFactory（）；
}
/// 
///允许您在新会话上注册拦截器。如果已有拦截器，则可能不会调用该拦截器
///连接到HttpContext的打开会话。如果要使用拦截器，请修改
///在调用BeginTransaction（）之前调用此函数的HttpModule。
/// 
公共无效注册侦听器（侦听器侦听器）
{
ISession会话=上下文会话；
if（session！=null&&session.IsOpen）
{
抛出新的CacheException（“一旦会话已经打开，就不能注册拦截器”）；
}
GetSession（拦截器）；
}
公共会话GetSession（）
{
返回GetSession（null）；
}
/// 
///获取包含或不包含拦截器的会话。此方法不是直接调用的，而是，
///它从其他公共方法调用。
/// 
专用ISession GetSession（IInterceptor侦听器）
{
ISession会话=上下文会话；
if（会话==null）
{
if（拦截器！=null）
{
session=sessionFactory.OpenSession（拦截器）；
}
其他的
{
session=sessionFactory.OpenSession（）；
}
上下文会话=会话；
}
//检查。确保（会话！=null，“会话为null”）；
返回会议；
}
/// 
///刷新会话中剩余的任何内容并关闭连接。
/// 
公共会话（）
{
ISession会话=上下文会话；
if（session！=null&&session.IsOpen）
{
session.Flush（）；
session.Close（）；
}
ContextSession=null；
}
公共无效开始生效（）
{
ITransaction事务=上下文事务；
if（事务==null）
{
事务=GetSession（）.BeginTransaction（）；
上下文事务=事务；
}
}
公共无效委托交易（）
{
ITransaction事务=上下文事务；
尝试
{
if（HasOpenTransaction（））
{
Commit（）；
ContextTransaction=null；
}
}
捕获（休眠异常）
{
回滚事务（）；
投掷；
}
}
公共bool HasOpenTransaction（）
{
ITransaction事务=上下文事务；
返回事务！=null&&！transaction.WasCommitted&&！transaction.wasrollledback；
}
公共无效回滚事务（）
{
ITransaction事务=上下文事务；
尝试
{
if（HasOpenTransaction（））
{
transaction.Rollback（）；
}
ContextTransaction=null；
}
最后
{
CloseSession（）；
}
}
/// 
///如果在web上下文中，则使用而不是WinForms
///具体的。关于这一点的讨论见
/// http://forum.springframework.net/showthread.php?t=572.
/// 
私有ITransaction上下文事务
{
得到
{
if（IsInWebContext（））
{
return（ITransaction）HttpContext.Current.Items[TRANSACTION_KEY]；
}
其他的
{
return（ITransaction）CallContext.GetData（事务_键）；
}
}
设置
{
if（IsInWebContext（））
{
HttpContext.Current.Items[TRANSACTION\u KEY]=值；
}
其他的
{
SetData（事务_键，值）；
}
}
}
/// 
///如果在web上下文中，则使用而不是WinForms
///具体的。关于这一点的讨论见
/// http://forum.springframework.net/showthread.php?t=572.
/// 
私有会话上下文会话
{
得到
{
if（IsInWebContext（））
{
返回（ISession）HttpContext.Current.Items[SESSION_KEY]；
}
其他的
{
return（ISession）CallContext.GetData（SESSION_键）；
}
}
设置
{
if（IsInWebContext（））
{
HttpContext.Current.Items[SESSION\u KEY]=值；
}
其他的
{
SetData（会话_键，值）；
}
}
}
私有bool IsInWebContext（）
{
返回HttpContext.Current！=null；
}
私有常量字符串事务\u KEY=“CO