ORM框架 EF code first 的封装

Code first 是Microsoft Entity Framework中的一种模式，CodeFirst不会有可视化的界面来进行拖动编辑DataBase-Entity，但会以一个类来进行对数据表关系的描述，以及对所有实体类的描述，优势在于，代码更加地简洁，文件目录更加清晰，也更加便于维护。

直接用实体关系类进行操作，最后SaveChanges，无可厚非，当然可以了，但是，对于一个追求更加简便，更加抽象的程序员来说，无限的封装似乎是一种追求吧，废话不多说，这里直接上EF_Helper_DG的代码->

首先示例性地来一个实体关系类，以便于后面的帮助类的对比，当然，这个类也是不可或缺的。

DBEntity_DG（习惯性地起名）

namespace QX_Frame.DAL.Service
{
    using System.Data.Entity;
    using QX_Frame.Model;

    public partial class DBEntity_DG : DbContext
    {
        public DBEntity_DG()
            : base("name=DBEntity_DG")
        {
        }

        public virtual DbSet<tb_Class> tb_Class { get; set; }
        public virtual DbSet<tb_User> tb_User { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<tb_Class>()
                .Property(e => e.Name)
                .IsFixedLength();

            modelBuilder.Entity<tb_Class>()
                .HasMany(e => e.tb_User)
                .WithRequired(e => e.tb_Class)
                .HasForeignKey(e => e.ClassId)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<tb_User>()
                .Property(e => e.Name)
                .IsFixedLength();
        }
    }
}

然后，我们来上正菜 EF_DBEntity_DG

using LinqKit; //AsExpandable() in linqkit.dll
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Data.Entity;
using QX_Frame.Helper_DG_Framework_4_6;

namespace QX_Frame.DAL.Service
{
    /*  time:2016-10-30 15:26:05
        author:qixiao
          */

    #region The EF_DBEntity_DG visual Interface

    public interface IEF_DBEntity_DG
    {
        Boolean IsAdd<T>(T entity);
        Boolean IsAdd<T>(T entity, out T outEntity);
        Boolean IsAdd<T>(List<T> entities);

        Boolean IsUpdate<T>(T entity);
        Boolean IsUpdate<T>(T entity, out T outEntity);

        Boolean IsDelete<T>(T entity);
        Boolean IsDelete<T>(List<T> entities);
        Boolean IsDelete<T>(Expression<Func<T, bool>> deleteWhere);

        T selectSingle<T>(Expression<Func<T, Boolean>> selectWhere);

        List<T> selectAll<T>();
        List<T> selectAll<T>(out int Count);
        List<T> selectAll<T>(Expression<Func<T, T>> orderBy, Boolean isDESC = false);
        List<T> selectAll<T>(Expression<Func<T, T>> orderBy, out int Count, Boolean isDESC = false);
        List<T> selectAll<T>(Expression<Func<T, Boolean>> selectWhere);
        List<T> selectAll<T>(Expression<Func<T, Boolean>> selectWhere, out int Count);
        List<T> selectAll<T>(Expression<Func<T, Boolean>> selectWhere, Expression<Func<T, T>> orderBy, Boolean isDESC = false);
        List<T> selectAll<T>(Expression<Func<T, Boolean>> selectWhere, Expression<Func<T, T>> orderBy, out int Count, Boolean isDESC = false);

        List<T> selectAllPaging<T>(int pageIndex, int pageSize);
        List<T> selectAllPaging<T>(int pageIndex, int pageSize, out int Count);
        List<T> selectAllPaging<T>(int pageIndex, int pageSize, Expression<Func<T, Boolean>> selectWhere);
        List<T> selectAllPaging<T>(int pageIndex, int pageSize, Expression<Func<T, Boolean>> selectWhere, out int Count);
        List<T> selectAllPaging<T>(int pageIndex, int pageSize, Expression<Func<T, T>> orderBy, Boolean isDESC = false);
        List<T> selectAllPaging<T>(int pageIndex, int pageSize, Expression<Func<T, T>> orderBy, out int Count, Boolean isDESC = false);
        List<T> selectAllPaging<T>(int pageIndex, int pageSize, Expression<Func<T, Boolean>> selectWhere, Expression<Func<T, T>> orderBy, Boolean isDESC = false);
        List<T> selectAllPaging<T>(int pageIndex, int pageSize, Expression<Func<T, Boolean>> selectWhere, Expression<Func<T, T>> orderBy, out int Count, Boolean isDESC = false);
    }

