说说IUnitOfWork~我的IUnitOfWork+Repository架构-低调大师

说说IUnitOfWork~我的IUnitOfWork+Repository架构

2017-12-04 544

第一讲认识IUnitOfWork，为什么要出现IUnitOfWork接口第二讲 Linq to Sql与EntityFrameworks中的SubmtChanges()发生了什么事第三讲方法完整性与统一提交不冲突第四讲 DbContext对象的创建应该向BLL层公开第五讲我的IUnitOfWork+Repository架构

这个系统的文章在写完这篇后将拉下眉目，一共5讲的IUnitOfWork带给我们的是性能，原子化操作，等多方法的改进，下面我把我的IUnitOfWork+Repository模式大体的说一下，并代上核心代码：

底层接口UnitOfWork.Data.Core

这是一个接口规范的项目层，它由CURD操作规范和UnitOfWork规范组成

namespace UnitOfWork.Data.Core
{
    /// <summary>
    /// 工作单元
    /// 提供一个保存方法，它可以对调用层公开，为了减少连库次数
    /// </summary>
    public interface IUnitOfWork
    {
        /// <summary>
        /// 将操作提交到数据库，
        /// </summary>
        void Save();
        /// <summary>
        /// 是否不提交到数据库，这只是在具体的repository类中的SaveChanges方法里用到的
        /// 默认为false，即默认为提交到数据库
        /// </summary>
        /// <returns></returns>
        bool IsNotSubmit { get; set; }
    }

    /// <summary>
    /// 工作单元
    /// 对泛型类型的支持
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IUnitOfWork<T> : IUnitOfWork where T : class { }

}

namespace UnitOfWork.Data.Core
{
    public interface IRepository<TEntity>
           where TEntity : class
    {
        /// <summary>
        /// 添加实体并提交到数据服务器
        /// </summary>
        /// <param name="item">Item to add to repository</param>
        void Insert(TEntity item);

        /// <summary>
        /// 移除实体并提交到数据服务器
        /// 如果表存在约束，需要先删除子表信息
        /// </summary>
        /// <param name="item">Item to delete</param>
        void Delete(TEntity item);

        /// <summary>
        /// 修改实体并提交到数据服务器
        /// </summary>
        /// <param name="item"></param>
        void Update(TEntity item);

        /// <summary>
        /// Get all elements of type {T} in repository
        /// </summary>
        /// <returns>List of selected elements</returns>
        IQueryable<TEntity> GetModel();

        /// <summary>
        /// 根据主键得到实体
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        TEntity Find(params object[] id);
    }
}

namespace UnitOfWork.Data.Core
{
    /// <summary>
    /// 扩展的Repository操作规范
    /// </summary>
    public interface IExtensionRepository<TEntity> where TEntity : class
    {
        /// <summary>
        /// 添加集合
        /// </summary>
        /// <param name="item"></param>
        void Insert(IEnumerable<TEntity> item);

        /// <summary>
        /// 修改集合
        /// </summary>
        /// <param name="item"></param>
        void Update(IEnumerable<TEntity> item);

        /// <summary>
        /// 删除集合
        /// </summary>
        /// <param name="item"></param>
        void Delete(IEnumerable<TEntity> item);

        /// <summary>
        /// 扩展更新方法，只对EF支持
        /// </summary>
        /// <param name="entity"></param>
        void Update(System.Linq.Expressions.Expression<Action<TEntity>> entity);
    }
}

namespace UnitOfWork.Data.Core
{
    /// <summary>
    /// 完整的数据操作接口
    /// </summary>
    public interface ICompleteRepository<T> :
        IRepository<T>,
        IExtensionRepository<T>
         where T : class
    {
    }
}

而在DATA层需要去实现这些接口，我们以EF为例，去实现这样接口：

namespace EntityFrameworks.Data.Core
{
    using UnitOfWork.Data.Core;
    using System.Data.Entity.Infrastructure;

