zoukankan      html  css  js  c++  java

  • EF学习笔记——通用增删改查方案

            EF学习笔记——通用增删改查方案             

            分类：             .NET             EF              2014-05-10 13:33     1371人阅读     评论(0)     收藏     举报    

    我刚接触EF未久，还不知道它有什么强大之处，但看上去，EF提供了一般的增删改查功能。以往用过一些ORM方法，尽管有代码生成器，但代码量总的来说比较多。这次采用EF，我就想，能不能尽量写出一些通用的方法，以后添加表、实体类，只需做很少的改动，就能拥有基本的增删改查功能呢？

    方案如下：

    1、分为几个部分：BLL、DAL、Model、Interface。其中，EF生成的代码放在Model。因为不想由BLL直接操作Model，因此还是增加一个DAL，由它来对EF的方法作进一步的封装，供BLL调用。至于接口，则是出于如下考虑：增删改查，BLL和DAL都需要实现，因此它们最好实现同一接口；最重要的，因为使用了接口，在BLL中，方便调用DAL对象。

    这几个部分分别介绍如下：

    1、接口Interface

    [csharp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
    1. public interface IEntity  
    2. {  
    3.     long _ID { get;}  
    4. }  
        public interface IEntity
    {
        long _ID { get;}
    }
    [csharp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
    1. public interface ICommon<T> where T : class,IEntity  
    2. {  
    3.     T Add(T model);  
    4.     T Update(T model);  
    5.     void Delete(T model);  
    6.     //按主键删除,keyValues是主键值  
    7.     void Delete(params object[] keyValues);  
    8.     //keyValues是主键值  
    9.     T Find(params object[] keyValues);  
    10.     List<T> FindAll();  
    11. }  
        public interface ICommon<T> where T : class,IEntity
    {
        T Add(T model);
        T Update(T model);
        void Delete(T model);
        //按主键删除,keyValues是主键值
        void Delete(params object[] keyValues);
        //keyValues是主键值
        T Find(params object[] keyValues);
        List<T> FindAll();
    }

    2、DAL

    通用的增删改查代码：

    [csharp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
    1. public abstract class BaseCommon<T> : Interface.ICommon<T> where T : class,Interface.IEntity  
    2. {  
    3.     DbContext db;  
    4.     public BaseCommon(DbContext context)  
    5.     {  
    6.         this.db = context;  
    7.     }  
    8.   
    9.     public DbContext Context  
    10.     {  
    11.         get  
    12.         {  
    13.             return db;  
    14.         }  
    15.     }  
    16.  
    17.     #region ICommon<T>  
    18.     public T Add(T model)  
    19.     {  
    20.         db.Set<T>().Add(model);  
    21.         db.SaveChanges();  
    22.         return model;  
    23.     }  
    24.     public T Update(T model)  
    25.     {  
    26.         if (db.Entry<T>(model).State == EntityState.Modified)  
    27.         {  
    28.             db.SaveChanges();  
    29.         }  
    30.         else if (db.Entry<T>(model).State == EntityState.Detached)  
    31.         {  
    32.             try  
    33.             {  
    34.                 db.Set<T>().Attach(model);  
    35.                 db.Entry<T>(model).State = EntityState.Modified;  
    36.             }  
    37.             catch (InvalidOperationException)  
    38.             {  
    39.                 T old = Find(model._ID);  
    40.                 db.Entry(old).CurrentValues.SetValues(model);  
    41.             }  
    42.             db.SaveChanges();  
    43.         }  
    44.         return model;  
    45.     }  
    46.     public void Delete(T model)  
    47.     {  
    48.         db.Set<T>().Remove(model);  
    49.         db.SaveChanges();  
    50.     }  
    51.     public void Delete(params object[] keyValues)  
    52.     {  
    53.         T model = Find(keyValues);  
    54.         if (model != null)  
    55.         {  
    56.             db.Set<T>().Remove(model);  
    57.             db.SaveChanges();  
    58.         }  
    59.     }  
    60.     public T Find(params object[] keyValues)  
    61.     {  
    62.         return db.Set<T>().Find(keyValues);  
    63.     }  
    64.     public List<T> FindAll()  
    65.     {  
    66.         return db.Set<T>().ToList();  
    67.     }  
    68.     #endregion  
    69. }  
        public abstract class BaseCommon<T> : Interface.ICommon<T> where T : class,Interface.IEntity
    {
        DbContext db;
        public BaseCommon(DbContext context)
        {
            this.db = context;
        }

        public DbContext Context
        {
            get
            {
                return db;
            }
        }

        #region ICommon<T>
        public T Add(T model)
        {
            db.Set<T>().Add(model);
            db.SaveChanges();
            return model;
        }
        public T Update(T model)
        {
            if (db.Entry<T>(model).State == EntityState.Modified)
            {
                db.SaveChanges();
            }
            else if (db.Entry<T>(model).State == EntityState.Detached)
            {
                try
                {
                    db.Set<T>().Attach(model);
                    db.Entry<T>(model).State = EntityState.Modified;
                }
                catch (InvalidOperationException)
                {
                    T old = Find(model._ID);
                    db.Entry(old).CurrentValues.SetValues(model);
                }
                db.SaveChanges();
            }
            return model;
        }
        public void Delete(T model)
        {
            db.Set<T>().Remove(model);
            db.SaveChanges();
        }
        public void Delete(params object[] keyValues)
        {
            T model = Find(keyValues);
            if (model != null)
            {
                db.Set<T>().Remove(model);
                db.SaveChanges();
            }
        }
        public T Find(params object[] keyValues)
        {
            return db.Set<T>().Find(keyValues);
        }
        public List<T> FindAll()
        {
            return db.Set<T>().ToList();
        }
        #endregion
    }
    这里面，已经封装好了一般的增删改查方法。而对应数据库每个表对象的那些类，只需继承这个BaseCommon类，即可拥有增删改查功能。如：
    [csharp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
    1. public partial class TableA : BaseCommon<Model.TableA> { }  
    public partial class TableA : BaseCommon<Model.TableA> { }
    这样，TableA对象会自然拥有增删改查功能。假如需要扩充它的功能，我们可以再写一个TableA的分部类。

    以后，新增一个表TableB，在DAL这里，一般情况下只需新增一句：

    [csharp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
    1. public partial class TableB : BaseCommon<Model.TableB> { }  
    public partial class TableB : BaseCommon<Model.TableB> { }
    是不是很方便？

    3、BLL

    BLL是供UI层，或者上一层调用的，因此，它每个对象，也应该有增删改查的基本功能。当然，BLL无须直接实现，是通过调用DAL来实现：

    [csharp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
    1. public abstract class Common<TDAL, TModel> : Interface.ICommon<TModel>  
    2.         where TDAL : class ,new()  
    3.         where TModel : class ,Interface.IEntity   
    4.     {  
    5.         protected TDAL dal;  
    6.         private Interface.ICommon<TModel> common;  
    7.   
    8.         public Common()  
    9.         {  
    10.             dal = new TDAL();  
    11.             common = (Interface.ICommon<TModel>)dal;  
    12.         }  
    13.  
    14.         #region ICommon<TModel>  
    15.         public TModel Add(TModel model)  
    16.         {  
    17.             return common.Add(model);  
    18.         }  
    19.         public TModel Update(TModel model)  
    20.         {  
    21.             return common.Update(model);  
    22.         }  
    23.         public void Delete(TModel model)  
    24.         {  
    25.             common.Delete(model);  
    26.         }  
    27.         public void Delete(params object[] keyValues)  
    28.         {  
    29.             common.Delete(keyValues);  
    30.         }  
    31.         public TModel Find(params object[] keyValues)  
    32.         {  
    33.             return common.Find(keyValues);  
    34.         }  
    35.         public List<TModel> FindAll()  
    36.         {  
    37.             return common.FindAll();  
    38.         }  
    39.         #endregion  
    40.     }  
    public abstract class Common<TDAL, TModel> : Interface.ICommon<TModel>
        where TDAL : class ,new()
        where TModel : class ,Interface.IEntity 
    {
        protected TDAL dal;
        private Interface.ICommon<TModel> common;

        public Common()
        {
            dal = new TDAL();
            common = (Interface.ICommon<TModel>)dal;
        }

        #region ICommon<TModel>
        public TModel Add(TModel model)
        {
            return common.Add(model);
        }
        public TModel Update(TModel model)
        {
            return common.Update(model);
        }
        public void Delete(TModel model)
        {
            common.Delete(model);
        }
        public void Delete(params object[] keyValues)
        {
            common.Delete(keyValues);
        }
        public TModel Find(params object[] keyValues)
        {
            return common.Find(keyValues);
        }
        public List<TModel> FindAll()
        {
            return common.FindAll();
        }
        #endregion
    }
    与DAL类似，TableA对象在这里是这样的：
    [csharp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
    1. public partial class TableA : Common<DAL.TableA, Model.TableA> { }  
    public partial class TableA : Common<DAL.TableA, Model.TableA> { }
    同理，如果以后新增了表TalbeB，在这里也只是新增一句而已。

    这里还有一个好处，就是对外界调用而言，根本不需要知道泛型，就是一个 TableA table = new TalbeA();就可以了。

    ========================================================================

    使用EF框架的增删改查和分页的公共类              

            分类：             C#(.Net              2012-12-26 16:42     2316人阅读     评论(4)     收藏     举报    
    [csharp] view plaincopyprint?
    1. public class BaseRepository<T> where T : class  
    2.     {  
    3.         //实例化EF框架  
    4.         DataModelContainer db = new DataModelContainer();  
    5.   
    6.         //添加  
    7.         public T AddEntities(T entity)  
    8.         {  
    9.             db.Entry<T>(entity).State = EntityState.Added;  
    10.             db.SaveChanges();  
    11.             return entity;  
    12.         }  
    13.   
    14.         //修改  
    15.         public bool UpdateEntities(T entity)  
    16.         {  
    17.             db.Set<T>().Attach(entity);  
    18.             db.Entry<T>(entity).State = EntityState.Modified;  
    19.             return db.SaveChanges() > 0;  
    20.         }  
    21.   
    22.         //删除  
    23.         public bool DeleteEntities(T entity)  
    24.         {  
    25.             db.Set<T>().Attach(entity);  
    26.             db.Entry<T>(entity).State = EntityState.Deleted;  
    27.             return db.SaveChanges() > 0;  
    28.         }  
    29.   
    30.         //查询  
    31.         public IQueryable<T> LoadEntities(Func<T, bool> wherelambda)  
    32.         {  
    33.             return db.Set<T>().Where<T>(wherelambda).AsQueryable();  
    34.         }  
    35.   
    36.         //分页  
    37.         public IQueryable<T> LoadPagerEntities<S>(int pageSize, int pageIndex, out int total,  
    38.             Func<T, bool> whereLambda, bool isAsc, Func<T, S> orderByLambda)  
    39.         {  
    40.             var tempData = db.Set<T>().Where<T>(whereLambda);  
    41.   
    42.             total = tempData.Count();  
    43.   
    44.             //排序获取当前页的数据  
    45.             if (isAsc)  
    46.             {  
    47.                 tempData = tempData.OrderBy<T, S>(orderByLambda).  
    48.                       Skip<T>(pageSize * (pageIndex - 1)).  
    49.                       Take<T>(pageSize).AsQueryable();  
    50.             }  
    51.             else  
    52.             {  
    53.                 tempData = tempData.OrderByDescending<T, S>(orderByLambda).  
    54.                      Skip<T>(pageSize * (pageIndex - 1)).  
    55.                      Take<T>(pageSize).AsQueryable();  
    56.             }  
    57.             return tempData.AsQueryable();  
    58.         }  
    59.     }  
  • 相关阅读:
    iOS技术框架构和更新版本的技术特性
    iOS第三方常用类库
    查看MySQL系统变量的命令
    解决WIN7下VMWARE虚拟机无法上网问题
    MySQL性能优化的最佳20+条经验
    PHP高效率写法（详解原因）
    google官方建议使用的网站性能测试工具
    ETL工具-KETTLE教程 实例实战4----转换（值映射、列转行，增加常量、增加序列等）
    ETL工具-KETTLE教程实例实战2----环境介绍
    ETL工具-KETTLE教程实例实战1----术语和定义
  • 原文地址：https://www.cnblogs.com/qq260250932/p/4245760.html
Copyright © 2011-2022 走看看