封装自己通用的 增删改查的方法 By EF

封装自己的通用CURD By EF

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using MODEL;

namespace ZRFDEMO.DAL
{
    public class BaseDAL<T> where T:class  //----这里我们可以实现 新增一个泛型的接口 如: IbaseDAL<T>.......
    {
        //1.创建EF上下文
        ZRFEntityes db = new ZRFEntityes();//---这里我们可以使用线程内唯一来优化,

        public BaseDAL()
        {
            //关闭 ef 检查
            db.Configuration.ValidateOnSaveEnabled = false;
        }

        #region 0.0 批量更新EF容器数据到数据库 +int SaveChanges()
        /// <summary>
        /// 0.0 批量更新EF容器数据到数据库
        /// </summary>
        /// <returns>返回受影响行数</returns>
        public int SaveChanges()
        {
            return db.SaveChanges();
        }
        #endregion

        #region 1.0 新增方法 +void Add(T model)
        /// <summary>
        /// 1.0 新增方法
        /// </summary>
        /// <param name="model"></param>
        public void Add(T model)
        {
            //1.直接通过EF上下文的 Set方法 获取一个 针对于 T类 做操作的 DbSet对象
            //var dbSet = db.Set<T>();
            //dbSet.Add(model);
            db.Set<T>().Add(model);
        }
        #endregion

        #region 2.0 删除方法 +void Delete(T model)
        /// <summary>
        /// 2.0 删除方法
        /// </summary>
        /// <param name="model"></param>
        public void Delete(T model)
        {
            DbEntityEntry entry = db.Entry<T>(model);
            entry.State = System.Data.EntityState.Deleted;
        }
        #endregion

        #region 2.1 条件删除方法 +void DeleteBy(System.Linq.Expressions.Expression<Func<T, bool>> delWhere)
        /// <summary>
        /// 2.1 条件删除方法
        /// </summary>
        /// <param name="delWhere">要删除的元素查询条件</param>
        public void DeleteBy(System.Linq.Expressions.Expression<Func<T, bool>> delWhere)
        {
            var delList = db.Set<T>().Where(delWhere);
            foreach (T model in delList)
            {
                Delete(model);
            }
        }
        #endregion

        #region 3.0 修改实体 + void Modify(T model, params string[] propertyNames)
        /// <summary>
        /// 3.0 修改实体
        /// </summary>
        /// <param name="model"></param>
        /// <param name="propertyNames"></param>
        public void Modify(T model, params string[] propertyNames)
        {
            DbEntityEntry entry = db.Entry<T>(model);
            entry.State = System.Data.EntityState.Unchanged;
            foreach (string proName in propertyNames)
            {
                entry.Property(proName).IsModified = true;
            }
        }
        #endregion

        #region 4.0 查询方法 +IQueryable<T> Where(Expression<Func<T, bool>> whereLambda)
        /// <summary>
        /// 4.0 查询方法
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        public IQueryable<T> Where(Expression<Func<T, bool>> whereLambda)
        {
            return db.Set<T>().Where(whereLambda);
        }
        #endregion

        #region 4.1 查询方法 -带排序 +IQueryable<T> WhereOrder<TKey>
        /// <summary>
        /// 4.1 查询方法 -带排序
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="whereLambda"></param>
        /// <param name="keySelector">u=></param>
        /// <param name="isAsc"></param>
        /// <returns></returns>
        public IQueryable<T> WhereOrder<TKey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> keySelector, bool isAsc = true)
        {
            if (isAsc)
                return db.Set<T>().Where(whereLambda).OrderBy(keySelector);
            else
                return db.Set<T>().Where(whereLambda).OrderByDescending(keySelector);
        }
        #endregion

        #region 4.2 查询方法 -带Include +IQueryable<T> WhereInclude
        /// <summary>
        /// 4.2 查询方法 -带Include
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <param name="includePropertyNames">要进行连接查询的 属性名</param>
        /// <returns></returns>
        public IQueryable<T> WhereInclude(Expression<Func<T, bool>> whereLambda, params string[] includePropertyNames)
        {
            DbQuery<T> dbQuery = db.Set<T>();
            foreach (string includeName in includePropertyNames)
            {
                dbQuery = dbQuery.Include(includeName);
            }
            return dbQuery.Where(whereLambda);

            //DbQuery<T> dbSet = (DbQuery<T>)db.Set<T>().Where(whereLambda);
            //foreach (string includeName in includePropertyNames)
            //{
            //        dbSet = dbSet.Include(includeName);
            //}
            //return dbSet;
        }
        #endregion

        #region 4.3 查询方法 -带Include 和 排序 +IQueryable<T> WhereInclude<TKey>
        /// <summary>
        /// 4.3 查询方法 -带Include 和 排序
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="whereLambda"></param>
        /// <param name="keySelector"></param>
        /// <param name="isAsc"></param>
        /// <param name="includePropertyNames"></param>
        /// <returns></returns>
        public IQueryable<T> WhereInclude<TKey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> keySelector, bool isAsc = true, params string[] includePropertyNames)
        {
            DbQuery<T> dbQuery = db.Set<T>();
            foreach (string includeName in includePropertyNames)
            {
                dbQuery = dbQuery.Include(includeName);
            }
            IQueryable<T> query = dbQuery.Where(whereLambda);
            if (isAsc)
                return query.OrderBy(keySelector);
            else
                return query.OrderByDescending(keySelector);
        }
        #endregion

        #region 4.4 查询方法 - 分页+Include+排序 + void WherePaged<TKey>
        /// <summary>
        /// 4.4 查询方法 - 分页+Include+排序
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="pagedData"></param>
        /// <param name="whereLambda"></param>
        /// <param name="keySelector"></param>
        /// <param name="isAsc"></param>
        /// <param name="includePropertyNames"></param>
        public void WherePaged<TKey>(MODEL.FormatMODEL.PagedData pagedData, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> keySelector, bool isAsc = true, params string[] includePropertyNames)
        {
            //0.获取 要操作的 数据表 对应的查询对象
            DbQuery<T> dbQuery = db.Set<T>();
            //1.include 属性
            foreach (string includeName in includePropertyNames)
            {
                dbQuery = dbQuery.Include(includeName);
            }
            IOrderedQueryable<T> orderQuery = null;
            //2.排序
            if (isAsc) orderQuery = dbQuery.OrderBy(keySelector);
            else orderQuery = dbQuery.OrderByDescending(keySelector);
            //3.分页查询
            pagedData.ListData = orderQuery.Where(whereLambda).Skip((pagedData.PageIndex - 1) * pagedData.PageSize).Take(pagedData.PageSize).ToList();
            //4.获取总行数
            pagedData.RowCount = orderQuery.Where(whereLambda).Count();
        }
        #endregion
    }
}

  