    public class DbContextRepository<TEntity> :
        ICompleteRepository<TEntity> where TEntity : class
    {
        protected DbContext _db { get; private set; }
        IUnitOfWork iUnitWork;
        public DbContextRepository(IUnitOfWork db)
        {
            iUnitWork = db;
            _db = (DbContext)db;
        }

        #region IRepository<T> 成员

        public virtual void Insert(TEntity item)
        {
            _db.Entry<TEntity>(item);
            _db.Set<TEntity>().Add(item);
            this.SaveChanges();
        }

        public virtual void Delete(TEntity item)
        {
            _db.Set<TEntity>().Attach(item);
            _db.Set<TEntity>().Remove(item);
            this.SaveChanges();
        }

        public virtual void Update(TEntity item)
        {
            _db.Set<TEntity>().Attach(item);
            _db.Entry(item).State = EntityState.Modified;
            this.SaveChanges();
        }

        public void Update(Expression<Action<TEntity>> entity)
        {

            TEntity newEntity = typeof(TEntity).GetConstructor(Type.EmptyTypes).Invoke(null) as TEntity;//建立指定类型的实例
            List<string> propertyNameList = new List<string>();
            MemberInitExpression param = entity.Body as MemberInitExpression;
            foreach (var item in param.Bindings)
            {
                string propertyName = item.Member.Name;
                object propertyValue;
                var memberAssignment = item as MemberAssignment;
                if (memberAssignment.Expression.NodeType == ExpressionType.Constant)
                {
                    propertyValue = (memberAssignment.Expression as ConstantExpression).Value;
                }
                else
                {
                    propertyValue = Expression.Lambda(memberAssignment.Expression, null).Compile().DynamicInvoke();
                }
                typeof(TEntity).GetProperty(propertyName).SetValue(newEntity, propertyValue, null);
                propertyNameList.Add(propertyName);
            }
            _db.Set<TEntity>().Attach(newEntity);
            _db.Configuration.ValidateOnSaveEnabled = false;
            var ObjectStateEntry = ((IObjectContextAdapter)_db).ObjectContext.ObjectStateManager.GetObjectStateEntry(newEntity);
            propertyNameList.ForEach(x => ObjectStateEntry.SetModifiedProperty(x.Trim()));
            this.SaveChanges();
            //  ((IObjectContextAdapter)_db).ObjectContext.Detach(newEntity);
        }

        public IQueryable<TEntity> GetModel()
        {
            //  return _db.Set<TEntity>().AsNoTracking();
            return _db.Set<TEntity>();
        }

        #endregion

        #region IExtensionRepository<T> 成员

        public virtual void Insert(IEnumerable<TEntity> item)
        {
            item.ToList().ForEach(i =>
            {
                this.Insert(i);//不提交
            });
        }

        public virtual void Delete(IEnumerable<TEntity> item)
        {
            item.ToList().ForEach(i =>
            {
                this.Delete(i);
            });
        }

        public virtual void Update(IEnumerable<TEntity> item)
        {
            item.ToList().ForEach(i =>
            {
                this.Update(i);
            });
        }

        public TEntity Find(params object[] id)
        {
            return _db.Set<TEntity>().Find(id);
        }

        #endregion

        #region Protected Methods
        /// <summary>
        /// 根据工作单元的IsNotSubmit的属性，去判断是否提交到数据库
        /// 一般地，在多个repository类型进行组合时，这个IsNotSubmit都会设为true，即不马上提交，
        /// 而对于单个repository操作来说，它的值不需要设置，使用默认的false，将直接提交到数据库，这也保证了操作的原子性。
        /// </summary>
        protected void SaveChanges()
        {
            if (!iUnitWork.IsNotSubmit)
                iUnitWork.Save();
        }

        /// <summary>
        ///  计数更新,与SaveChange()是两个SQL链接，走分布式事务
        ///  子类可以根据自己的逻辑，去复写
        ///  tableName:表名
        ///  param:索引0为主键名，1表主键值，2为要计数的字段，3为增量
        /// </summary>
        /// <param name="tableName">表名</param>
        /// <param name="param">参数列表，索引0为主键名，1表主键值，2为要计数的字段，3为增量</param>
        protected virtual void UpdateForCount(string tableName, params object[] param)
        {
            string sql = "update [" + tableName + "] set [{2}]=ISNULL([{2}],0)+{3} where [{0}]={1}";
            List<object> listParasm = new List<object>
            {
                param[0],
                param[1],
                param[2],
                param[3],
            };
            _db.Database.ExecuteSqlCommand(string.Format(sql, listParasm.ToArray()));
        }
        #endregion

    }
}

