深入理解ADO.NET Entity Framework（02）

目录：

• ORM概念
• 数据迁移
• EF状态管理
• 加载
• 缓存
• 事务
• 封装EF的DAL层

Ado.net Entity Framework 是Microsoft推出的ORM框架。

1.ORM

对象映射关系对数据库进行操作，解决面向对象与关系数据库不匹配的现象。

• CSDL ：概念层 O （对象）
• SSDL ：存储层 R（配置文件 标记对象对应数据库的表）
• MSL ：对应层 M （映射）

　　EF包括三种模式：DBFirst、CodeFist、ModelFirst 。

　　　(1)数据库到对象模型

• 在项目中添加"ADO.NET实体数据模型"，选择"来自数据库的EF设计器"，按照提示配置数据库相关信息。选择相关的数据库表。
• 打开.emdx文件,edmx中包含SSDL、CSDL和C-S mapping三种类型的节点定义，分别对应EDM中的存储层、概念层、对应层。这也是EF实现ORM的关键配置文件。
• 导航属性 -- 外键列 （一对一 （obj） 一对多（Icollection<obj>）） 
• DBContext -- uisng system.data.Entity -- 数据库上下文
• 操作数据

//查询
using (MySchoolEntities entities = new MySchoolEntities()){
//按名称查询年级编号
Grade grade = entities.Grade.SingleOrDefault(g => g.GradeName == "S2");
if (grade!=null)
Console.WriteLine("S2年级的编号为{0}",grade.GradeId);
//用where（）方法查询符合条件的数据
IQueryable<Student> query = entities.Student.Where(s => s.GradeId == grade.GradeId);
Console.WriteLine("学号	姓名");
foreach (var stu in query)
{Console.WriteLine("{0}	{1}",stu.StudentNo,stu.StudentName);}}

//添加数据
using (MySchool1Entities entities = new MySchool1Entities())
{Student stu=new Student(){StudentNo="S10001",StudentName="王翱翔",GradeId=2,Sex="男"};
entities.Student.Add(stu); //向实体集添加数据
if (entities.SaveChanges()>0) //将添加的数据保存到数据库中
Console.WriteLine("添加数据成功！");}

//修改数据
using (MySchool1Entities entities = new MySchool1Entities()){
//先查询要修改的数据
Student stu = entities.Student.FirstOrDefault(s => s.StudentName == "王翱翔");
if (stu!=null)
{stu.LoginPwd = "123456"; //修改对象属性值}
if (entities.SaveChanges()>0) //将修改的对象保存到数据库中
{Console.WriteLine("修改数据成功！");}}

//删除数据
using (MySchool1Entities entities = new MySchool1Entities()){
//先查询要删除的数据
Student stu = entities.Student.FirstOrDefault(s => s.StudentName == "王翱翔");
if (stu!=null)
{entities.Student.Remove(stu);} //从数据集中移除数据if (entities.SaveChanges()>0)
{Console.WriteLine("删除数据成功！");}}

注意：需要额外做的两件事是创建数据上下文对象和调用其SaveChange（）方法实现数据的增、删、改。

　　(2)从代码到数据库

• 安装Entity Framework package包、创建实体类、创建DbContext类、创建MySchoolContext类

<configuration>
<connectionStrings>
<add name="MySchool" providerName="System.Data.SqlClient" connectionString="Data Source=.;Initial Catalog=Test;Persist Security Info=True;User ID=sa;Password=sa"/>
</connectionStrings>
</configuration>

//创建MySchoolContext类
sing System.Data.Entity;
public class MySchoolContext:DbContext
{
//构造函数，会读取配置文件中的连接字符串
public MySchoolContext():base("MySchool") //.config文件数据库连接字符串名称
{}
//对象集合
public DbSet<Grade> Grade { get; set; }
public DbSet<Student> Student { get; set; }
//重新父类中的方法（当模型初始化后被调用）
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
//指定单数形式的表名（否则数据库的表名会是复数形式）
//需要命名空间：using System.Data.Entity.ModelConfiguration.Conventions;
modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
}
}

