本文例子中使用环境:vs2017,sql server 2008

一,创建EF项目

1,解决方案添加.Net Framework类库项目,在新建的项目下新建项:data->ADO.NET实体数据模型->来自数据库的EF设计器,填写数据库连接,选择包含的内容,完成创建。

     

二,创建接口及方法封装

此过程可参考文章《关于EF 通用增删改查的封装》,这里复制下代码。

using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Data;
using MySql.Data.MySqlClient;
/************************************************
◇作者: LowKeyC
◇说明: 定义一个EF通用的CRUD的接口
◇版本号:V1.0
◇创建日期:2017年6月22日 星期四
*****************************************************/ namespace EFCommon.SqlHelp
{
public interface IRepository : IDisposable
{ /// <summary>
/// 添加实体
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Entity"></param>
/// <returns></returns>
bool Add<T>(T Entity) where T : class; /// <summary>
/// 批量的进行添加实体
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Entity"></param>
/// <returns></returns>
bool AddRange<T>(List<T> Entity) where T : class; /// <summary>
/// 删除单个实体
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Entity"></param>
/// <returns></returns>
bool Delete<T>(T Entity) where T : class; /// <summary>
/// 根据查询条件进行删除单个实体
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="whereLambda"></param>
/// <returns></returns>
bool Delete<T>(Expression<Func<T, bool>> whereLambda) where T : class; /// <summary>
///单个对象的修改
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Entity">需要修改的对象</param>
/// <returns></returns>
bool Update<T>(T Entity) where T : class; /// <summary>
/// 批量修改
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="whereLambda"></param>
/// <param name="updateLambda"></param>
/// <returns></returns>
bool Update<T>(Expression<Func<T, bool>> WhereLambda, Expression<Func<T, T>> UpdateLambda) where T : class; /// <summary>
/// 批量的修改
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Entity"></param>
/// <returns></returns>
bool Update<T>(List<T> Entity) where T : class; /// <summary>
/// 批量统一的进行更新
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="model">需要修改的对象实体</param>
/// <param name="WhereLambda">查询的条件</param>
/// <param name="ModifiedProNames"></param>
/// <returns></returns>
bool Update<T>(T model, Expression<Func<T, bool>> WhereLambda, params string[] ModifiedProNames) where T : class; /// <summary>
/// 根据主键进行查询
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="ID"></param>
/// <returns></returns>
T FindByID<T>(dynamic ID) where T : class; /// <summary>
/// 默认查询选择第一条数据,没有那么进行返回NULL
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="WhereLambda"></param>
/// <returns>返回bool</returns>
T GetFristDefault<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class; /// <summary>
/// 查询所有的数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
List<T> GetAll<T>(string Order = null) where T : class; /// <summary>
/// 含有带条件的查询
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="WhereLambda"></param>
/// <returns></returns>
List<T> GetAllQuery<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class; /// <summary>
///获取查询的数量
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="WhereLambda"></param>
/// <returns></returns>
int GetCount<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class; /// <summary>
/// 判断对象是否存在
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="WhereLambda"></param>
/// <returns></returns>
bool GetAny<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class; /// <summary>
/// 根据查询过条件进行分页
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TKey"></typeparam>
/// <param name="PageIndex">当前页面</param>
/// <param name="PageSize">页面的大小</param>
/// <param name="TotalCount">总记录数</param>
/// <param name="OrderBy">排序的条件</param>
/// <param name="WhereLambda">查询条件</param>
/// <param name="IsOrder">是否正序</param>
/// <returns></returns>
List<T> Pagination<T, TKey>(int PageIndex, int PageSize, out int TotalCount, Expression<Func<T, TKey>> OrderBy, Expression<Func<T, bool>> WhereLambda = null, bool IsOrder = true) where T : class; /// <summary>
/// 根据查询条件进行做分页查询
/// </summary>
/// <typeparam name="T">查询的对象</typeparam>
/// <param name="PageIndex">当前的页码</param>
/// <param name="PageSize">每页的大小</param>
/// <param name="TotalCount">总页数</param>
/// <param name="ordering">排序条件</param>
/// <param name="WhereLambda">查询条件</param>
/// <returns></returns>
List<T> Pagination<T>(int PageIndex, int PageSize, out int TotalCount, string ordering, Expression<Func<T, bool>> WhereLambda = null) where T : class; /// <summary>
/// 根据查询条件进行转化
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="WhereLambda"></param>
/// <returns></returns>
List<T> GetSelect<T>(Expression<Func<T, bool>> WhereLambda) where T : class; /// <summary>
/// 执行存储过程或自定义sql语句--返回集合
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Sql"></param>
/// <param name="Parms"></param>
/// <param name="CmdType"></param>
/// <returns></returns>
List<T> QueryPro<T>(string Sql, List<MySqlParameter> Parms, CommandType CmdType = CommandType.Text) where T : class; /// <summary>
/// 回滚
/// </summary>
/// <typeparam name="T"></typeparam>
void RollBackChanges<T>() where T : class; }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Transactions;
using System.Data.Entity;
using System.Linq.Expressions;
using System.Data;
using System.Linq.Dynamic;
using EntityFramework.Extensions;
using System.Reflection;
using System.Data.Entity.Infrastructure;
using MySql.Data.MySqlClient;
/************************************************
◇作者: LowKeyC 需要引用这个程序集:EntityFramework.Extended.6.1.0.168
◇说明: 实现EF通用的CRUD通用的接口
◇版本号:V1.0
◇创建日期:2017年6月22日 星期四
*****************************************************/
namespace EFCommon.SqlHelp
{
public class Repository : IRepository, IDisposable
{ private readonly static DbContext _DbContextHandle =new ahavadbEntities();//此处进行调用EF的DBContent 的实体类或者通过工厂化模式来进行调用。 /// <summary>
/// 添加一个对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Entity"></param>
/// <returns></returns>
public bool Add<T>(T Entity) where T : class
{
using (TransactionScope Ts = new TransactionScope(TransactionScopeOption.Required))
{
_DbContextHandle.Set<T>().Add(Entity);
int Count = _DbContextHandle.SaveChanges();
Ts.Complete();
return Count > ;
}
} /// <summary>
/// 批量的插入数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Entity"></param>
/// <returns></returns>
public bool AddRange<T>(List<T> Entity) where T : class
{
using (TransactionScope Ts = new TransactionScope(TransactionScopeOption.Required))
{
_DbContextHandle.Set<T>().AddRange(Entity);
int Count = _DbContextHandle.SaveChanges();
Ts.Complete();
return Count > ;
}
} /// <summary>
/// 根据查询条件进行删除对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="whereLambda">查询条件</param>
/// <returns></returns>
public bool Delete<T>(Expression<Func<T, bool>> whereLambda) where T : class
{
using (TransactionScope Ts = new TransactionScope(TransactionScopeOption.Required))
{
var EntityModel = _DbContextHandle.Set<T>().Where(whereLambda).FirstOrDefault();
if (EntityModel != null)
{
_DbContextHandle.Set<T>().Remove(EntityModel);
int Count = _DbContextHandle.SaveChanges();
Ts.Complete();
return Count > ;
}
return false;
}
} /// <summary>
/// 删除单个对象的实体
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Entity">实体对象</param>
/// <returns></returns>
public bool Delete<T>(T Entity) where T : class
{
using (TransactionScope Ts = new TransactionScope(TransactionScopeOption.Required))
{
_DbContextHandle.Set<T>().Attach(Entity);
_DbContextHandle.Set<T>().Remove(Entity);
int Count = _DbContextHandle.SaveChanges();
Ts.Complete();
return Count > ;
}
} /// <summary>
/// 批量的进行更新数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Entity"></param>
/// <returns></returns>
public bool Update<T>(List<T> Entity) where T : class
{
int Count = ;
using (TransactionScope Ts = new TransactionScope(TransactionScopeOption.Required))
{
if (Entity != null)
{
foreach (var items in Entity)
{
var EntityModel = _DbContextHandle.Entry(Entity);
_DbContextHandle.Set<T>().Attach(items);
EntityModel.State = EntityState.Modified;
} }
Count = _DbContextHandle.SaveChanges();
Ts.Complete();
} return Count > ;
} /// <summary>
/// 进行修改单个实体对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Entity">实体对象</param>
/// <returns></returns>
public bool Update<T>(T Entity) where T : class
{
using (TransactionScope Ts = new TransactionScope())
{
var EntityModel = _DbContextHandle.Entry<T>(Entity);
_DbContextHandle.Set<T>().Attach(Entity);
EntityModel.State = EntityState.Modified;
int Count = _DbContextHandle.SaveChanges();
Ts.Complete();
return Count > ;
}
} /// <summary>
/// 批量的修改
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="WhereLambda"></param>
/// <param name="UpdateLambda"></param>
/// <returns></returns>
public bool Update<T>(Expression<Func<T, bool>> WhereLambda, Expression<Func<T, T>> UpdateLambda) where T : class
{
_DbContextHandle.Set<T>().Where(WhereLambda).Update<T>(UpdateLambda);
return _DbContextHandle.SaveChanges() > ;
} /// <summary>
/// 查询条件进行修改
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="model"></param>
/// <param name="WhereLambda"></param>
/// <param name="ModifiedProNames"></param>
/// <returns></returns>
public bool Update<T>(T model, Expression<Func<T, bool>> WhereLambda, params string[] ModifiedProNames) where T : class
{
//查询要修改的数据
List<T> ListModifing = _DbContextHandle.Set<T>().Where(WhereLambda).ToList();
Type t = typeof(T);
List<PropertyInfo> ProInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();
Dictionary<string, PropertyInfo> DitProList = new Dictionary<string, PropertyInfo>();
ProInfos.ForEach(p =>
{
if (ModifiedProNames.Contains(p.Name))
{
DitProList.Add(p.Name, p);
}
}); if (DitProList.Count <= )
{
throw new Exception("指定修改的字段名称有误或为空");
}
foreach (var item in DitProList)
{
PropertyInfo proInfo = item.Value;
object newValue = proInfo.GetValue(model, null);
//批量进行修改相互对应的属性
foreach (T oModel in ListModifing)
{
proInfo.SetValue(oModel, newValue, null);//设置其中新的值
}
} return _DbContextHandle.SaveChanges() > ;
}
/// <summary>
/// 释放缓存
/// </summary>
public void Dispose()
{
_DbContextHandle.Dispose();
} /// <summary>
/// 查询单个对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="ID">主键ID</param>
/// <returns></returns>
public T FindByID<T>(dynamic ID) where T : class
{
return _DbContextHandle.Set<T>().Find(ID) ?? null;
} /// <summary>
/// 获取全部数据的列表
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Order">排序</param>
/// <returns></returns>
public List<T> GetAll<T>(string Order = null) where T : class
{
return Order != null ? _DbContextHandle.Set<T>().OrderBy(Order).ToList() ?? null : _DbContextHandle.Set<T>().ToList() ?? null;
} /// <summary>
///根据查询条件进行查询列表
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="WhereLambda"></param>
/// <returns></returns>
public List<T> GetAllQuery<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class
{
return WhereLambda != null ? _DbContextHandle.Set<T>().Where(WhereLambda).ToList() ?? null : _DbContextHandle.Set<T>().ToList() ?? null;
} /// <summary>
///判断对象是否存在
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="WhereLambda"></param>
/// <returns></returns>
public bool GetAny<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class
{
return WhereLambda != null ? _DbContextHandle.Set<T>().Where(WhereLambda).Any() : _DbContextHandle.Set<T>().Any();
} /// <summary>
/// 获取查询条件的记录数
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="WhereLambda"></param>
/// <returns></returns>
public int GetCount<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class
{
return WhereLambda != null ? _DbContextHandle.Set<T>().Where(WhereLambda).Count() : _DbContextHandle.Set<T>().Count();
} /// <summary>
/// 获取单条的记录
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="WhereLambda"></param>
/// <returns></returns>
public T GetFristDefault<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class
{
return WhereLambda != null ? _DbContextHandle.Set<T>().Where(WhereLambda).FirstOrDefault() ?? null : _DbContextHandle.Set<T>().FirstOrDefault() ?? null;
} /// <summary>
/// 查询对象的转化
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="WhereLambda"></param>
/// <returns></returns>
public List<T> GetSelect<T>(Expression<Func<T, bool>> WhereLambda) where T : class
{
return _DbContextHandle.Set<T>().Where(WhereLambda).ToList() ?? null;
} /// <summary>
///根据查询条件进行分页
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="PageIndex">当前页</param>
/// <param name="PageSize">每页的大小</param>
/// <param name="TotalCount">总记录数</param>
/// <param name="ordering">排序条件</param>
/// <param name="WhereLambda">查询条件</param>
/// <returns></returns>
public List<T> Pagination<T>(int PageIndex, int PageSize, out int TotalCount, string Ordering, Expression<Func<T, bool>> WhereLambda = null) where T : class
{
//分页的时候一定要注意 Order 一定在Skip 之前
var QueryList = _DbContextHandle.Set<T>().OrderBy(Ordering);
if (WhereLambda != null)
{
QueryList = QueryList.Where(WhereLambda);
} TotalCount = QueryList.Count();
return QueryList.Skip(PageSize * (PageIndex - )).Take(PageSize).ToList() ?? null;
} /// <summary>
///根据查询条件进行分页
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="PageIndex">当前页</param>
/// <param name="PageSize">每页的大小</param>
/// <param name="TotalCount">总记录数</param>
/// <param name="OrderBy">排序条件</param>
/// <param name="WhereLambda">查询的条件</param>
/// <param name="IsOrder"></param>
/// <returns></returns>
public List<T> Pagination<T, TKey>(int PageIndex, int PageSize, out int TotalCount, Expression<Func<T, TKey>> OrderBy, Expression<Func<T, bool>> WhereLambda = null, bool IsOrder = true) where T : class
{
//分页的时候一定要注意 Order一定在Skip 之前
IQueryable<T> QueryList = IsOrder == true ? _DbContextHandle.Set<T>().OrderBy(OrderBy) : _DbContextHandle.Set<T>().OrderByDescending(OrderBy); if (WhereLambda != null)
{
QueryList = QueryList.Where(WhereLambda);
} TotalCount = QueryList.Count();
return QueryList.Skip(PageSize * (PageIndex - )).Take(PageSize).ToList() ?? null;
} /// <summary>
/// 执行存储过程的SQL 语句
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Sql">执行的SQL语句</param>
/// <param name="Parms">SQL 语句的参数</param>
/// <param name="CmdType"></param>
/// <returns></returns>
public List<T> QueryPro<T>(string Sql, List<MySqlParameter> Parms, CommandType CmdType = CommandType.Text) where T : class
{
//进行执行存储过程
if (CmdType == CommandType.StoredProcedure)
{
StringBuilder paraNames = new StringBuilder();
foreach (var item in Parms)
{
paraNames.Append($" @{item},");
}
Sql = paraNames.Length > ? $"exec {Sql} {paraNames.ToString().Trim(',')}" : $"exec {Sql} ";
}
return _DbContextHandle.Set<T>().SqlQuery(Sql, Parms.ToArray()).ToList();
} /// <summary>
/// 进行回滚
/// </summary>
/// <typeparam name="T"></typeparam>
public void RollBackChanges<T>() where T : class
{
var Query = _DbContextHandle.ChangeTracker.Entries().ToList(); Query.ForEach(p => p.State = EntityState.Unchanged);
} }
}

因本人使用的是sql server,因此修改这部分的mysql,改用System.Data.SqlClient。采用上面的代码,应该会报错在OrderBy(string),因为构建的是LambdaExpression类型的,这位大神给出了很好的解决方案,一起去看看吧——c# 扩展方法 奇思妙用 高级篇 九:OrderBy(string propertyName, bool desc)

三,使用注意事项

1,需要把EF的配置拷贝到主程序配置里。

2,在主程序配置中添加entityFramework的节点配置

  <entityFramework>
<defaultConnectionFactory type="System.Data.Entity.Infrastructure.LocalDbConnectionFactory, EntityFramework">
<parameters>
<parameter value="mssqllocaldb"/>
</parameters>
</defaultConnectionFactory>
<providers>
<provider invariantName="System.Data.SqlClient" type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer"/>
</providers>
</entityFramework>

3,在主程序中NuGet包中添加下EntityFramework

使用VS2017创建EF框架实例的更多相关文章

  1. ASP.NET MVC+EF框架+EasyUI实现权限管理系列(6)- EF上下文实例管理

    原文:ASP.NET MVC+EF框架+EasyUI实现权限管理系列(6)- EF上下文实例管理 ASP.NET MVC+EF框架+EasyUI实现权限管系列 (开篇)   (1):框架搭建    ( ...

  2. 论在Repository中使用EF框架

    最近在思考框架的事情,从Petshop的传统三层框架过渡到目前的DDD模式. 目前纠结的几个节点是: 1,EF这个ORM框架,有没有必要在 Repository 层封装一下,或者直接在 Service ...

  3. ASP.NET MVC+EF框架+EasyUI实现权限管理系列(2)-数据库访问层的设计Demo

    原文:ASP.NET MVC+EF框架+EasyUI实现权限管理系列(2)-数据库访问层的设计Demo ASP.NET MVC+EF框架+EasyUI实现权限管系列 (开篇) (1)框架搭建 前言:这 ...

  4. Wcf+EF框架搭建实例

    一.最近在使用Wcf创建数据服务,但是在和EF框架搭建数据访问时遇到了许多问题 下面是目前整理的基本框架代码,经供参考使用,源代码地址:http://git.oschina.net/tiama3798 ...

  5. C# CodeFirst(EF框架)代码优先创建数据库

    namespace WebEF.Model{ public class ModelContext:DbContext //继承DBcontext 来自EF框架 { public ModelContex ...

  6. MVC实战之排球计分(六)—— 使用EF框架,创建Controller,生成数据库。

    在上篇博客我们写到,此软件的数据库连接我们使用的是EF框架,code first模式下, 通过模型类,在创建controller的时候直接生成数据库,完成数据库的连接,与操作. 在使用EF框架之前,我 ...

  7. C++反射机制:可变参数模板实现C++反射(使用C++11的新特性--可变模版参数,只根据类的名字(字符串)创建类的实例。在Nebula高性能网络框架中大量应用)

    1. 概要   本文描述一个通过C++可变参数模板实现C++反射机制的方法.该方法非常实用,在Nebula高性能网络框架中大量应用,实现了非常强大的动态加载动态创建功能.Nebula框架在码云的仓库地 ...

  8. vs2017 + mysql+ef 创建实体模型闪退问题

    =>:需要下载安装三个包 mysql和VS链接的驱动 vs2017推荐安装版本:mysql-connector-net-6.10.7.msi vs2015推荐安装版本: mysql-connec ...

  9. .net EF框架 MySql实现实例

    1.nuget中添加包EF和MySql.Data.Entity 2.config文件添加如下配置 1.配置entitframework节点(一般安装EF时自动添加) <entityFramewo ...

随机推荐

  1. 【转】JS 的 new 到底是干什么的?

    原文:https://zhuanlan.zhihu.com/p/23987456?refer=study-fe 大部分讲 new 的文章会从面向对象的思路讲起,但是我始终认为,在解释一个事物的时候,不 ...

  2. mysql必知必会--了解SQL

    什么是数据库 数据库这个术语的用法很多,但就本书而言,数据库是一个以某种 有组织的方式存储的数据集合.理解数据库的一种最简单的办法是将其 想象为一个文件柜.此文件柜是一个存放数据的物理位置,不管数据是 ...

  3. [SDOI] 仪仗队

    SDOI仪仗队 序 迎面冷风袭来 ​  我又该何去何从     哪里       是我的安居之处 正文 我们这个题有一个是很显然的想法,我们可以想到是跟 \(\gcd\) 有关,事实上没有任何分析的, ...

  4. [SDOI2018]反回文串

    题意 问有多少个长度为\(N\)且字符集大小为\(K\)的字符串可以通过回文串旋转 (把第一个字符移到最后)若干次得到.\(K\le N≤10^{18}\) 做法 ARC64F的加强版 设\(h(d) ...

  5. final关键字在JVM中的理解

    我们先来看两段代码与运行结果,根据结果去分析解释一下 不加final关键字: package com.waibizi; public class demo02 { public static void ...

  6. 【database】oracle触发器基础

    一.oracle触发器基本语法 CREATE [OR REPLACE] TRIGGER trigger_name {BEFORE | AFTER } {INSERT | DELETE | UPDATE ...

  7. ECMAScript基本对象——Date日期对象

    1.创建 var 对象名 = new Date(); 2.方法 ①toLocaleString()据本地时间格式,把 Date 对象转换为字符串.和电脑的语言位置有关 ②getTime()返回 197 ...

  8. linux - 服务器性能评估

    影响Linux服务器性能的因素 cpu 内存 磁盘IO 网络IO 系统性能评估标准 影响性能因素 好 坏 糟糕 CPU user% + sys%< 70% user% + sys%= 85% u ...

  9. 【巨杉数据库SequoiaDB】巨杉Tech | 四步走,快速诊断数据库集群状态

    1.背景 SequoiaDB 巨杉数据库是一款金融级分布式数据库,包括了分布式 NewSQL.分布式文件系统与对象存储.与高性能 NoSQL 三种存储模式,分别对应分布式在线交易.非结构化数据和内容管 ...

  10. CSRF漏洞原理

    跨站脚本伪造 用户与服务器端已进行了身份认证,站点已经对用户生成的session,完全信任了,然后此时黑客通过社工发过来一个不友好的链接, 让用户点击请求此站点,站点完全信任这个请求,按照黑客的这个请 ...