仓储模式+工作单元的问题

[Millor]

初来砸到，不懂得怎么做才合理：
模型：

    public class UserLogin : IAggregateRoot
    {
        /// <summary>
        /// 用户编号
        /// </summary>
        public virtual int Id { get; set; }
        /// <summary>
        /// 电邮
        /// </summary>
        public virtual string Email { get; set; }
        /// <summary>
        /// 密码
        /// </summary>
        public virtual string PassWord { get; set; }
        /// <summary>
        /// 注册时间，可为空
        /// </summary>
        public virtual System.Nullable<DateTime> RegisterTime { get; set; }
        /// <summary>
        /// 最后登录时间，可为空
        /// </summary>
        public virtual System.Nullable<DateTime> LastLoginTime { get; set; }
        /// <summary>
        /// 是否在线
        /// </summary>
        public virtual bool IsOnline { get; set; }
        /// <summary>
        /// 限制登录
        /// </summary>
        public virtual bool IsLimit { get; set; }
        /// <summary>
        /// 用户信息
        /// </summary>
        public virtual UserInfo Info { get; set; }
    }

仓储抽象类：

    /// <summary>
    /// Repository基础抽象类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TEntityKey"></typeparam>
    public abstract class Repository<T, TEntityKey> where T : IAggregateRoot
    {
        private IUnitOfWork uow;

        protected Repository(IUnitOfWork uow)
        {
            this.uow = uow;
        }
        /// <summary>
        /// 实体添加
        /// </summary>
        /// <param name="entity">entity</param>
        public void Add(T entity)
        {
            SessionFactory.GetCurrentSession().Save(entity);
        }
        /// <summary>
        /// 实体删除
        /// </summary>
        /// <param name="entity">实体</param>
        public void Remove(T entity)
        {
            SessionFactory.GetCurrentSession().Delete(entity);
        }
        /// <summary>
        /// 实体更新
        /// </summary>
        /// <param name="entity">实体</param>
        public void Save(T entity)
        {
            SessionFactory.GetCurrentSession().SaveOrUpdate(entity);
        }
    }

实现仓储基类：

   
    public class UserLoginRepository : Repository<UserLogin, int>, IUserLoginRepository
    {
        public UserLoginRepository(IUnitOfWork uow)
            : base(uow)
        {
        }

一个工作单元接口：

public interface IUnitOfWork: IDisposable
    {
        /// <summary>
        /// 实体修改
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="unitofWorkRepository">操作仓储</param>
        void RegisterAmended(IAggregateRoot entity,
                             IUnitOfWorkRepository unitofWorkRepository);
        
        /// <summary>
        /// 实体添加
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="unitofWorkRepository">操作仓储</param>
        void RegisterNew(IAggregateRoot entity,
                         IUnitOfWorkRepository unitofWorkRepository);
        
        /// <summary>
        /// 实体删除
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="unitofWorkRepository">操作仓储</param>
        void RegisterRemoved(IAggregateRoot entity,
                             IUnitOfWorkRepository unitofWorkRepository);
        
        /// <summary>
        /// 提交
        /// </summary>
        void Commit();
        
        /// <summary>
        /// 回滚
        /// </summary>
        void Rollback();
    }

业务基类接口：

    /// <summary>
    /// 业务基接口
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IBaseService<T> where T : class ,IAggregateRoot, new()
    {
        /// <summary>
        /// 保存对象
        /// </summary>
        /// <param name="entity">对象</param>
        void Save(T entity);
        /// <summary>
        /// 添加对象
        /// </summary>
        /// <param name="entity">对象</param>
        void Add(T entity);
        /// <summary>
        /// 删除对象
        /// </summary>
        /// <param name="entity">对象</param>
        void Remove(T entity);
    }

实现业务基类接口：

    /// <summary>
    /// 业务基类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class BaseServices<T,Tid>:IBaseService<T> where T : class,IAggregateRoot, new()
    {
        //当前仓储
        public IBaseRepository<T, Tid> _currentRepository;
        //工作单元
        private IUnitOfWork _unitWork;
        public BaseServices(IUnitOfWork unitWork,IBaseRepository<T,Tid> currentRepository) {
            _unitWork = unitWork;
            _currentRepository = currentRepository;
        }
        public void Save(T entity)
        {
            _currentRepository.Save(entity);
            _unitWork.Commit();
        }

        public void Add(T entity)
        {
            _currentRepository.Add(entity);
            _unitWork.Commit();
        }

        public void Remove(T entity)
        {
            _currentRepository.Remove(entity);
            _unitWork.Commit();
        }
    }

业务实现：

    public class LoginService:BaseServices<UserLogin,int>,ILoginService
    {
        private IUserLoginRepository _userLogin;
        public LoginService(IUnitOfWork unitWork, IUserLoginRepository userLogin)
            : base(unitWork, userLogin)
        {
            _userLogin = userLogin;
        }

        public bool IsOnline(string email)
        {
            return _userLogin.IsOnline(email);
        }
        public UserLogin CheckUser(string email, string passWord)
        {
            return _userLogin.CheckUser(email, passWord);
        }
        public void UpdateOnline(string email,bool isOnline=false)
        {
            _userLogin.UpdateOnline(email, isOnline);
        }
    }

问题是：
public void Add(T entity)
{
_currentRepository.Add(entity);
_unitWork.Commit();
}

public void Remove(T entity)
{
_currentRepository.Remove(entity);
_unitWork.Commit();
}....，这个commit(),要这样吗？ 那不是操作一个更新一个？
还有我这么做是不是正确？哪里需要改正？各位看官，指点指点。

[moonwrite]

nopCommerce 看这个开源项目 另外google一下：Repository 模式 如果是使用EF的话，看看EF的Find，可以减少一个Tid

[newxdlysk]

这个还是得看你具体的业务吧，如果是批量操作，那可以批量完再commit _unitWork;声明为protected，这样子类可以适时调用commit