• EF中的默认约定

　　　①关于表和字段名的约定。映射列和属性命名一致

　　　②关于主键的约定。将命名为 Id 或 [类名]Id 的属性视为类的键，如果是int类型同时会设为标识列。

　　　③字符串属性的约定。字符串约定为映射到不限长度的非空列中，默认数据类型为nvarchar(max)，且允许为空。

　　　④布尔值的约定。Code Frirst将bool属性映射为 bit 类型，且不允许为空。

　　　⑤关系。1对1、1对多、多对多

• 配置覆盖约定

　　　　①使用Data Annotation特性

public class Student
{

[Key] //主键声明
public string studentKey { get; set; }

[Required] //非空声明
public string stuName { get; set; }

[MaxLength(10)] //最大长度
public string stuTxt1 { get; set; }

[MaxLength(10), MinLength(2)] //最大长度和最小长度
public string stuTxt2 { get; set; }

[ConcurrencyCheck] //并发检查
public string stuTxt3 { get; set; }

public virtual Address stuAddress { get; set; }
}

[ Table("myAddress")] //设置类映射的数据库表名
public class Address
{
[ForeignKey("stu")] //设置外键(对应下面声明的 stu) //这里符合 类名+id(忽略大小写)的规则，所以自动生成主键
public string AddressId { get; set; }

[Column("myAddressName")] //设置映射数据库中表的列名
public string AddressName { get; set; }

[Column("myAddressName2", Order = 1, TypeName = "varchar")] //设置映射数据库中表的列名、顺序、类型

public string AddrssName2 { get; set; }

[NotMapped]//不映射数据
public string addressNum { get; set; }

public virtual Student stu { get; set; }
}

　　　　②使用Fluent API

　　　　可以将一个类映射成多个数据库表，还可以将配置写成多个文件，方便控制。优先级：Fluent API > data annotations > default conventions.

　　　　常见配置：

　　　　　　❶获取表对应的配置根： var stu =modelBuilder.Entity<XXX>();

　　　　　　❷设置主键：HasKey<string>(s => s.studentKey);

　　　　　　❸获取属性：stu.Property(p => p.stuName)

　　　　　　❹设置可空或非空：IsRequired和IsOptional

　　　　　　❺设置最大值：HasMaxLength

　　　　　　❻修改属性名→修改属性的次序→修改属性对应的数据库类型：HasColumnName→HasColumnOrder→HasColumnType

　　　　　　❼修改表名：ToTable

　　　　可以建立多个Fluent API的配置文件，然后通过modelBuilder.Configurations.Add(new XXX());添加到一起。

public class Student
{
//主键声明
public string studentKey { get; set; }

//非空声明
public string stuName { get; set; }

//最大长度
public string stuTxt1 { get; set; }

//最大长度和最小长度
public string stuTxt2 { get; set; }

//并发检查
public string stuTxt3 { get; set; }
}

public class Address

{
//既是主键、又是外键
public string AddressId { get; set; }

//设置映射数据库中表的列名
public string AddressName { get; set; }

//设置映射数据库中表的列名、顺序、类型
public string AddrssName2 { get; set; }

//不映射数据
public string addressNum { get; set; }

}

/// <summary>
/// Game实体，与其它两个没有什么直接关系，单纯的为了演示, Fluent API的配置，可以根据实体进行拆分
/// 文件来配置，方便管理
/// </summary>
public class Game
{
public int GameId { get; set; }
public string GameName { get; set; }
}

/// <summary>
/// Game实体的配置文件
/// </summary>
public class GameConfiguration : EntityTypeConfiguration<Game>
{
public GameConfiguration()
{
this.HasKey(p => p.GameId);
this.Property(p => p.GameName).HasMaxLength(10).IsRequired();
}
}

