使用Fluent-Nhibernate的存储库模式

大家好，我已经用fluentNHibernate成功实现了存储库模式，但是我有一个问题，那就是当我删除它时，ExposeConfiguration所有方法都可以正常工作，但是当我添加它时，它会重置数据库中的表。所以我需要你们看一下，给我一些关于实现的笔记，这是我的工作单元课

 public class UnitOfWork 
{

    public static ISession  NhibernateHelper()
    {
        ISessionFactory _sessionFactory = Fluently.Configure()
            .Database(MsSqlConfiguration.MsSql2012.ConnectionString(@"Data Source=WAAIL-PC\COMPUTERENGINEER;Initial Catalog=TSQL2012;User ID=sa;Password=12345678Ce").ShowSql())
            .Mappings(x => x.FluentMappings.AddFromAssemblyOf<UsersMap>())
           //.ExposeConfiguration(cfg => new SchemaExport(cfg).Create(false, true)) //when i removed this line it doesn't
          //remove the elements from the db
            .BuildSessionFactory();

       return _sessionFactory.OpenSession();

    }}

公共类UnitOfWork
{
公共静态ISession NhibernateHelper（）
{
ISessionFactory\u sessionFactory=fluntly.Configure（）
.Database（MsSqlConfiguration.MsSql2012.ConnectionString（@“数据源=WAAIL-PC\COMPUTERENGINEER；初始目录=TSQL2012；用户ID=sa；密码=12345678Ce”）.ShowSql（）
.Mappings（x=>x.FluentMappings.AddFromAssemblyOf（））
//.ExposeConfiguration（cfg=>newschemaexport（cfg）.Create（false，true））//当我删除这一行时，它不会
//从数据库中删除元素
.BuildSessionFactory（）；
返回_sessionFactory.OpenSession（）；
}}

下面是我的存储库模式：

public class Repository<T> :IRepository<T> where T :BaseEntity
{

    public Repository(/*IUnitOfWork unitOfWork*/)
    {
        //_unitOfWork = (UnitOfWork)unitOfWork;
    }

    public List<T> GetAll()
    {
        using (ISession Session = UnitOfWork.NhibernateHelper())
        {
            return Session.Query<T>().ToList();
        }
    }

    public T GetById(int id)
    {
        using (ISession Session = UnitOfWork.NhibernateHelper())
        {
            return Session.Get<T>(id);
        }
    }

    public T Insert(T entity)
    {
        try
        {
            using (ISession Session = UnitOfWork.NhibernateHelper())
            {
                using (ITransaction Transaction = Session.BeginTransaction())
                {
                    Session.Save(entity);
                    Transaction.Commit();
                }
            }
            return entity;
        }
        catch (Exception)
        {

            throw;
        }
    }

    public void Update(T entity)
    {
        using (ISession Session = UnitOfWork.NhibernateHelper())
        {
            using (ITransaction Transaction = Session.BeginTransaction())
            {
                Session.Update(entity);
                Transaction.Commit();
            }
        }
    }

    public void Delete(int id)
    {
        using (ISession Session = UnitOfWork.NhibernateHelper())
        {
            using (ITransaction Transaction = Session.BeginTransaction())
            {
                Session.Delete(Session.Load<T>(id));
                Transaction.Commit();
            }
        }
    }
}

公共类存储库：IRepository其中T:BaseEntity
{
公共存储库（/*IUnitOfWork unitOfWork*/）
{
//_unitOfWork=（unitOfWork）unitOfWork；
}
公共列表GetAll（）
{
使用（ISession Session=UnitOfWork.NhibernateHelper（））
{
返回Session.Query（）.ToList（）；
}
}
公共T GetById（int-id）
{
使用（ISession Session=UnitOfWork.NhibernateHelper（））
{
返回会话.Get（id）；
}
}
公共T插入（T实体）
{
尝试
{
使用（ISession Session=UnitOfWork.NhibernateHelper（））
{
使用（ITransaction Transaction=Session.BeginTransaction（））
{
Session.Save（实体）；
Commit（）；
}
}
返回实体；
}
捕获（例外）
{
投掷；
}
}
公共无效更新（T实体）
{
使用（ISession Session=UnitOfWork.NhibernateHelper（））
{
使用（ITransaction Transaction=Session.BeginTransaction（））
{
更新（实体）；
Commit（）；
}
}
}
公共无效删除（int-id）
{
使用（ISession Session=UnitOfWork.NhibernateHelper（））
{
使用（ITransaction Transaction=Session.BeginTransaction（））
{
Session.Delete（Session.Load（id））；
Commit（）；
}
}
}
}