另外我们还可新增查询Sql的方法,这就不过多啰嗦了!

原文地址:https://www.cnblogs.com/Fengge518/p/11780028.html

时间: 2024-10-11 15:49:47

封装自己通用的 增删改查的方法 By EF的相关文章

通用DAO之MyBatis封装,封装通用的增删改查(三)

曾将发布过俩篇关于Mybatis封装的文章,当时曾曾承诺过当测试没有问题后阿海会整理一下然后将原代码发布出来. 那么今天正好朋友找我要一份那套mybatis封装的源码,我便整理了一份,想想这么长时间了并没有发现什么明显的bug,于是决定将它发出来. 喜欢的朋友可以在这里下载: http://aiyiupload.oss-cn-beijing.aliyuncs.com/blog/img/2016/06/28/15/6d69ad50-ab53-4f4f-b4e7-1fed010bfdb9.rar 关

通用DAO之MyBatis封装,封装通用的增删改查(二)

曾经发过一篇文章,大概写的就是阿海多么多么厉害,见到某位同事在Hibernate的基础上封装了一下,就以一己之力开发什么什么框架,最后写了个超大的一坨的事. 那么,后续篇来了.阿海不是自负之人,当之前的CRUD框架并没有达到理想的结果时,阿海转向了Mybatis封装.别问我为什么不是Hibernate.我本来就不喜欢Hibernate,即使在之前的一家公司一直被强制性的约束使用Hibernate时,也没有对Hibernate产生什么真正的好感,反而屡次发现了Hibernate的一些问题. 或许是

mcv实现通用的增删改查

在mvc框架和前一次通用分页的基础上,我们可以完善一下,把它做成一个通用的增删改查 话不多说直接上代码: 先创建一个与数据库表名对应的实体类Book: package com.entity; public class Book { private int bid; private String bname; private float price; @Override public String toString() { return "Book [bid=" + bid + &quo

(原理篇)基于SQLite3轻量级封装,一行代码实现增删改查

最近写的项目中有用到数据库,写了不少蛋疼的sql语句,每次都是好几行代码,而且每次都是重复的没有一点技术含量的代码,虽然也有不少基于sqlite的封装,不过用起来还是感觉不够面向对象! 为了不再写重复的代码,花了几天时间,基于SQLite3简单封装了下,实现了一行代码解决增删改查等常用的功能!并没有太过高深的知识,主要用了runtime和KVC: 首先我们创建个大家都熟悉的Person类,并声明两个属性,下面将以类此展开分析 @interface Person : NSObject @prope

EF(Entity Framework)通用DBHelper通用类,增删改查以及列表

(1)通用类用法 其中 通用类名:DBhelper 实体类:UserInfo 1 //新增 2 DBHelper<UserInfo> dbhelper = new DBHelper<UserInfo>(); 3 UserInfo userinfo = new UserInfo(); 4 userinfo.Name = "1"; 5 dbhelper.Add(userinfo); 6 7 //根据条件查找列表 8 var entityes = dbhelper.F

一个Servlet处理增删改查的方法

处理的思路是在servlet中定义不同的增删改查方法,页面请求 的时候携带请求的参数,根据参数判断调用不同的方法. package cn.xm.small.Servlet; import java.io.IOException; import java.text.DateFormat; import java.text.SimpleDateFormat; import javax.servlet.ServletException; import javax.servlet.annotation.

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

http://blog.csdn.net/leftfist/article/details/25005307 我刚接触EF未久,还不知道它有什么强大之处,但看上去,EF提供了一般的增删改查功能.以往用过一些ORM方法,尽管有代码生成器,但代码量总的 来说比较多.这次采用EF,我就想,能不能尽量写出一些通用的方法,以后添加表.实体类,只需做很少的改动,就能拥有基本的增删改查功能呢? 方案如下: 1. 分为几个部分:BLL.DAL.Model.Interface.其中,EF生成的代码放在Model.

数据库增删改查代码,登录和注册

封装字段,定义成员变量 using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace data { public class cangkudata { private string cno; public string Cno { get { return cno; } set { cno = value; } } private string city; publi

ztree使用系列三(ztree与springmvc+spring+mybatis整合实现增删改查)

在springmvc+spring+mybatis里整合ztree实现增删改查,上一篇已经写了demo,下面就只贴出各层实现功能的代码: Jsp页面实现功能的js代码如下: <script> //用于捕获分类编辑按钮的 click 事件,并且根据返回值确定是否允许进入名称编辑状态 function beforeEditName(treeId, treeNode) { var zTree = $.fn.zTree.getZTreeObj("treeDemo"); zTree.