public class dbContext : DbContext
{
public dbContext(): base("name=MySchool")
{
}
   

public DbSet<Student> Student { get; set; }

public DbSet<Address> Address { get; set; }

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
//所有的FluentAPI均在方法中进行重写
//一. 属性层次上的设置
var stu = modelBuilder.Entity<Student>();
var stuAddress = modelBuilder.Entity<StudentAddress>();

//1. 设置主键
stu.HasKey<string>(s => s.studentKey);
stuAddress.HasKey<string>(s => s.AddressId);
   
//2. 设置非空 （扩展：IsOptional 设置可空）
stu.Property(p => p.stuName).IsRequired( );

//3. 设置最大值（不能设置最小值）
stu.Property(p => p.stuTxt1).HasMaxLength(10);

//4. 修改列的名称、排序、类型
stuAddress.Property(p => p.stuAddrssName2).HasColumnName("myAddress2").HasColumnOrder(1).HasColumnType("varchar");

//5.修改表名
stu.Map<Student>(c =>
{
c.ToTable("MyStudent");
});

//6.将一个实体映射成多张表，并分别给其命名
//stuAddress.Map<StudentAddress>(c =>
//{
// c.Properties(p => new
// {
// p.AddressId,
// p.AddressName
// });
// c.ToTable("MyStuAddress1");
//}).Map<StudentAddress5>(c =>
//{
// c.Properties(p => new
// {
// p.stuAddressId,
// p.stuAddrssName2
// });
// c.ToTable("MyStuAddress2");
//});

//三. 将Game实体的配置添加进来
modelBuilder.Configurations.Add(new GameConfiguration());
base.OnModelCreating(modelBuilder);
}
}

（3）EF CodeFirst 数据库初始化策略和数据迁移

①数据库初始化策略

四种策略：

• CreateDatabaseIfNotExists：EF的默认策略，一旦model发生变化,抛异常，提示数据迁移
• DropCreateDatabaseIfModelChanges：一旦model发生变化,删除数据库重新生成
• DropCreateDatabaseAlways：数据库每次都重新生成
• 自定义初始化(继承上面的三种策略中任何一种，然后追加自己的业务)

也可以关闭Database.SetInitializer<dbContext6>(null);关闭后改变实体类，不会报错，不会丢失数据，但也无法映射改变数据库结构。

public class MySchoolEntities : DbContext
{
public MySchoolEntities (): base("name=MySchool")
{
//在这里可以改变生成数据库的初始化策略
//1. CreateDatabaseIfNotExists （EF的默认策略，数据库不存在,生成数据库；一旦model发生变化,抛异常，提示走数据迁移)
//Database.SetInitializer<MySchoolEntities>(new CreateDatabaseIfNotExists<MySchoolEntities >());

//2. DropCreateDatabaseIfModelChanges （一旦model发生变化,删除数据库重新生成）
//Database.SetInitializer<MySchoolEntities >(new DropCreateDatabaseIfModelChanges<MySchoolEntities >());

//3.DropCreateDatabaseAlways （数据库每次都重新生成）
//Database.SetInitializer<MySchoolEntities >(new DropCreateDatabaseAlways<MySchoolEntities >());

//4. 自定义初始化(继承上面的三种策略中任何一种，然后追加自己的业务)
//Database.SetInitializer<MySchoolEntities >(new MySpecialIntializer());

//5. 禁用数据库策略（不会报错，不会丢失数据，但是改变不了数据库的结构了）
//Database.SetInitializer<MySchoolEntities >(null);
}

public DbSet<Animal> Animal { get; set; }
public DbSet<AnimalKind> AnimalKind { get; set; }
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
}

/// <summary>
/// 自定义一个初始化策略，每次初始化时追加10条数据
/// </summary>
public class MySpecialIntializer :
DropCreateDatabaseAlways<MySchoolEntities >
{
public override void InitializeDatabase(MySchoolEntities context)
{
base.InitializeDatabase(context);
}
   
//重写seed，追加初始数据
protected override void Seed(MySchoolEntities context)
{
for (int i = 0; i < 10; i++)
{
context.Animal.Add(new Animal()
{
id = "animal" + i,
animalName = "mru" + i,
animalKind = "mruru" + i,
});
}
context.SaveChanges();
base.Seed(context);
}
}
}