在Entity实体模型层，需要去继承IUnitOfWork这个接口，并去实现它：

 public partial class backgroundEntities : IUnitOfWork
    {
        #region IUnitOfWork 成员

        public void Save()
        {
            this.SaveChanges();
        }

        public bool IsNotSubmit
        {
            get;
            set;
        }

        #endregion

    }

最后在BLL层来完成业务的组成及基础操作的实现

namespace BLL
{
    public abstract class BLLBase
    {
        protected IUnitOfWork IUnitOfWork { get; private set; }
        public BLLBase()
            : this(null)
        {

        }
        public BLLBase(IUnitOfWork iUnitOfWork)
        {
            IUnitOfWork = iUnitOfWork;
        }
        protected ICompleteRepository<T> LoadRepository<T>() where T : class
        {
            return IUnitOfWork == null ? new TestBase<T>() : new TestBase<T>(IUnitOfWork);
        }
    }
}

在BLL层具体业务实现中，去继承BLLBase，并将数据上下文以参数的形式传递过去：

 public class OrderManager : BLLBase
    {
        public OrderManager()
            : base(new TestDataContext())
        {

        }
        public void GeneratorOrder(Order_Info order)
        {
            GeneratorOrder(order, null);
        }
        public void GeneratorOrder(Order_Info order, Product product)
        {

            #region BLLBase中直接调用公用方法
            IUnitOfWork.IsNotSubmit = true;
            new OrderRepository(IUnitOfWork).Insert(order);//DAL层具体的Repository实现类
            if (product != null)
                LoadRepository<Product>().Insert(product);//BLLBase提供的单纯CURD操作
            IUnitOfWork.SaveChanges();
            #endregion
        }
}

在WEB层直接调用BLL的具体业务即可！

到此，我们的UnitOfWork系列就讲完了，各位，晚安了！

本文转自博客园张占岭（仓储大叔）的博客，原文链接：说说IUnitOfWork~我的IUnitOfWork+Repository架构，如需转载请自行联系原博主。

微信关注我们

原文链接：https://yq.aliyun.com/articles/336137

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

EF架构~linq to entity的随机排序问题

对于从linq to sql迁移过来的开发者，对随机排序不会感到陌生，直接为datacontext添加一个方法再配合反射就可以实现随机排序了，代码如下： /// <summary> /// 数据上下文扩展 /// </summary> public partial class dbDataContext : IUnitOfWork { /// <summary> /// 随机排序时使用这个函数 /// </summary> /// <returns></returns> [Function(Name = "NewID", IsComposable = true)] public Guid NewID() { return ((Guid)(this.ExecuteMethodCall(this, ((MethodInfo)(MethodInfo.GetCurrentMethod()))).ReturnValue)); } } 而对于linq to entity的开发者们就不能使用上面的方法了，因为dbcontext没...

2017-12-05

674

将不确定变为确定~感谢异或，是你让我彻底摆脱“否定式”

在这里，我需要感谢一下“异或”运算符，真的，谢谢你，^（xor），如果没有它，也许我架构里总是离不开否定式，如果你看不懂我说的，那让先看看这篇文章，事实上那篇文章没有解决根本的否定式问题，题目也只是对DefaultValue的一个学习，这篇文章，我认为终于把“否定式“解决了，真的解决了！这是我的架构代码，否定式的出现是为了让程序员少写代码 public interface IUnitOfWork { /// <summary> /// 将操作提交到数据库， /// </summary> void Save(); /// <summary> /// 是否不提交到数据库，这只是在具体的repository类中的SaveChanges方法里用到的 /// 默认应该设置为false，即默认为提交到数据库 /// </summary> /// <returns></returns> bool IsNotSubmit { get; set; } } 当你的数据上下文实现IUnitOfWork接口后，不需要为IsNotSubm...

2017-12-05

520

发表评论

资源下载

更多资源

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。