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;
                 ;
             }
             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;
                 ;
             }
             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);
                 ;
             }
             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;
                 }
                 ;
             }
             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;
                 ;
             }
             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;
                 ;
             }
             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);
                 ;
             }
             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);
                 ;
             }
             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 = ;
                 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 = ;
                 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 = ;
                 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 = ;
                 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)
                     ) * pageSize).Take(pageSize).ToList();
                 else
                     ) * 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)
                     ) * pageSize).Take(pageSize).ToList();
                 else
                     ) * pageSize).Take(pageSize).ToList();
             }
             catch (Exception ex)
             {
                 Log_DG(ex.ToString());
                 Count = ;
                 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)
                     ) * pageSize).Take(pageSize).ToList();
                 else
                     ) * 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)
                     ) * pageSize).Take(pageSize).ToList();
                 else
                     ) * pageSize).Take(pageSize).ToList();
             }
             catch (Exception ex)
             {
                 Log_DG(ex.ToString());
                 Count = ;
                 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/ 且在文章页面明显位置给出原文链接,否则保留追究法律责任的权利。

ORM框架 EF - code first 的封装的更多相关文章

  1. ORM框架 EF - code first 的封装 优化一

    上一节我们讲到对EF(EntityFramework)的初步封装,任何事情都不可能一蹴而就,通过大量的实际项目的实战,也发现了其中的各种问题.在这一章中,我们对上一章的EF_Helper_DG进行优化 ...

  2. ORM框架EF

    应用程序和数据库采用Tcp协议通讯 ORM框架有: NHibernate ,Dapper ,Mybatis 底层是 ADO.Net 好处: 1.面向对象 2.没有sql减少学习成本,快速开发 3.编译 ...

  3. MVC系列学习(二)-初步了解ORM框架-EF

    1.新建 一个控制台项目 2.添加一个数据项 a.选择数据库 注:数据库中的表如下: b.选择EF版本 c.选择表 3.初步了解EF框架 看到了多了一个以 edmx后缀的文件 在edmx文件上,右击打 ...

  4. ORM框架Hibernate (一) 对DAO封装和抽象

    说明 前面已经给大家介绍了Struts这个框架,Struts是对Web项目的表示层进行了封装,而Hibernate是对Web项目中DAO层进行封装,也即是.NET中我们常用到的D层封装,即对访问数据库 ...

  5. 抛弃EF,20分构建一个属于自己的ORM框架

    Poiuyt_cyc 博客园首页新随笔联系订阅管理随笔 - 11  文章 - 0  评论 - 111 抛弃EF,20分构建一个属于自己的ORM框架 相信EF大家都不陌生了,因为数据库表跟程序实体是一一 ...

  6. .Net 常用ORM框架对比:EF Core、FreeSql、SqlSuger

    前言: 最近由于工作需要,需要选用一种ORM框架,也因此对EF Core.FreeSql.SqlSuger作简单对比.个人认为各有有优势,存在即合理,不然早就被淘汰了是吧,所以如何选择因人而议.因项目 ...

  7. 【EF 4】ORM框架及其流行产品之一EF介绍

    导读:跳进了多租户切换数据库的坑,那么就继续走下去吧.在我们的项目中,是运用EF实现对数据库的操作,那么EF其实是.NET系统中,基于ORM框架的一个产品实现.在java那边,则有Hibernate和 ...

  8. webapi框架搭建-数据访问ef code first

    webapi框架搭建系列博客 为什么用ef? 我相信很多博友和我一样都有这种“选择困难症”,我曾经有,现在也有,这是技术人的一个通病——总想用“更完美”的方式去实现,导致在技术选择上犹豫不决,或总是推 ...

  9. EF、Dapper、NHibernate等ORM框架的比较及优缺点

    什么是ORM? ORM的全称是Object Relational Mapping,即对象关系映射.它的实现思想就是将关系数据库中表的数据映射成为对象,以对象的形式展现,这样开发人员就可以把对数据库的操 ...

随机推荐

  1. 剑指offer习题集2

    1.把数组排成最小的数 class Solution { public: static bool compare(const string& s1, const string& s2) ...

  2. LINQ inner join

    用的EF,需要联合查询,否则就需要反复的访问数据库 var query = from fp in db.Form_ProcessSets                         join n  ...

  3. zmap使用笔记

    zmap使用笔记 zmap, 一个网络端口开放性的快速扫描工具.至于这个工具的特色,配置参数,和比的工具的对比,不做介绍.只记录一下近期使用过程中,遇到的问题.软件版本:2.1.1 传言与现实 传言: ...

  4. EXT学习之——EXT下拉框默认绑定第一个值

    //默认第一个下拉框绑定值if (this.moduleCombo.store.getAt(0) != undefined) { this.moduleCombo.setValue(this.modu ...

  5. EXT学习之——获取下拉框combobox的值与显示名

    //申请科室 var comboboxdept = new Ext.form.ComboBox({ xtype: "combobox", name: "Gender&qu ...

  6. display:inline-block左右元素上下不对齐

    今天做了两个inline-block元素,出现左右两个元素顶端出现上下不对齐的情况(下图): 解决办法: 把应用 inline-block的元素加上 vertical-align: top; .CSS ...

  7. win7,xp通用的打开文件浏览对话框的方法

    第一种:Function BrowseForFile()     Dim shell : Set shell = CreateObject("WScript.Shell")     ...

  8. NHibernate系列文章十:NHibernate对象二级缓存下

    摘要 上一节对NHibernate二级缓存做了简单介绍,NHibernate二级缓存是由SessionFactory管理的,所有Session共享.这一节介绍二级缓存其他两个方面:二级缓存查询和二级缓 ...

  9. 用vector容器代替数组 ——使用数组初始化vector对象

    在C++中,我们不能用数组直接初始化另一数组,而只能创建新的数组,然后显式的把原数组的元素逐个复制给新的数组. 按照C语言中的做法: const size_t arry_size=6; int int ...

  10. ajax分页

    html显示 <center> <div id="fyh"> <ul class="pagination" id="fy ...