    #endregion

    public abstract class EF_DBEntity_DG
    {
        /*the singleton DBEntity_DG */
        /// <summary>
        /// The DBEntity_DG is must be named: DBEntity_DG
        /// </summary>
        private volatile static DBEntity_DG db = null;

        #region The Singleton to new DBEntity_DG 
        private static readonly object lockHelper = new object();
        static EF_DBEntity_DG()
        {
            if (db == null)
            {
                lock (lockHelper)
                {
                    if (db == null)
                        db = new DBEntity_DG();
                }
            }
            //close the Validate of EF OnSaveEnabled
            db.Configuration.ValidateOnSaveEnabled = false;
        }
        #endregion

        /// <summary>
        /// Give the Error Log support
        /// </summary>
        /// <param name="logText">LogText</param>
        /// <param name="isAppend">The Log Text isAppend or Cover</param>
        private static void Log_DG(string logText, string logTitle = "DBEntity_DG Error", Boolean isAppend = true)
        {
            string LogLocation_DG = @"Log_QX_Frame/Log_QX_Frame_Error/";
            try
            {
                LogLocation_DG = Config_Helper_DG.AppSetting_Get("Log_Location_Error_DG");
            }
            catch (Exception)
            {
                LogLocation_DG = @"Log_QX_Frame/Log_QX_Frame_Error/";
            }
            if (!Directory.Exists(LogLocation_DG))
            {
                Directory.CreateDirectory(LogLocation_DG);
            }
            using (StreamWriter log = new StreamWriter(LogLocation_DG + "Log_" + DateTime.Now.Year + DateTime.Now.Month + DateTime.Now.Day + ".Log", isAppend))
            {
                log.WriteLine();
                log.WriteLine(DateTime_Helper_DG.Get_DateTime_Now_24HourType() + "   -------" + logTitle + " Log !--------------------");
                log.WriteLine();
                log.WriteLine(logText);
            }
        }

        #region Add 

        public static Boolean IsAdd<T>(T entity) where T : class
        {
            try
            {
                db.Entry<T>(entity).State = EntityState.Added;
                return db.SaveChanges() > 0;
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                return false;
            }
        }
        public static Boolean IsAdd<T>(T entity, out T outEntity) where T : class
        {
            try
            {
                db.Entry<T>(entity).State = EntityState.Added;
                outEntity = entity;
                return db.SaveChanges() > 0;
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                outEntity = default(T);
                return false;
            }
        }
        public static Boolean IsAdd<T>(List<T> entities) where T : class
        {
            try
            {
                db.Set<T>().AddRange(entities);
                return db.SaveChanges() > 0;
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                return false;
            }
        }

        #endregion

        #region Update

        public static Boolean IsUpdate<T>(T entity) where T : class
        {
            try
            {
                if (db.Entry<T>(entity).State == EntityState.Detached)
                {
                    db.Set<T>().Attach(entity);
                    db.Entry<T>(entity).State = EntityState.Modified;
                }
                return db.SaveChanges() > 0;
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                return false;
            }
        }
        public static Boolean IsUpdate<T>(T entity, out T outEntity) where T : class
        {
            try
            {
                db.Set<T>().Attach(entity);
                db.Entry<T>(entity).State = EntityState.Modified;
                outEntity = entity;
                return db.SaveChanges() > 0;
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                outEntity = default(T);
                return false;
            }
        }

        #endregion

        #region Delete

