aps.net mysql_APS.NET MVC + EF (02)---深入理解ADO.NET Entity Framework

￡神魔★判官ぃ 2022-11-03 05:45 2阅读 0赞

2.7深入理解Entity Framework

性能问题几乎是一切ORM框架的通病，对于EF来说，引起性能低的原因主要在以下几个方面。

复杂的对象管理机制

为了在.NET中更好地管理模型对象，EF提供了一套内部机制管理和跟踪对象的状态，保持对象的一致性，带来方便的同时，降低了性能。

高度封装的执行机制

在EF应用中，编写的任何一个查询表达式都需要经过分析，解析成SQL语句，然后调用底层的ADO.NET Providers去执行。直接执行SQL语句相比，性能上有一定的降低。

低效的SQL语句

EF采用映射机制将对象操作转换为SQL语句，SQL语句一般是基于标准模板生成的，不会进行特殊的优化，这与直接针对业务编写的SQL语句去操作数据相比，效率一般会打折扣，特别是复杂的数据库操作。

Linq查询最终生成的SQL语句是什么样的？我们可以使用ToString()方法直接输出T-SQL代码。如示例10所示。

示例10

using (MySchoolContext db = new MySchoolContext())

var result = db.Student.Where(n => n.StudentName.Contains("张"));

Console.WriteLine(result);

运行结果如图2-10所示。

![1f0da892993d04fd91a24d9bf81fee67.png][]

图2-10 Linq查询生成的SQL语句

当然，EF本身对性能有一系列的优化措施，会使用这写手段的前提是对EF的执行机制有足够的了解。

2.7.1 EF的状态管理

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

示例11

using (MySchoolContext db = new MySchoolContext())

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

//输出当前对象状态

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

db.Grade.Add(grade);

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

db.SaveChanges();

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

示例11中，通过Entry()方法获取模型状态，该方法是DbContext类的成员方法，定义如下：

public DbEntityEntry Entry(TEntity entity)

返回类型 DbEntityEntry 封装了对象状态相关的信息。常用成员如表3-2所示。

表3-2 DbEntityEntry 的主要成员

方法或属性

说明

CurrentValues

获取由此对象表示的跟踪实体的当前属性值

OriginalValues

获取由此对象表示的跟踪实体的原始属性值

State

获取或设置实体的状态

Reload()

从数据库重新加载对象的值

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

Detached：表示对象存在，但没有被跟踪

Unchanged：表示对象尚未经过修改

Added：表示对象为新对象，并且已添加到对象上下文

Deleted：对象已从对象上下文中删除

Modified：表示对象的一个标量属性已更改

通过设置实体的State属性也可以实现对数据的操作，如：

using (MySchoolContext db = new MySchoolContext())

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

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

db.SaveChanges( );

除了需要增删改的对象会受状态管理机制管理外，通过EF查询的数据也默认会进行状态管理。可以通过两种方式指定查询不进行状态管理。

方式一：使用AsNoTracking()方法，如示例12所示。

示例12

using (MySchoolContext db = new MySchoolContext())

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

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

方式二：设置Configuration.AutoDetectChangesEnabled 属性为false，如示例13。

示例13

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

示例14

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.7.2延迟加载和贪婪加载

延迟加载

又称为懒加载，只有每次调用子实体(外键所在的实体)的时候，才去查询数据库， 主表数据加载的时候，不去查询外键所在的从表。

实现延迟加载需要满足两个条件：

poco类是public且不能为sealed。

导航属性需要标记为Virtual。

也可以关闭延迟加载，方法是：

db.Configuration.LazyLoadingEnabled = false;

关闭延迟加载后,查询主表数据时候,主表的中从表实体为null。

示例15

using (dbContext1 db = new dbContext1())

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

//EF默认就是延迟加载，默认下面的语句就是true,所以下面语句注释没有任何影响

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);

贪婪加载

又名：立即加载、贪婪加载、预加载。查询主表的时候通过Include()方法一次性将数据查询了出来，在调用从表数据的时候，从缓存中读取，无须查询数据库。

实现方式：

先关闭延迟加载：db.Configuration.LazyLoadingEnabled = false;

查询主表的同时通过Include把从表数据也查询出来。

示例16

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);

显示加载

关闭了延迟加载，单纯查询了主表数据，这个时候需要重新查询从表数据，就要用到显式加载了。

使用步骤：

①：单个实体用：Reference

②：集合用：Collection

③：最后需要Load一下

示例17

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(stu).Reference(c => c.StudentAddress).Load();

//3.2 集合的情况用Collection

//db.Entry(stu).Collection(c => c.StudentAddress).Load();

//下面调用导航属性(一对一的关系) 每次调用时，都要去查询数据库

var stuAddress = stu.StudentAddress;

Console.WriteLine("地址编号：\{0\}，地址名称：\{1\}",

stuAddress.studentAddressId, stu.studentName);

小结

