使用fluent-nhibernate进行多线程处理 私有ISessionFactory GetSessionFactory（字符串sessionFactoryConfigPath） { GetFullSessionFactoryFor（sessionFactoryConfigPath）； while（！sessionFactoryReady）线程.Sleep（1000）； 返回（ISessionFactory）会话工厂[sessionFactoryConfigPath]； } 私有void GetFullSessionFactory（字符串sessionFactoryConfigPath） { ThreadPool.QueueUserWorkItem（状态=> { ISessionFactory sessionFactory=null； FluentConfiguration FluentConfiguration=FluentConfiguration.ExposeConfiguration（c=>c.SetProperty（“sessionfactoryname”，“somevalue”）） .Mappings（m=> { m、 FluentMappings .AddFromAssembly（Assembly.Load（“Assembly的名称”）） .Conventions.Add（DefaultLazy.Always（）， OptimisticLock.Is（x=>x.All（））， DynamicUpdate.AlwaysTrue（）， DynamicInsert.AlwaysFalse（）， DefaultCascade.None（） ) .Conventions.AddFromAssemblyOf（）； } ); sessionFactory=fluentConfiguration.BuildSessionFactory（）； }); }

我在主线程上创建Ministression工厂（此处未显示），在第二个线程上创建完整会话工厂。 问题是当它点击buildsessionfactory时，代码永远不会返回。我做得对吗

private  ISessionFactory GetSessionFactory(string sessionFactoryConfigPath)

   {
        GetFullSessionFactoryFor(sessionFactoryConfigPath);
        while (!sessionFactoryReady) Thread.Sleep(1000);
        return (ISessionFactory)sessionFactories[sessionFactoryConfigPath];
 }


 private void GetFullSessionFactory(string sessionFactoryConfigPath)
    {       
   ThreadPool.QueueUserWorkItem(state =>
         {
           ISessionFactory sessionFactory=null;
           FluentConfiguration fluentConfiguration = fluentConfiguration.ExposeConfiguration(c => c.SetProperty("sessionfactoryname","somevalue"))
                                         .Mappings(m =>
                                         {
                                             m.FluentMappings
                                                 .AddFromAssembly(Assembly.Load("nameofassembly"))
                                                 .Conventions.Add(DefaultLazy.Always(),
                                                                  OptimisticLock.Is(x => x.All()),
                                                                  DynamicUpdate.AlwaysTrue(),
                                                                  DynamicInsert.AlwaysFalse(),
                                                                  DefaultCascade.None()
                                                                 )
                                                 .Conventions.AddFromAssemblyOf<"SomeConvention">();
                                         }
                                                  );

         sessionFactory = fluentConfiguration.BuildSessionFactory();

          });
}