        public static Boolean IsDelete<T>(T entity) where T : class
        {
            try
            {
                db.Set<T>().Attach(entity);
                db.Entry<T>(entity).State = EntityState.Deleted;
                return db.SaveChanges() > 0;
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                return false;
            }
        }
        public static Boolean IsDelete<T>(List<T> entities) where T : class
        {
            try
            {
                db.Set<T>().RemoveRange(entities);
                return db.SaveChanges() > 0;
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                return false;
            }
        }
        public static Boolean IsDelete<T>(Expression<Func<T, bool>> deleteWhere) where T : class
        {
            try
            {
                List<T> entitys = db.Set<T>().AsExpandable().Where(deleteWhere).ToList();
                entitys.ForEach(m => db.Entry<T>(m).State = EntityState.Deleted);
                return db.SaveChanges() > 0;
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                return false;
            }
        }
        #endregion

        #region Select 

        public static Boolean IsExist<T>(Expression<Func<T, Boolean>> selectWhere) where T : class
        {
            try
            {
                return db.Set<T>().AsExpandable().Where(selectWhere).ToList().FirstOrDefault<T>() == null ? false : true;
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                return default(Boolean);
            }
        }
        public static T selectSingle<T>(Expression<Func<T, Boolean>> selectWhere) where T : class
        {
            try
            {
                return db.Set<T>().AsExpandable().Where(selectWhere).ToList().FirstOrDefault<T>();
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                return default(T);
            }
        }
        public static List<T> selectAll<T>() where T : class
        {
            try
            {
                return db.Set<T>().AsExpandable().ToList();
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                return default(List<T>);
            }
        }
        public static List<T> selectAll<T>(out int Count) where T : class
        {
            try
            {
                Count = db.Set<T>().AsExpandable().Count();
                return db.Set<T>().AsExpandable().ToList();
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                Count = 0;
                return default(List<T>);
            }
        }
        public static List<T> selectAll<T, TKey>(Expression<Func<T, TKey>> orderBy, Boolean isDESC = false) where T : class
        {
            try
            {
                if (isDESC)
                    return db.Set<T>().AsExpandable().OrderByDescending(orderBy).ToList();
                else
                    return db.Set<T>().AsExpandable().OrderBy(orderBy).ToList();
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                return default(List<T>);
            }
        }
        public static List<T> selectAll<T, TKey>(Expression<Func<T, TKey>> orderBy, out int Count, Boolean isDESC = false) where T : class
        {
            try
            {
                Count = db.Set<T>().AsExpandable().Count();
                if (isDESC)
                    return db.Set<T>().AsExpandable().OrderByDescending(orderBy).ToList();
                else
                    return db.Set<T>().AsExpandable().OrderBy(orderBy).ToList();
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                Count = 0;
                return default(List<T>);
            }
        }
        public static List<T> selectAll<T>(Expression<Func<T, Boolean>> selectWhere) where T : class
        {
            try
            {
                return db.Set<T>().AsExpandable().Where(selectWhere).ToList();
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                return default(List<T>);
            }
        }
        public static List<T> selectAll<T>(Expression<Func<T, Boolean>> selectWhere, out int Count) where T : class
        {

            try
            {
                var list = db.Set<T>().AsExpandable().Where(selectWhere);
                Count = list.Count();
                return list.ToList();
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                Count = 0;
                return default(List<T>);
            }
        }
        public static List<T> selectAll<T, TKey>(Expression<Func<T, TKey>> orderBy, Expression<Func<T, Boolean>> selectWhere, Boolean isDESC = false) where T : class
        {
            try
            {
                if (isDESC)
                    return db.Set<T>().AsExpandable().Where(selectWhere).OrderByDescending(orderBy).ToList();
                else
                    return db.Set<T>().AsExpandable().Where(selectWhere).OrderBy(orderBy).ToList();
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                return default(List<T>);
            }
        }
        public static List<T> selectAll<T, TKey>(Expression<Func<T, TKey>> orderBy, Expression<Func<T, Boolean>> selectWhere, out int Count, Boolean isDESC = false) where T : class
        {
            try
            {
                var list = db.Set<T>().AsExpandable().Where(selectWhere);
                Count = list.Count();
                if (isDESC)
                    return list.OrderByDescending(orderBy).ToList();
                else
                    return list.OrderBy(orderBy).ToList();
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                Count = 0;
                return default(List<T>);
            }
        }