什么时候使用延迟加载，什么时候又使用贪婪加载呢？

延迟加载只有在需要使用数据时加载，如果不需要使用实体的关联数据，可以使用延迟加载。使用贪婪加载适用于预先了解要使用什么数据的情况，利用这种方式一次性加载数据，可以减少数据库访问次数。

从实际情况来看，使用默认的延迟加载就可以了，2次或3次的数据库查询是可以接受的。而循环中多次读取数据库，可以考虑使用贪婪加载。

2.7.3本地缓存

在使用EF时，有时会多次使用一个查询结果，如示例18所示。

示例18

using (MySchoolEntities db = new MySchoolEntities())

//查询全部学生

IQueryable stus = db.Student;

Console.WriteLine("全部学生姓名：");

foreach (var stu in stus)

Console.WriteLine("学生姓名：\{0\}",stu.StudentName);

//查询并输出学生人数

Console.WriteLine("学生人数为：\{0\}",db.Student.Count());

示例18中会产生两次查询，但从需求来看，完全没有必要，因为第二次完全可以利用第一次查询的结果。事实上，完全可以使用EF的缓存功能，直接利用缓存的结果，DbSet的Local属性正是用于提供缓存的数据。

示例18中，将"db.Student.Count()"替换为"db.Student.Local.Count()"，这样就不会产生新的查询了。

另外，DbSet提供了 Find()方法，用于通过主键查找实体，其查询速度比First()和FirstOrDefault()方法快的多，并且如果相应的实体已经被DbContext缓存，EF会在缓存中直接返回对应的实体，而不会执行数据库访问。

2.7.4 EF中的事务

EF中的事务主要分为三类，分别是SaveChanges、DbContextTransaction 和

TransactionScope。

SaveChanges事务

在前面内容中，SaveChanges一次性将本地缓存中所有的状态变化一次性提交到数据库，这就是一个事务，要么统一成功，要么统一回滚。

示例19

using (DbContext db = new CodeFirstModel())

//增加

TestInfor t1 = new TestInfor()

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

txt1 = "txt1",

txt2 = "txt2"

\};

db.Set().Add(t1);

//删除

TestInfor t2 = db.Set().Where(u => u.id == "1").FirstOrDefault();

if (t2 != null)

db.Set().Remove(t2);

//修改

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

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

//SaveChanges事务提交

int n = db.SaveChanges();

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

示例19中，如果三个操作中有任意一个出现错误，就会回滚，结果n为0。

DbContextTransaction 事务

使用场景：EF调用SQL语句的时候使用该事务、 多个SaveChanges的情况。

示例20

using (DbContext db = new CodeFirstModel())

DbContextTransaction trans = null;

try

//开启事务

trans = db.Database.BeginTransaction();

//增加

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();

DbContextTransaction事务也适用于多个SaveChanges的情况。

示例21

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();

TransactionScope事务

该种事务适用于多数据库连接的情况，在此不做介绍，请自行查阅相关资料。

2.7.5 从实体框架回归SQL

EF虽然本身有很多优化机制，但和直接使用ADO.NET相比，还是有一定的性能差距，因此EF在DbContext类的Database属性里提供了ExecuteSqlCommand()和SqlQuery()两个方法，用来直接访问数据库。

ExecuteSqlCommand()

方法的定义如下：

public int ExecuteSqlCommand(string sql, params object\[\] parameters)

用来执行增、删、改操作，返回结果为受影响行数。

SqlQuery()

方法的定义如下：

public DbRawSqlQuery SqlQuery(string sql, params object\[\] parameters);

用来执行查询操作，返回结果是一个集合。

示例22

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(sql, ps);

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

2.8封装EF的DAL层

![8f900a89c6347c561fdf2122f13be562.png][]

![961ddebeb323a10fe0623af514929fc1.png][]

1 public class BaseDAL where T:class