公共类NHibernatebaseado
{
公共nhibernatebaseado（字符串sessionFactoryConfigPath，int sessionId）
{
SessionFactoryConfigPath=SessionFactoryConfigPath；
SessionId=SessionId；
公共布尔存储（T实体）
{
bool saveSuccessful=true；
尝试
{
NHibernateSession.Save（实体）；
}
捕获（NHibernate.hibernateeexception）
{
saveSuccessful=false；
}
返回成功；
}
公共布尔存储或更新（T实体）
{
bool saveSuccessful=true；
尝试
{
NHibernateSession.SaveOrUpdate（实体）；
}
捕获（NHibernate.hibernateeexception）
{
saveSuccessful=false；
}
返回成功；
}
公共作废删除（T实体）
{
删除（实体）；
}
公共无效佣金（）
{
if（NHibernateSessionManager.Instance.HasOpenTransactionOn（SessionFactoryConfigPath，this.SessionId））
{
NHibernateSessionManager.Instance.GetSessionFrom（SessionFactoryConfigPath，this.SessionId）.Flush（）；
NHibernateSessionManager.Instance.CommitTransaction（SessionFactoryConfigPath，this.SessionId）；
}
其他的
{
NHibernateSessionManager.Instance.GetSessionFrom（SessionFactoryConfigPath，this.SessionId）.Flush（）；
}
}
公共无效开始生效（）
{
NHibernateSessionManager.Instance.BeginTransaction（SessionFactoryConfigPath，this.SessionId）；
}
公共无效回滚事务（）
{
NHibernateSessionManager.Instance.RollbackTransactionOn（SessionFactoryConfigPath，this.SessionId）；
}
公共图书馆
{
返回NHibernateSession.IsDirty（）；
}
公共IQueryable查询（）{
return（IQueryable）NHibernateSession.Query（）；
}
受保护的ISession NHibernateSession
{
得到
{
返回NHibernateSessionManager.Instance.GetSessionFrom（SessionFactoryConfigPath，this.SessionId）；
}
}
受保护的只读字符串SessionFactoryConfigPath；
受保护的会话ID；
受保护的System.Data.IDbConnection数据库连接
{
获取{return NHibernateSessionManager.Instance.GetDbConnection（SessionFactoryConfigPath，this.SessionId）；}
}
/// 
///返回对象数组列表。用于常规查询
/// 
public System.Collections.IEnumerable GetSqlQuery（字符串queryString，IList条件，类型returnType）
{
queryString+=CriteriaToSql（标准）；
返回NHibernateSession.CreateQuery（queryString.Enumerable（）；
}
受保护的ICriteria标准（IList标准）
{
ICriteria-criteria=NHibernateSession.CreateCriteria（persistentType）；
foreach（标准中的标准）
{
开关（标准比较）
{
案例SqlComparison.StartsWith:
Add（Restrictions.InsensitiveLike（criterium.Property，criterium.Value1.ToString（），MatchMode.Start））；
打破
案例SqlComparison。包含：
Add（Restrictions.InsensitiveLike（criterium.Property，criterium.Value1.ToString（），MatchMode.Anywhere））；
打破
案例SqlComparison.Equals：
添加（Restrictions.Eq（criterium.Property，criterium.Value1））；
打破
案例SqlComparison.Between：
criteria.Add（Restrictions.Between（criteriam.Property，criteriam.Value1，criteriam.Value2））；
打破
案例SqlComparison.more：
添加（Restrictions.Gt（criterium.Property，criterium.Value1））；
打破
案例SqlComparison.LessThan：
添加（Restrictions.Lt（criterium.Property，criterium.Value2））；
打破
case SqlComparison.InLi
public class NHibernateBaseDAO<T>
{
    public NHibernateBaseDAO(string sessionFactoryConfigPath, int sessionId)
    {


        SessionFactoryConfigPath = sessionFactoryConfigPath;
        SessionId = sessionId;
    public bool Save(T entity)
    {
        bool saveSuccessful = true;
        try
        {
            NHibernateSession.Save(entity);
        }
        catch (NHibernate.HibernateException)
        {
            saveSuccessful = false;
        }
        return saveSuccessful;
    }

    public bool SaveOrUpdate(T entity)
    {
        bool saveSuccessful = true;
        try
        {
            NHibernateSession.SaveOrUpdate(entity);
        }
        catch (NHibernate.HibernateException)
        {
            saveSuccessful = false;
        }
        return saveSuccessful;
    }

    public void Delete(T entity)
    {
        NHibernateSession.Delete(entity);

    }

    public void CommitChanges()
    {
        if (NHibernateSessionManager.Instance.HasOpenTransactionOn(SessionFactoryConfigPath, this.SessionId))
        {
            NHibernateSessionManager.Instance.GetSessionFrom(SessionFactoryConfigPath, this.SessionId).Flush();
            NHibernateSessionManager.Instance.CommitTransactionOn(SessionFactoryConfigPath, this.SessionId);
        }
        else
        {
            NHibernateSessionManager.Instance.GetSessionFrom(SessionFactoryConfigPath, this.SessionId).Flush();
        }
    }

    public void BeginTransaction()
    {
        NHibernateSessionManager.Instance.BeginTransactionOn(SessionFactoryConfigPath, this.SessionId);
    }

    public void RollbackTransaction()
    {
        NHibernateSessionManager.Instance.RollbackTransactionOn(SessionFactoryConfigPath, this.SessionId);
    }

    public bool IsDirty()
    {
        return NHibernateSession.IsDirty();
    }

    public IQueryable<T> Query() {
        return (IQueryable<T>)NHibernateSession.Query<T>(); 

    }
    protected ISession NHibernateSession
    {
        get
        {
            return NHibernateSessionManager.Instance.GetSessionFrom(SessionFactoryConfigPath, this.SessionId);
        }
    }


    protected readonly string SessionFactoryConfigPath;
    protected int SessionId;

    protected System.Data.IDbConnection DbConnection
    {
        get { return NHibernateSessionManager.Instance.GetDbConnection(SessionFactoryConfigPath, this.SessionId); }
    }

    /// <summary>
    /// Return a list of object arrays. use this for general queries
    /// </summary>
    public System.Collections.IEnumerable GetSqlQuery(string queryString, IList<Criterion> criterion, Type returnType)
    {
        queryString += CriteriaToSql(criterion);

        return NHibernateSession.CreateQuery(queryString).Enumerable();
    }

    protected ICriteria AddCriteria(IList<Criterion> criterion)
    {
        ICriteria criteria = NHibernateSession.CreateCriteria(persistentType);

        foreach (Criterion criterium in criterion)
        {
            switch (criterium.Comparison)
            {
                case SqlComparison.StartsWith:
                    criteria.Add(Restrictions.InsensitiveLike(criterium.Property, criterium.Value1.ToString(), MatchMode.Start));
                    break;

                case SqlComparison.Contains:
                    criteria.Add(Restrictions.InsensitiveLike(criterium.Property, criterium.Value1.ToString(), MatchMode.Anywhere));
                    break;

                case SqlComparison.Equals:
                    criteria.Add(Restrictions.Eq(criterium.Property, criterium.Value1));
                    break;

                case SqlComparison.Between:
                    criteria.Add(Restrictions.Between(criterium.Property, criterium.Value1, criterium.Value2));
                    break;
                case SqlComparison.MoreThan:
                    criteria.Add(Restrictions.Gt(criterium.Property, criterium.Value1));
                    break;
                case SqlComparison.LessThan:
                    criteria.Add(Restrictions.Lt(criterium.Property, criterium.Value2));
                    break;
                case SqlComparison.InList:
                    criteria.Add(Restrictions.In(criterium.Property, (System.Collections.IList)criterium.Value1));
                    break;

            }
        }
        return criteria;
    }
    protected string CriteriaToSql(IList<Criterion> criterion)
    {

    }
    /// <summary>
    /// Get delimiter for data, defaults to ' unless specifed for data type
    /// </summary>
    protected string[] GetDelimiter(object value)
    {

}
public class Criterion
{
    public Criterion(string property, SqlComparison comparison, object value1)
    {
        Property = property;
        Comparison = comparison;
        Value1 = value1;
    }
    public Criterion(string property, SqlComparison comparison, object value1, object value2)
    {
        Property = property;
        Comparison = comparison;
        Value1 = value1;
        Value2 = value2;
    }
    public Criterion(string property, SqlComparison comparison, object value1, bool not)
    {
        Property = property;
        Comparison = comparison;
        Value1 = value1;
        Not = not;
    }
    public Criterion(string property, SqlComparison comparison, object value1, object value2, bool not)
    {
        Property = property;
        Comparison = comparison;
        Value1 = value1;
        Value2 = value2;
        Not = not;
    }
    public string Property { get; set; }
    public bool Not { get; set; }
    public SqlComparison Comparison { get; set; }
    public object Value1 { get; set; }
    public object Value2 { get; set; }
}
public enum SqlComparison { StartsWith, Contains, Equals, Between, MoreThan, LessThan,   InList }
 }

void Main()
{
    Database.InitRealFactoryAsync("<sessionFactoryConfigPath>");

    var minifactory = Database.GetMiniFactory("<sessionFactoryConfigPath>");

    // Do some stuff with minifactory

    var realsessionfactory = Database.SessionFactory;

    // Do stuff with real factory
}

static class Database
{
    private static ISessionFactory sessionFactory;

    public void InitRealFactoryAsync(string sessionFactoryConfigPath)
    {
        ThreadPool.QueueUserWorkItem(state =>
        {
            sessionFactory = Fluently.Configure()
                .Mappings(m => m.FluentMappings.AddFromAssembly(Assembly.Load("nameofassembly"))
                    .Conventions.Add(DefaultLazy.Always(),
                        OptimisticLock.Is(x => x.All()),
                        DynamicUpdate.AlwaysTrue(),
                        DynamicInsert.AlwaysFalse(),
                        DefaultCascade.None())
                    .Conventions.AddFromAssemblyOf<FoxproDateConvention>())
                .BuildSessionFactory();
        });
    }

    public ISessionFactory GetMiniFactory(string sessionFactoryConfigPath)
    {
        var assembly = Assembly.Load("nameofassembly");
        return Fluently.Configure()
            .Mappings(m => m.FluentMappings.Add(assembly.GetTypes().Where(Filter).ToArray())
                .Conventions.Add(DefaultLazy.Always(),
                    OptimisticLock.Is(x => x.All()),
                    DynamicUpdate.AlwaysTrue(),
                    DynamicInsert.AlwaysFalse(),
                    DefaultCascade.None())
                .Conventions.AddFromAssemblyOf<FoxproDateConvention>())
                .BuildSessionFactory();
    }

    public static ISessionFactory SessionFactory
    {
        get {
            while (sessionFactory == null) Thread.Sleep(1000);
            return sessionFactory;
        }
    }
}

void Main()
{
    Database.InitRealFactoryAsync("<sessionFactoryConfigPath>");
    Database.InitMiniFactory("<sessionFactoryConfigPath>");

    using (var session = Database.GetSession(true))
    {
        // Do some stuff where minifactory is enough
    }

    using (var session = Database.GetSession())
    {
        // Do stuff with real factory
    }
    ...
}

// class Database
public ISession GetSession()
{
    return GetSession(false);
}

public ISession GetSession(bool miniFactoryIsEnough)
{
    if (realSessionfactory != null)
        return realSessionfactory.OpenSession();
    if (miniFactoryIsEnough)
        return miniSessionfactory.OpenSession();
    else
    {
        while (realSessionFactory == null) Thread.Sleep(1000);
        return realSessionfactory.OpenSession();
    }
}

public ISession GetSession(Type persistentType)
{
    if (fullSessionfactory != null)
        return realSessionfactory.OpenSession();
    if (miniFactory.GetClassMetadata(persistentType) != null)
        return miniSessionfactory.OpenSession();
    else
    {
        // minifactory doesnt contain the type needed, wait for full factory
        while (fullSessionFactory == null) Thread.Sleep(1000);
        return fullSessionfactory.OpenSession();
    }
}

var session = NHibernateSession;
if (session.Transaction.IsActiv)
{
    session.Transaction.Commit();
}