②数据迁移

解决修改表结构，数据丢失的问题。两种方式：

• 自动迁移（不安全）

//(1)新建Configuration.cs类，在其构造函数中进行相关配置。
internal sealed class Configuration :
DbMigrationsConfiguration<MySchoolEntities >
{
public Configuration()
{
AutomaticMigrationsEnabled = true; //(2)启用自动迁移
AutomaticMigrationDataLossAllowed = true; //(3)更改数据库中结构(增加、删除列、修改列、改变列的属性、增加、删除、修改表),需要显示开启。}}

public class MySchoolEntities : DbContext
{
public MySchoolEntities (): base("name=MySchool")
{
//数据库迁移配置
//数据库迁移的初始化方式
Database.SetInitializer(new MigrateDatabaseToLatestVersion<MySchoolEntities , Configuration>("MySchoolEntities"));
}

public DbSet<Animal> Animal { get; set; }
public DbSet<AnimalKind> AnimalKind { get; set; }
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
}
}

• 手动迁移

　　(1)通过“程序包管理器控制台”的enable-migrations命令启动数据迁移。该命令只需执行一次

　　　　作用：在项目根目录下创建了一个Migrations文件夹,在Migrations文件夹下新建一个Configuration.cs文件。

　　(2)执行添加“add-migration InitialCreate”命令

　　　　作用：产生一个<timestamp>_InitialCreate.cs的文件，文件中的两个方法（Up和Down）用来完成数据的更改

　　(3)执行更新“update-database”命令

　　　　作用：完成数据库的更新

• 迁移回退

　　PM> update-database -TargetMigration:SchoolDB-v1

 

1.1 ORM性能问题

• 复杂的对象管理机制：执行数据库会全程跟踪，降低性能
• 高度封装执行机制：编写的表达式都要解析成SQL语句。
• 低效的SQL语句：映射机制转将对象操作换为SQL语句，效率低。

1.2 EF的状态管理

在程序中实现数据的增、删、改操作，EF会监控这些状态的变化，在执行SaveChange（）方法时，会根据对象状态的变化执行相应的操作。

using (MySchoolContext db = new MySchoolContext())

{

Grade grade = new Grade() { GradeName = "Y3" };

//输出当前对象状态

Console.WriteLine(db.Entry(grade).State);  //通过Entry（）方法获取模型状态

   

db.Grade.Add(grade);

Console.WriteLine(db.Entry(grade).State);

   

db.SaveChanges();

Console.WriteLine(db.Entry(grade).State);

}

方法或属性	说明
CurrentValues	获取由此对象表示的跟踪实体的当前属性值
OriginalValues	获取由此对象表示的跟踪实体的原始属性值
State	获取或设置实体的状态
Reload（）	从数据库重新加载对象的值

其中，State属性是一个EntityState枚举类型，其取值如下：

执行过程：  --Detached 游离、Added 添加、Unchanged 未改变、Modified 已修改、Deleted 已删除、Detached 游离

Detached	表示对象存在，但没有被跟踪
Unchanged	表示对象尚未经过修改
Added	表示对象为新对象，并且已添加到对象上下文
Deleted	对象已从对象上下文中删除
Modified	表示对象的一个标量属性已更改

1.3查询不进行跟踪

• AsNoTracking（）方法

using (MySchoolContext db = new MySchoolContext())

{

var result = db.Student.AsNoTracking().FirstOrDefault();

Console.WriteLine(db.Entry(result).State);

}

• 设置Configuration.AutoDetectChangesEnabled 属性为false

using (MySchoolContext db = new MySchoolContext())

{

//禁用自动跟踪变化

db.Configuration.AutoDetectChangesEnabled = false;

for (int i = 0; i < 5000; i++)

{

var stu = new Student() { StudentName = "alex",

GradeId = 1, Age = 20 };

db.Student.Add(stu);

}

db.SaveChanges();

}

在使用EF修改或删除数据时，必须先查询对象，然后再对其进行修改或删除。然而现实开发中很多情况都是通过主键删除一条数据。我们可以通过实体的状态特性来进行优化。

using (MySchool1Entities entities = new MySchool1Entities())

{

//创建替身对象

var stu = new Student { StudentNo = "10001" };

//给实体附加到上下文中

entities.Student.Attach(stu);

//删除

entities.Student.Remove(stu);

entities.SaveChanges();

}

代码中的Attach（）方法可以将EntityState.Unchangee状态的对象附加到上下文中。

2.加载

• 延迟加载

　　每次调用时再去查询,两个条件：①Poco类是Public且不能为Sealed。 ②导航属性需要标记为Vritual。

• 贪懒加载

　　一次性将数据读取出来，从缓存中读取，不用在查询数据库，两个条件：①先关闭延迟加载。 ②查询主表的同时通过Include把从表数据也查询出来。

• 显示加载

　　--步骤：①单个实体用：Reference  ②集合用：Collection  ③最后需要Load一下

注意：默认用延迟，多次读数据库用贪婪。

//延迟加载
using (dbContext1 db = new dbContext1())
{

Console.WriteLine("---------------- 01-延迟加载 ---------------");


//EF默认就是延迟加载，默认下面的语句就是true,关闭则false

db.Configuration.LazyLoadingEnabled = true;


var list = db.Student.ToList(); //此处加载的数据,没有对从表进行任何查询操作


foreach (var stu in list)
{
Console.WriteLine("学生编号：{0},学生姓名：{1}", stu.studentId, stu.studentName);

//下面调用导航属性(一对一的关系) 每次调用时，都要去查询数据库
var stuAddress = stu.StudentAddress;
Console.WriteLine("地址编号：{0}，地址名称：{1}",
stuAddress.studentAddressId, stu.studentName);

}
}


//贪懒加载
using (dbContext1 db = new dbContext1())
{
Console.WriteLine("------------------- 03-立即加载 ------------------");
   
//1.关闭延迟加载

db.Configuration.LazyLoadingEnabled = false;

//2. 获取主表数据的同时，通过Include将从表中的数据也全部加载出来
var list = db.Student.Include("StudentAddress").ToList();
foreach (var stu in list)
{
Console.WriteLine("学生编号：{0},学生姓名：{1}", stu.studentId,
stu.studentName);
//这里获取从表中的数据，均是从缓存中获取，无需查询数据库
var stuAddress = stu.StudentAddress;
Console.WriteLine("地址编号：{0}，地址名称：{1}",
stuAddress.studentAddressId, stu.studentName);
}
}



//显示加载

using (dbContext1 db = new dbContext1())
{
Console.WriteLine("----------------- 04-显式加载 ------------------");

//1.关闭延迟加载
db.Configuration.LazyLoadingEnabled = false;

//2.此处加载的数据，不含从表中的数据
var list = db.Student.ToList();
foreach (var stu in list)
{
Console.WriteLine("学生编号：{0},学生姓名：{1}", stu.studentId,
stu.studentName);


//3.下面的这句话，可以开启重新查询一次数据库
//3.1 单个属性的情况用Refercence
db.Entry<Student>(stu).Reference(c => c.StudentAddress).Load();

//3.2 集合的情况用Collection
//db.Entry<Student>(stu).Collection(c => c.StudentAddress).Load();

//下面调用导航属性(一对一的关系) 每次调用时，都要去查询数据库
var stuAddress = stu.StudentAddress;
Console.WriteLine("地址编号：{0}，地址名称：{1}",
stuAddress.studentAddressId, stu.studentName);
}
}

3.缓存

• EF的dbset<T>的Local属性提供缓存
• DbSet<T>提供了 Find（）方法，用于通过主键查找实体速度比First方法快的多，并且如果相应的实体已经被DbContext缓存，EF会在缓存中直接返回对应的实体，不执行数据库访问。

4.事务

•  SaveChanges
• DbContextTransaction
• TransactionScope

using (DbContext db = new CodeFirstModel())
{
//增加
TestInfor t1 = new TestInfor()
{
id = Guid.NewGuid().ToString("N"),
txt1 = "txt1",
txt2 = "txt2"
};

db.Set<TestInfor>().Add(t1);

//删除
TestInfor t2 = db.Set<TestInfor>().Where(u => u.id == "1").FirstOrDefault();
if (t2 != null)
{
db.Set<TestInfor>().Remove(t2);
}

//修改

TestInfor t3 = db.Set<TestInfor>().Where(u => u.id == "3").FirstOrDefault();

t3.txt2 = "我是李马茹23";

   

//SaveChanges事务提交

int n = db.SaveChanges();  //一次性统一或回滚

Console.WriteLine("数据作用条数:" + n);

}

using (DbContext db = new CodeFirstModel())

{

DbContextTransaction trans = null;

try

{

//开启事务

trans = db.Database.BeginTransaction();  //多个SaveChanges

//增加

string sql1 = @"insert into TestInfor values(@id,@txt1,@txt2)";

SqlParameter[] pars1 ={

new SqlParameter("@id",Guid.NewGuid().ToString("N")),

new SqlParameter("@txt1","txt11"),

new SqlParameter("@txt2","txt22")

};

db.Database.ExecuteSqlCommand(sql1, pars1);

//删除

string sql2 = @"delete from TestInfor where id=@id";

SqlParameter[] pars2 ={

new SqlParameter("@id","22")

};

db.Database.ExecuteSqlCommand(sql2, pars2);

//修改

string sql3 = @"update TestInfor set txt1=@txt1 where id=@id";

SqlParameter[] pars3 ={

new SqlParameter("@id","3"),

new SqlParameter("@txt1","二狗子")

};

db.Database.ExecuteSqlCommand(sql3, pars3);

   

//提交事务

trans.Commit();

Console.WriteLine("事务成功了");

}

catch (Exception ex)

{

Console.WriteLine(ex.Message);

trans.Rollback(); //回滚

   

}

finally

{

//也可以把该事务写到using块中,让其自己托管,就不需要手动释放了

trans.Dispose();

}

}

using (DbContext db = new CodeFirstModel())

{

//自动脱管，不需要手动释放 多数据库连接

using (DbContextTransaction trans = db.Database.BeginTransaction())

{

try

{

TestInfor t1 = new TestInfor()

{

id = Guid.NewGuid().ToString("N"),

txt1 = "111111111",

txt2 = "222222222222"

};

db.Entry(t1).State = EntityState.Added;

db.SaveChanges();

   

TestInfor t2 = new TestInfor()

{

id = Guid.NewGuid().ToString("N") + "123",

txt1 = "111111111",

txt2 = "222222222222"

};

db.Entry(t2).State = EntityState.Added;

db.SaveChanges();

   

trans.Commit();

}

catch (Exception)

{

trans.Rollback();

}

}

}

5.从实体框架回归SQL

EF在DbContext类的Database属性里提供了ExecuteSqlCommand（）和SqlQuery（）两个方法，用来直接访问数据库。

• ExecuteSqlCommand（）
• SqlQuery（）

using (MySchool1Entities db = new MySchool1Entities())

{

//执行update语句

string sql = "update grade set gradeName=@gradeName where

gradeId=@gradeId";

SqlParameter[] ps =

{

new SqlParameter("@gradeName","第二学年"),

new SqlParameter("@gradeId",3)

};

int result=db.Database.ExecuteSqlCommand(sql, ps);  //返回影响行数

if (result>0)

{

Console.WriteLine("数据更新完成！");

}

//执行查询语句

sql = "select * from from student where studentNo=@stuNo";

ps = new SqlParameter[] { new SqlParameter("@stuNo", "S1001234") };

var stu = db.Database.SqlQuery<Student>(sql, ps);  //返回集合

Console.WriteLine(stu.ToList()[0]);

}

封装EF的DAL层

  public class BaseDAL<T> where T:class
  2     {
  3         private DbContext db
  4         {
  5             get
  6             {
  7                 DbContext dbContext = CallContext.GetData("dbContext") as DbContext;
  8                 if (dbContext == null)
  9                 {
 10                     dbContext = new MySchoolContext();
 11                     CallContext.SetData("dbContext", dbContext);
 12                 }
 13                 return dbContext;
 14             }
 15         }
 16 
 17         /// <summary>
 18         /// 执行增加,删除,修改操作(或调用存储过程)
 19         /// </summary>
 20         /// <param name="sql"></param>
 21         /// <param name="pars"></param>
 22         /// <returns></returns>
 23         public int ExecuteSql(string sql, params SqlParameter[] pars)
 24         {
 25             return db.Database.ExecuteSqlCommand(sql, pars);
 26         }
 27 
 28         /// <summary>
 29         /// 执行查询操作
 30         /// </summary>
 31         /// <typeparam name="T"></typeparam>
 32         /// <param name="sql"></param>
 33         /// <param name="pars"></param>
 34         /// <returns></returns>
 35         public List<T> ExecuteQuery(string sql, params SqlParameter[] pars)
 36         {
 37             return db.Database.SqlQuery<T>(sql, pars).ToList();
 38         }
 39 
 40         /// <summary>
 41         /// 添加
 42         /// </summary>
 43         /// <param name="model"></param>
 44         /// <returns></returns>
 45         public int Add(T model)
 46         {
 47             db.Set<T>().Add(model);
 48             return db.SaveChanges();
 49         }
 50 
 51         /// <summary>
 52         /// 删除(适用于先查询后删除的单个实体)
 53         /// </summary>
 54         /// <param name="model">需要删除的实体</param>
 55         /// <returns></returns>
 56         public int Del(T model)
 57         {
 58             db.Set<T>().Attach(model);
 59             db.Set<T>().Remove(model);
 60             return db.SaveChanges();
 61         }
 62 
 63         /// <summary>
 64         /// 根据条件删除(支持批量删除)
 65         /// </summary>
 66         /// <param name="delWhere">传入Lambda表达式(生成表达式目录树)</param>
 67         /// <returns></returns>
 68         public int DelBy(Expression<Func<T, bool>> delWhere)
 69         {
 70             var listDels = db.Set<T>().Where(delWhere);
 71             foreach(var model in listDels)
 72             {
 73                 db.Set<T>().Attach(model);
 74                 db.Set<T>().Remove(model);
 75             }
 76             return db.SaveChanges();
 77         }
 78 
 79         /// <summary>
 80         /// 修改
 81         /// </summary>
 82         /// <param name="model">修改后的实体</param>
 83         /// <returns></returns>
 84         public int Modify(T model)
 85         {
 86             db.Entry(model).State = EntityState.Modified;
 87             return db.SaveChanges();
 88         }
 89 
 90         /// <summary>
 91         /// 批量修改
 92         /// </summary>
 93         /// <param name="model">要修改实体中 修改后的属性 </param>
 94         /// <param name="whereLambda">查询实体的条件</param>
 95         /// <param name="proNames">lambda的形式表示要修改的实体属性名</param>
 96         /// <returns></returns>
 97         public int ModifyBy(T model, Expression<Func<T, bool>> whereLambda, params string[] proNames)
 98         {
 99             List<T> listModifes = db.Set<T>().Where(whereLambda).ToList();
100             Type t = typeof(T);
101             List<PropertyInfo> proInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();
102             Dictionary<string, PropertyInfo> dicPros = new Dictionary<string, PropertyInfo>();
103             proInfos.ForEach(p =>
104             {
105                 if (proNames.Contains(p.Name))
106                 {
107                     dicPros.Add(p.Name, p);
108                 }
109             });
110             foreach (string proName in proNames)
111             {
112                 if (dicPros.ContainsKey(proName))
113                 {
114                     PropertyInfo proInfo = dicPros[proName];
115                     object newValue = proInfo.GetValue(model, null);
116                     foreach (T m in listModifes)
117                     {
118                         proInfo.SetValue(m, newValue, null);
119                     }
120                 }
121             }
122             return db.SaveChanges();
123         }
124 
125         /// <summary>
126         /// 根据条件查询
127         /// </summary>
128         /// <param name="whereLambda">查询条件(lambda表达式的形式生成表达式目录树)</param>
129         /// <returns></returns>
130         public IQueryable<T> GetListBy(Expression<Func<T, bool>> whereLambda)
131         {
132             return db.Set<T>().Where(whereLambda);
133         }
134         /// <summary>
135         /// 根据条件排序和查询
136         /// </summary>
137         /// <typeparam name="Tkey">排序字段类型</typeparam>
138         /// <param name="whereLambda">查询条件</param>
139         /// <param name="orderLambda">排序条件</param>
140         /// <param name="isAsc">升序or降序</param>
141         /// <returns></returns>
142         public IQueryable<T> GetListBy<Tkey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, Tkey>> orderLambda, bool isAsc = true)
143         {
144             if (isAsc)
145             {
146                 return db.Set<T>().Where(whereLambda).OrderBy(orderLambda);
147             }
148             else
149             {
150                 return db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda);
151             }
152         }
153         /// <summary>
154         /// 分页查询
155         /// </summary>
156         /// <typeparam name="Tkey">排序字段类型</typeparam>
157         /// <param name="pageIndex">页码</param>
158         /// <param name="pageSize">页容量</param>
159         /// <param name="whereLambda">查询条件</param>
160         /// <param name="orderLambda">排序条件</param>
161         /// <param name="isAsc">升序or降序</param>
162         /// <returns></returns>
163         public IQueryable<T> GetPageList<Tkey>(int pageIndex, int pageSize, Expression<Func<T, bool>> whereLambda, Expression<Func<T, Tkey>> orderLambda, bool isAsc = true)
164         {
165 
166             IQueryable<T> list = null;
167             if (isAsc)
168             {
169                 list = db.Set<T>().Where(whereLambda).OrderBy(orderLambda)
170                .Skip((pageIndex - 1) * pageSize).Take(pageSize);
171             }
172             else
173             {
174                 list = db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda)
175               .Skip((pageIndex - 1) * pageSize).Take(pageSize);
176             }
177             return list;
178         }
179         /// <summary>
180         /// 分页查询输出总行数
181         /// </summary>
182         /// <typeparam name="Tkey">排序字段类型</typeparam>
183         /// <param name="pageIndex">页码</param>
184         /// <param name="pageSize">页容量</param>
185         /// <param name="whereLambda">查询条件</param>
186         /// <param name="orderLambda">排序条件</param>
187         /// <param name="isAsc">升序or降序</param>
188         /// <returns></returns>
189         public IQueryable<T> GetPageList<Tkey>(int pageIndex, int pageSize, out int rowCount, Expression<Func<T, bool>> whereLambda, Expression<Func<T, Tkey>> orderLambda, bool isAsc = true)
190         {
191             IQueryable<T> list = null;
192             rowCount = db.Set<T>().Where(whereLambda).Count();
193             if (isAsc)
194             {
195                 list = db.Set<T>().Where(whereLambda).OrderBy(orderLambda)
196                    .Skip((pageIndex - 1) * pageSize).Take(pageSize);
197             }
198             else
199             {
200                 list = db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda)
201                  .Skip((pageIndex - 1) * pageSize).Take(pageSize);
202             }
203             return list;
204         }
205 
206 
207     }

• DbContextTransaction