2 \{3 privateDbContext db4 \{5 get

6 \{7 DbContext dbContext = CallContext.GetData("dbContext") asDbContext;8 if (dbContext == null)9 \{10 dbContext = newMySchoolContext();11 CallContext.SetData("dbContext", dbContext);12 \}13 returndbContext;14 \}15 \}16

17 ///

18 ///执行增加,删除,修改操作(或调用存储过程)19 ///

20 ///

21 ///

22 ///

23 public int ExecuteSql(string sql, paramsSqlParameter\[\] pars)24 \{25 returndb.Database.ExecuteSqlCommand(sql, pars);26 \}27

28 ///

29 ///执行查询操作30 ///

31 ///

32 ///

33 ///

34 ///

35 public List ExecuteQuery(string sql, paramsSqlParameter\[\] pars)36 \{37 return db.Database.SqlQuery(sql, pars).ToList();38 \}39

40 ///

41 ///添加42 ///

43 ///

44 ///

45 public intAdd(T model)46 \{47 db.Set().Add(model);48 returndb.SaveChanges();49 \}50

51 ///

52 ///删除(适用于先查询后删除的单个实体)53 ///

54 /// 需要删除的实体

55 ///

56 public intDel(T model)57 \{58 db.Set().Attach(model);59 db.Set().Remove(model);60 returndb.SaveChanges();61 \}62

63 ///

64 ///根据条件删除(支持批量删除)65 ///

66 /// 传入Lambda表达式(生成表达式目录树)

67 ///

68 public int DelBy(Expression>delWhere)69 \{70 var listDels = db.Set().Where(delWhere);71 foreach(var model inlistDels)72 \{73 db.Set().Attach(model);74 db.Set().Remove(model);75 \}76 returndb.SaveChanges();77 \}78

79 ///

80 ///修改81 ///

82 /// 修改后的实体

83 ///

84 public intModify(T model)85 \{86 db.Entry(model).State =EntityState.Modified;87 returndb.SaveChanges();88 \}89

90 ///

91 ///批量修改92 ///

93 /// 要修改实体中 修改后的属性

94 /// 查询实体的条件

95 /// lambda的形式表示要修改的实体属性名

96 ///

97 public int ModifyBy(T model, Expression> whereLambda, params string\[\] proNames)98 \{99 List listModifes = db.Set().Where(whereLambda).ToList();100 Type t = typeof(T);101 List proInfos = t.GetProperties(BindingFlags.Instance |BindingFlags.Public).ToList();102 Dictionary dicPros = new Dictionary();103 proInfos.ForEach(p =>

104 \{105 if(proNames.Contains(p.Name))106 \{107 dicPros.Add(p.Name, p);108 \}109 \});110 foreach (string proName inproNames)111 \{112 if(dicPros.ContainsKey(proName))113 \{114 PropertyInfo proInfo =dicPros\[proName\];115 object newValue = proInfo.GetValue(model, null);116 foreach (T m inlistModifes)117 \{118 proInfo.SetValue(m, newValue, null);119 \}120 \}121 \}122 returndb.SaveChanges();123 \}124

125 ///

126 ///根据条件查询127 ///

128 /// 查询条件(lambda表达式的形式生成表达式目录树)

129 ///

130 public IQueryable GetListBy(Expression>whereLambda)131 \{132 return db.Set().Where(whereLambda);133 \}134 ///

135 ///根据条件排序和查询136 ///

137 /// 排序字段类型

138 /// 查询条件

139 /// 排序条件

140 /// 升序or降序

141 ///

142 public IQueryable GetListBy(Expression> whereLambda, Expression> orderLambda, bool isAsc = true)143 \{144 if(isAsc)145 \{146 return db.Set().Where(whereLambda).OrderBy(orderLambda);147 \}148 else

149 \{150 return db.Set().Where(whereLambda).OrderByDescending(orderLambda);151 \}152 \}153 ///

154 ///分页查询155 ///

156 /// 排序字段类型

157 /// 页码

158 /// 页容量

159 /// 查询条件

160 /// 排序条件

161 /// 升序or降序

162 ///

163 public IQueryable GetPageList(int pageIndex, int pageSize, Expression> whereLambda, Expression> orderLambda, bool isAsc = true)164 \{165

166 IQueryable list = null;167 if(isAsc)168 \{169 list = db.Set().Where(whereLambda).OrderBy(orderLambda)170 .Skip((pageIndex - 1) \*pageSize).Take(pageSize);171 \}172 else

173 \{174 list = db.Set().Where(whereLambda).OrderByDescending(orderLambda)175 .Skip((pageIndex - 1) \*pageSize).Take(pageSize);176 \}177 returnlist;178 \}179 ///

180 ///分页查询输出总行数181 ///

182 /// 排序字段类型

183 /// 页码

184 /// 页容量

185 /// 查询条件

186 /// 排序条件

187 /// 升序or降序

188 ///

189 public IQueryable GetPageList(int pageIndex, int pageSize, out int rowCount, Expression> whereLambda, Expression> orderLambda, bool isAsc = true)190 \{191 IQueryable list = null;192 rowCount = db.Set().Where(whereLambda).Count();193 if(isAsc)194 \{195 list = db.Set().Where(whereLambda).OrderBy(orderLambda)196 .Skip((pageIndex - 1) \*pageSize).Take(pageSize);197 \}198 else

199 \{200 list = db.Set().Where(whereLambda).OrderByDescending(orderLambda)201 .Skip((pageIndex - 1) \*pageSize).Take(pageSize);202 \}203 returnlist;204 \}205

206

207 \}

[1f0da892993d04fd91a24d9bf81fee67.png]: /images/20221024/5db959106e754f259a9fb84624e8969c.png
[8f900a89c6347c561fdf2122f13be562.png]: /images/20221024/59cad2c6912146688b44d0c515f1c879.png
[961ddebeb323a10fe0623af514929fc1.png]: /images/20221024/1546345ed8394f39b50d949861981e4b.png