NHibernate下持久化类的两种设计，哪种更好一些？

刚才看到Aero老兄写的《NHibernate学习手记(4) - 持久化类(Persistent class)的设计》的文章，谈到了NHibernate下持久化类的设计时关于关于对象的操作和数据是否应该剥离的问题，想到了我经常看到的两种不同的设计，虽然现在已经没时间再去研究NHibernate了，但还是把这两种实现方法贴出来，大家可以讨论一下。

一．剥离对象的操作和数据

1．实体类

public class User
{    
    private string id;

    private string userName;

    private string password;

    private string emailAddress;

    private DateTime lastLogon;

    public string Id 
    {
        get { return id; }
        set { id = value; }
    }

    public string UserName 
    {
        get { return userName; }
        set { userName = value; }
    }

    public string Password 
    {
        get { return password; }
        set { password = value; }
    }

    public string EmailAddress 
    {
        get { return emailAddress; }
        set { emailAddress = value; }
    }

    public DateTime LastLogon 
    {
        get { return lastLogon; }
        set { lastLogon = value; }
    }

    构造函数
}


2．对象操作

public class UserDAL
{
    private EntityControl control;

    public UserDAL()
    {
        control = EntityControl.CreateEntityControl("NHibernateWebDemo.Model");
    }
    
    //新增
    public void AddUser(User user)
    {
        control.AddEntity(user);
    }
        
    //修改
    public void UpdateUser(User user,string Id)
    {
        control.UpdateEntity(user,user.Id);
    }
        
    //删除
    public void DeleteUser(User user)
    {
        control.DeleteEntity(user);
    } 
}


3．公用的类

public class EntityControl
{
    private static EntityControl entity;
    private string _AssemblyName;
    static readonly object padlock = new object();

    public static EntityControl CreateEntityControl(string AssemblyName)
    {
        if(entity == null)
        {
            lock(padlock)
            {
                if(entity == null)
                {
                    entity = new EntityControl();
                    entity._AssemblyName = AssemblyName;
                }
            }
        }
        return entity;
    }

    public void AddEntity(Object entity)
    {
        ISession session = SessionFactory.OpenSession(_AssemblyName);
        ITransaction transaction = session.BeginTransaction();
        try
        {
            session.Save(entity);
            transaction.Commit();
        }
        catch(Exception ex)
        {
            transaction.Rollback();
            throw ex;
        }
        finally
        {
            session.Close();
        }
    }
            
    public void UpdateEntity(Object entity,Object key)
    {
        ISession session = SessionFactory.OpenSession(_AssemblyName);
        ITransaction transaction = session.BeginTransaction();
        try
        {
            session.Update(entity,key);
            transaction.Commit();
        }
        catch(Exception ex)
        {
            transaction.Rollback();
            throw ex;
        }
        finally
        {
            session.Close();
        }
    }
        
    public void DeleteEntity(object entity)
    {
        ISession session = SessionFactory.OpenSession(_AssemblyName);
        ITransaction transaction = session.BeginTransaction();
            
        try
        {
            session.Delete(entity);
            transaction.Commit();
        }
        catch(Exception ex)
        {
            transaction.Rollback();
            throw ex;
        }
        finally
        {
            session.Close();
        }
    }

    public IList GetEntities(string strHQL)
    {
        IList lst;
        ISession session = SessionFactory.OpenSession(_AssemblyName);
        ITransaction transaction = session.BeginTransaction();

        lst=session.Find(strHQL);
        transaction.Commit();
        session.Close();
        return lst;
    }
}


public class SessionFactory
{
    public SessionFactory()
    {
        
    }

    private static ISessionFactory sessions;
    private static Configuration cfg;
    static readonly object padlock = new object();
    
    public static ISession OpenSession(string AssemblyName)
    {
        if(sessions == null)
        {
            lock(padlock)
            {
                if(sessions == null)
                {
                    BuildSessionFactory(AssemblyName);
                }
            }
        }
        return sessions.OpenSession();
    }

    private static void BuildSessionFactory(string AssemblyName)
    {
        try
        {
            cfg = new Configuration();

            cfg.AddAssembly(AssemblyName);

            sessions = cfg.BuildSessionFactory();
        }
        catch(Exception ex)
        {
            throw ex;
        }
    }
}


这种方式的实现，在前面我曾经写过的一个例子中出现过，持久化类跟我们在开发三层结构系统中的业务实体是一样的。

二．对象的操作和数据在一起

1．实体类

public class Customer : BizObject 
{
    private string _customerId = string.Empty;

    private string _companyName = string.Empty;

    private string _contactName = string.Empty;

    private string _contactTitle = string.Empty;

    private string _address = string.Empty;

    private string _city = string.Empty;

    private string _region = string.Empty;

    private string _postalCode = string.Empty;

    private string _country = string.Empty;

    private string _phone = string.Empty;

    private string _fax = string.Empty;

    public string CustomerId 
    {
        get { return _customerId; }
        set { _customerId = value; }
    }
    public string CompanyName 
    {
            get { return _companyName; }
        set { _companyName = value; }
    }
    public string ContactName 
    {
        get { return _contactName; }
        set { _contactName = value; }
    }
    public string ContactTitle 
    {
        get { return _contactTitle; }
        set { _contactTitle = value; }
    }
    public string Address 
    {
        get { return _address; }
        set { _address = value; }
    }
    public string City 
    {