        public static List<T> selectAllPaging<T, TKey>(int pageIndex, int pageSize, Expression<Func<T, TKey>> orderBy, Boolean isDESC = false) where T : class
        {
            try
            {
                var list = db.Set<T>().AsExpandable();
                if (isDESC)
                    return list.OrderByDescending(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
                else
                    return list.OrderBy(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                return default(List<T>);
            }
        }
        public static List<T> selectAllPaging<T, TKey>(int pageIndex, int pageSize, Expression<Func<T, TKey>> orderBy, out int Count, Boolean isDESC = false) where T : class
        {
            try
            {
                var list = db.Set<T>().AsExpandable();
                Count = list.Count();
                if (isDESC)
                    return list.OrderByDescending(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
                else
                    return list.OrderBy(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                Count = 0;
                return default(List<T>);
            }
        }
        public static List<T> selectAllPaging<T, TKey>(int pageIndex, int pageSize, Expression<Func<T, TKey>> orderBy, Expression<Func<T, Boolean>> selectWhere, Boolean isDESC = false) where T : class
        {
            try
            {
                var list = db.Set<T>().AsExpandable().Where(selectWhere);
                if (isDESC)
                    return list.OrderByDescending(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
                else
                    return list.OrderBy(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                return default(List<T>);
            }
        }
        public static List<T> selectAllPaging<T, TKey>(int pageIndex, int pageSize, Expression<Func<T, TKey>> orderBy, Expression<Func<T, Boolean>> selectWhere, out int Count, Boolean isDESC = false) where T : class
        {
            try
            {
                var list = db.Set<T>().AsExpandable().Where(selectWhere);
                Count = list.Count();
                if (isDESC)
                    return list.OrderByDescending(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
                else
                    return list.OrderBy(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
            }
            catch (Exception ex)
            {
                Log_DG(ex.ToString());
                Count = 0;
                return default(List<T>);
            }
        }

        #endregion
    }
}

这里说明一下：

1、IEF_DBEntity_DG 帮助类的接口，当然我没有继承这个接口，这个接口只是我以后回顾的时候看的，并没有实际使用价值，只作为说明性的文字，不喜勿碰哈。

2、采用单例模式，这里不做过多说明，单例的介绍铺天盖地，我只是说，使用的时候，需要在这里改动两处对应到实体关系类上。

3、使用泛型，泛型在帮助类的重要性不必多说了吧，写帮助类不用泛型...啧啧啧。

4、Log_DG 这里直接封装了EF操作的错误信息，一般在try catch中调用，对错误进行日志的描述，便于后续的错误查找。

5、里面分别封装了 增加、删除、修改、查询四种基础的操作，并且每种操作都附有大量的重载（尤其是查询）便于适应更多不断变化项目；还有一些是快捷的操作，IsExist 这里直接返回数据是否存在。

6、所有的条件采用lambda表达式的方式，lambda表达式是比较新颖比较方便的条件判断条件筛选方式之一，在未来会更多地使用lambda表达式进行操作，在C#6.0已然是得到了很大的支持。

7、恰到适宜的out 输出参数，保证了在需要插入并且需要插入的结果需求的使用。

8、查询的分页支持，不必再写繁琐的分页，这里已经对分页进行了支持。

具体内容，参考类详情吧，后续更新修改，敬请期待！ --柒小 2016年12月21日22:34:01

本文为七小站主原创作品，转载请注明出处：http://www.cnblogs.com/qixiaoyizhan/ 且在文章页面明显位置给出原文链接，否则保留追究法律责任的权利。