这是我的用户服务

public class UsersService : IUsersService
{
    private readonly IRepository<Users> _Repository;

    #region Constructor
    public UsersService(IRepository<Users> Repository)
    {
        _Repository = Repository;
    }
    #endregion

    #region Service Implementation

    public List<Users> GetListAll()
    {
        return _Repository.GetAll().ToList();
    }

    public Users GetById(int Id)
    {
        return _Repository.GetById(Id);
    }

    public Users Insert(Users user)
    {
        return _Repository.Insert(user);
    }

    public void Update(Users user)
    {
        _Repository.Update(user);
    }
    public void Delete(int Id)
    {
        _Repository.Delete(Id);
    }

    //public int execute()
    //{
    //    return _Repository.execute();
    //}


}

公共类用户服务：IUsersService
{
专用只读IRepository存储库；
#区域构造函数
公共用户服务（IRepository存储库）
{
_存储库=存储库；
}
#端区
#区域服务实现
公共列表GetListAll（）
{
返回_Repository.GetAll（）.ToList（）；
}
公共用户GetById（int-Id）
{
return _Repository.GetById（Id）；
}
公共用户插入（用户）
{
返回_Repository.Insert（用户）；
}
公共无效更新（用户）
{
_更新（用户）；
}
公共无效删除（int-Id）
{
_删除（Id）；
}
//公共int执行（）
//{
//返回_Repository.execute（）；
//}
}

所以我需要知道的是为什么Expose_配置方法会导致表重置。。。第二，我在实施过程中是否采取了正确的方式。 如果你们有任何改进，请告诉我。。 致以最良好的祝愿。

邪恶在于细节 你写道：

。。。ExposeConfiguration当我删除它时，所有方法都可以正常工作，但当我添加它时，它会重置数据库中的表

这是非常正常的操作方式，因为如果我们查找NHiberate的

SchemaExport

classes方法签名，它会显示：

public void Create(Action<string> scriptAction, bool execute)

您的问题在于，您将

true

传递给

execute

参数，如文档中所述，该参数将执行模式创建脚本，其中可能包括删除和重新描述现有数据库对象

为什么要制造恶魔？ 关于你的第二个想法，我真的认为在你的代码中添加另一个间接层没有任何好处，那就是你召唤不需要的恶魔的地方

NHibernate ORM本身就是一个抽象，为什么还要在它周围添加一个更通用的呢？您的

存储库

只需调用已经实现的通用NHibernate方法。。。有点像是在隐藏NHibernate，如果是故意的，请原谅，但看起来不是

最后一点注意：您的

users服务

类首先违反了，并通过维护和测试它使您的生活更加困难。其次，这个类也只是一个用来调用存储库以从中返回值的代理

让我举例说明这个问题：

客户端调用

UsersService.GetById（Id）

服务调用

\u Repository.GetById（Id）

您的通用抽象存储库调用NHibernates

Session.Get（id）

你看到问题了吗

在这种情况下，说使用一种可能对您有所帮助的模式是多么容易，这就是

您的命令负责写操作和关于读操作的查询，这两者都适合您的用例

---

您可以阅读我前面关于和的回答。

那么您的意思是，只要我们实现fluentNHibernate，那么存储库模式就没有必要了？对吗？对，如果没有任何东西强迫您拥有额外的抽象层，那么就是这样，是的！

.ExposeConfiguration(cfg => new SchemaExport(cfg).Create(false, true))