1. Entity Framework是Microsoft的ORM框架，随着 Entity Framework 不断的完善强化已经到达了EF 6.0+ 还是非常的完善的，目前使用的比例相对于其他ORM 的框架还是比较多的。例如有我们目前使用较多的是EF和Drapper 和SQL Sugar 以及NHibernate 当然NHibernate 我使用的不多。当然EF确实使用起来非常的方便开发的速度是比较快的，EF 毕竟在Microsoft 在.NET 体系中已经推出了多年了，无论是成熟度还是其中的性能以及优化的程度都得到了很好很大的改善， 所以还是非常值得我们学习使用，当然我这个不是吹嘘EF 好，而且有的朋友也说了 EF 性能不好效率不高，我想询问一下 针对于这些问题你想过如何进行优化 以及改进没有其实目前改进的方案网上还是非常多的，当然也有很多开发者为EF提供了扩展功能，如Entity Framework Extended 等里面封装的一些方法就是非常好使用的。而且作为.NET 开发者来说项目的通用性也是非常的强大的，资料也是非常多的，Microsoft在这块的更新力度也很给力。Entity Framework 提供了三种开发模式，Code Frist，Database-First,Model-First。 目前采用Code Frist 的比较多一些 ，但是我建议大家可以使用DB Frist 简单好用。操作方便。当然你如果你喜欢Code Frist 也是拥有自己的好处，反正三者之间 都是相通的，没有什么难点的。都是ORM 之间的转化。
Database-First模式明显性能会差点，非常的适合初学者，或者是比较急的中小型项目一般情况下使用还是足够的。（数据量200W左右还是足够应付的）。
Model-First模式优点是开发人员能够在设计模型时完全了解数据库的结构以及表格之间的关系，但是缺点是在模型设计完后，还是需要去手动创建数据库，而且生成的脚本有点不简洁。
Code-First模式有点不用说了，就是上面两个模式的缺点。缺点应该也是有很多的，比如更新数据库。涉及到数据的迁移这一块。就让大多数人比较头疼。目前解决的方案比较多。
这个这个只是我个人的意见和看法 。所以关于这个EF 的开发模式的如何的使用，决定权利在于你的项目和数据库数据量大小和你公司的目前存在的框架。
2. 关于我个人封装的通用的EF 比较简单好用就是正对于数据库的CRUD ，而且非常适合于单个数据库的读写的操作。 当然你也可以进行对于数据库进行读写分离的操作，建立相互对应的数据库的集群，那么其实说白了 EF本身就是一个对于CRUD 的读写的操作。使用过EF的人知道，EF提供访问数据库的是 DbContext 这个对象，所以想实现读写分离的就很简单了，只要在程序中使用两个不同的DbContext对象，一个负责读，一个负责写就好了。当然你也可以进行使用相对应的工厂化模式进行 读写分离的操作也可以通过 常用的反射来进行读写的操作，决定权取决在你的手上。所以我们在使用其中的读写分离的时候你只管进行对于 DbContext 进行操作就是了 建立相互对于的读写的类就可以了。 一般读写进行分离的都是进行同步于主库的。因为一般情况下的读写的分离 都是一主多从库的模式。
3.在使用这个通用EF CRUD 类的时候需要 进行添加EntityFramework.Extended.6.1.0.168 EntityFramework 6.1.3 两个程序集 。当然 我这里使用的是MySQL 数据库 所以还添加MySQL Data Entity 的等等。添加以上引用的程序集 就可以了。然后还需要添加相对应的Transaction的程序集，这个时候有的朋友就问了 添加Transaction做什么 我的目的就是通过建立想对应的事务来进行回滚 处理简单的并发 要做全部都做，要么全部都不做。如果你采用Queue 来进行解决并发那就更好了。其中关于EF 的CRUD 的通用代码如下。
1 using System;
2 using System.Collections.Generic;
3 using System.Linq.Expressions;
4 using System.Data;
5 using MySql.Data.MySqlClient;
6 /************************************************
7 ◇作者： LowKeyC
8 ◇说明： 定义一个EF通用的CRUD的接口
9 ◇版本号：V1.0
10 ◇创建日期：2017年6月22日 星期四
11 *****************************************************/
12
13 namespace EFCommon.SqlHelp
14 {
15 public interface IRepository : IDisposable
16 {
17
18 /// <summary>
19 /// 添加实体
20 /// </summary>
21 /// <typeparam name="T"></typeparam>
22 /// <param name="Entity"></param>
23 /// <returns></returns>
24 bool Add<T>(T Entity) where T : class;
25
26 /// <summary>
27 /// 批量的进行添加实体
28 /// </summary>
29 /// <typeparam name="T"></typeparam>
30 /// <param name="Entity"></param>
31 /// <returns></returns>
32 bool AddRange<T>(List<T> Entity) where T : class;
33
34
35 /// <summary>
36 /// 删除单个实体
37 /// </summary>
38 /// <typeparam name="T"></typeparam>
39 /// <param name="Entity"></param>
40 /// <returns></returns>
41 bool Delete<T>(T Entity) where T : class;
42
43 /// <summary>
44 /// 根据查询条件进行删除单个实体
45 /// </summary>
46 /// <typeparam name="T"></typeparam>
47 /// <param name="whereLambda"></param>
48 /// <returns></returns>
49 bool Delete<T>(Expression<Func<T, bool>> whereLambda) where T : class;
50
51
52 /// <summary>
53 ///单个对象的修改
54 /// </summary>
55 /// <typeparam name="T"></typeparam>
56 /// <param name="Entity">需要修改的对象</param>
57 /// <returns></returns>
58 bool Update<T>(T Entity) where T : class;
59
60
61 /// <summary>
62 /// 批量修改
63 /// </summary>
64 /// <typeparam name="T"></typeparam>
65 /// <param name="whereLambda"></param>
66 /// <param name="updateLambda"></param>
67 /// <returns></returns>
68 bool Update<T>(Expression<Func<T, bool>> WhereLambda, Expression<Func<T, T>> UpdateLambda) where T : class;
69
70
71 /// <summary>
72 /// 批量的修改
73 /// </summary>
74 /// <typeparam name="T"></typeparam>
75 /// <param name="Entity"></param>
76 /// <returns></returns>
77 bool Update<T>(List<T> Entity) where T : class;
78
79
80 /// <summary>
81 /// 批量统一的进行更新
82 /// </summary>
83 /// <typeparam name="T"></typeparam>
84 /// <param name="model">需要修改的对象实体</param>
85 /// <param name="WhereLambda">查询的条件</param>
86 /// <param name="ModifiedProNames"></param>
87 /// <returns></returns>
88 bool Update<T>(T model, Expression<Func<T, bool>> WhereLambda, params string[] ModifiedProNames) where T : class;
89
90
91 /// <summary>
92 /// 根据主键进行查询
93 /// </summary>
94 /// <typeparam name="T"></typeparam>
95 /// <param name="ID"></param>
96 /// <returns></returns>
97 T FindByID<T>(dynamic ID) where T : class;
98
99 /// <summary>
100 /// 默认查询选择第一条数据,没有那么进行返回NULL
101 /// </summary>
102 /// <typeparam name="T"></typeparam>
103 /// <param name="WhereLambda"></param>
104 /// <returns>返回bool</returns>
105 T GetFristDefault<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class;
106
107 /// <summary>
108 /// 查询所有的数据
109 /// </summary>
110 /// <typeparam name="T"></typeparam>
111 /// <returns></returns>
112 List<T> GetAll<T>(string Order = null) where T : class;
113
114 /// <summary>
115 /// 含有带条件的查询
116 /// </summary>
117 /// <typeparam name="T"></typeparam>
118 /// <param name="WhereLambda"></param>
119 /// <returns></returns>
120 List<T> GetAllQuery<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class;
121
122
123 /// <summary>
124 ///获取查询的数量
125 /// </summary>
126 /// <typeparam name="T"></typeparam>
127 /// <param name="WhereLambda"></param>
128 /// <returns></returns>
129 int GetCount<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class;
130
131 /// <summary>
132 /// 判断对象是否存在
133 /// </summary>
134 /// <typeparam name="T"></typeparam>
135 /// <param name="WhereLambda"></param>
136 /// <returns></returns>
137 bool GetAny<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class;
138
139
140 /// <summary>
141 /// 根据查询过条件进行分页
142 /// </summary>
143 /// <typeparam name="T"></typeparam>
144 /// <typeparam name="TKey"></typeparam>
145 /// <param name="PageIndex">当前页面</param>
146 /// <param name="PageSize">页面的大小</param>
147 /// <param name="TotalCount">总记录数</param>
148 /// <param name="OrderBy">排序的条件</param>
149 /// <param name="WhereLambda">查询条件</param>
150 /// <param name="IsOrder">是否正序</param>
151 /// <returns></returns>
152 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;
153
154
155 /// <summary>
156 /// 根据查询条件进行做分页查询
157 /// </summary>
158 /// <typeparam name="T">查询的对象</typeparam>
159 /// <param name="PageIndex">当前的页码</param>
160 /// <param name="PageSize">每页的大小</param>
161 /// <param name="TotalCount">总页数</param>
162 /// <param name="ordering">排序条件</param>
163 /// <param name="WhereLambda">查询条件</param>
164 /// <returns></returns>
165 List<T> Pagination<T>(int PageIndex, int PageSize, out int TotalCount, string ordering, Expression<Func<T, bool>> WhereLambda = null) where T : class;
166
167
168 /// <summary>
169 /// 根据查询条件进行转化
170 /// </summary>
171 /// <typeparam name="T"></typeparam>
172 /// <param name="WhereLambda"></param>
173 /// <returns></returns>
174 List<T> GetSelect<T>(Expression<Func<T, bool>> WhereLambda) where T : class;
175
176
177 /// <summary>
178 /// 执行存储过程或自定义sql语句--返回集合
179 /// </summary>
180 /// <typeparam name="T"></typeparam>
181 /// <param name="Sql"></param>
182 /// <param name="Parms"></param>
183 /// <param name="CmdType"></param>
184 /// <returns></returns>
185 List<T> QueryPro<T>(string Sql, List<MySqlParameter> Parms, CommandType CmdType = CommandType.Text) where T : class;
186
187
188 /// <summary>
189 /// 回滚
190 /// </summary>
191 /// <typeparam name="T"></typeparam>
192 void RollBackChanges<T>() where T : class;
193
194 }
195 }
4.关于如何实现以上接口的方法。如下面代码所示。当然你也可以将进行实例化对象这里进行采用简单工厂 或者抽象工厂 全凭个人想法。
1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5 using System.Transactions;
6 using System.Data.Entity;
7 using System.Linq.Expressions;
8 using System.Data;
9 using System.Linq.Dynamic;
10 using EntityFramework.Extensions;
11 using System.Reflection;
12 using System.Data.Entity.Infrastructure;
13 using MySql.Data.MySqlClient;
14 /************************************************
15 ◇作者： LowKeyC 需要引用这个程序集:EntityFramework.Extended.6.1.0.168
16 ◇说明： 实现EF通用的CRUD通用的接口
17 ◇版本号：V1.0
18 ◇创建日期：2017年6月22日 星期四
19 *****************************************************/
20 namespace EFCommon.SqlHelp
21 {
22 public class Repository : IRepository, IDisposable
23 {
24
25 private readonly static DbContext _DbContextHandle =new ahavadbEntities();//此处进行调用EF的DBContent 的实体类或者通过工厂化模式来进行调用。
26
27 /// <summary>
28 /// 添加一个对象
29 /// </summary>
30 /// <typeparam name="T"></typeparam>
31 /// <param name="Entity"></param>
32 /// <returns></returns>
33 public bool Add<T>(T Entity) where T : class
34 {
35 using (TransactionScope Ts = new TransactionScope(TransactionScopeOption.Required))
36 {
37 _DbContextHandle.Set<T>().Add(Entity);
38 int Count = _DbContextHandle.SaveChanges();
39 Ts.Complete();
40 return Count > 0;
41 }
42 }
43
44 /// <summary>
45 /// 批量的插入数据
46 /// </summary>
47 /// <typeparam name="T"></typeparam>
48 /// <param name="Entity"></param>
49 /// <returns></returns>
50 public bool AddRange<T>(List<T> Entity) where T : class
51 {
52 using (TransactionScope Ts = new TransactionScope(TransactionScopeOption.Required))
53 {
54 _DbContextHandle.Set<T>().AddRange(Entity);
55 int Count = _DbContextHandle.SaveChanges();
56 Ts.Complete();
57 return Count > 0;
58 }
59 }
60
61 /// <summary>
62 /// 根据查询条件进行删除对象
63 /// </summary>
64 /// <typeparam name="T"></typeparam>
65 /// <param name="whereLambda">查询条件</param>
66 /// <returns></returns>
67 public bool Delete<T>(Expression<Func<T, bool>> whereLambda) where T : class
68 {
69 using (TransactionScope Ts = new TransactionScope(TransactionScopeOption.Required))
70 {
71 var EntityModel = _DbContextHandle.Set<T>().Where(whereLambda).FirstOrDefault();
72 if (EntityModel != null)
73 {
74 _DbContextHandle.Set<T>().Remove(EntityModel);
75 int Count = _DbContextHandle.SaveChanges();
76 Ts.Complete();
77 return Count > 0;
78 }
79 return false;
80 }
81 }
82
83
84 /// <summary>
85 /// 删除单个对象的实体
86 /// </summary>
87 /// <typeparam name="T"></typeparam>
88 /// <param name="Entity">实体对象</param>
89 /// <returns></returns>
90 public bool Delete<T>(T Entity) where T : class
91 {
92 using (TransactionScope Ts = new TransactionScope(TransactionScopeOption.Required))
93 {
94 _DbContextHandle.Set<T>().Attach(Entity);
95 _DbContextHandle.Set<T>().Remove(Entity);
96 int Count = _DbContextHandle.SaveChanges();
97 Ts.Complete();
98 return Count > 0;
99 }
100 }
101
102 /// <summary>
103 /// 批量的进行更新数据
104 /// </summary>
105 /// <typeparam name="T"></typeparam>
106 /// <param name="Entity"></param>
107 /// <returns></returns>
108 public bool Update<T>(List<T> Entity) where T : class
109 {
110 int Count = 0;
111 using (TransactionScope Ts = new TransactionScope(TransactionScopeOption.Required))
112 {
113 if (Entity != null)
114 {
115 foreach (var items in Entity)
116 {
117 var EntityModel = _DbContextHandle.Entry(Entity);
118 _DbContextHandle.Set<T>().Attach(items);
119 EntityModel.State = EntityState.Modified;
120 }
121
122 }
123 Count = _DbContextHandle.SaveChanges();
124 Ts.Complete();
125 }
126
127 return Count > 0;
128 }
129
130
131 /// <summary>
132 /// 进行修改单个实体对象
133 /// </summary>
134 /// <typeparam name="T"></typeparam>
135 /// <param name="Entity">实体对象</param>
136 /// <returns></returns>
137 public bool Update<T>(T Entity) where T : class
138 {
139 using (TransactionScope Ts = new TransactionScope())
140 {
141 var EntityModel = _DbContextHandle.Entry<T>(Entity);
142 _DbContextHandle.Set<T>().Attach(Entity);
143 EntityModel.State = EntityState.Modified;
144 int Count = _DbContextHandle.SaveChanges();
145 Ts.Complete();
146 return Count > 0;
147 }
148 }
149
150 /// <summary>
151 /// 批量的修改
152 /// </summary>
153 /// <typeparam name="T"></typeparam>
154 /// <param name="WhereLambda"></param>
155 /// <param name="UpdateLambda"></param>
156 /// <returns></returns>
157 public bool Update<T>(Expression<Func<T, bool>> WhereLambda, Expression<Func<T, T>> UpdateLambda) where T : class
158 {
159 _DbContextHandle.Set<T>().Where(WhereLambda).Update<T>(UpdateLambda);
160 return _DbContextHandle.SaveChanges() > 0;
161 }
162
163
164 /// <summary>
165 /// 查询条件进行修改
166 /// </summary>
167 /// <typeparam name="T"></typeparam>
168 /// <param name="model"></param>
169 /// <param name="WhereLambda"></param>
170 /// <param name="ModifiedProNames"></param>
171 /// <returns></returns>
172 public bool Update<T>(T model, Expression<Func<T, bool>> WhereLambda, params string[] ModifiedProNames) where T : class
173 {
174 //查询要修改的数据
175 List<T> ListModifing = _DbContextHandle.Set<T>().Where(WhereLambda).ToList();
176 Type t = typeof(T);
177 List<PropertyInfo> ProInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();
178 Dictionary<string, PropertyInfo> DitProList = new Dictionary<string, PropertyInfo>();
179 ProInfos.ForEach(p =>
180 {
181 if (ModifiedProNames.Contains(p.Name))
182 {
183 DitProList.Add(p.Name, p);
184 }
185 });
186
187 if (DitProList.Count <= 0)
188 {
189 throw new Exception("指定修改的字段名称有误或为空");
190 }
191 foreach (var item in DitProList)
192 {
193 PropertyInfo proInfo = item.Value;
194 object newValue = proInfo.GetValue(model, null);
195 //批量进行修改相互对应的属性
196 foreach (T oModel in ListModifing)
197 {
198 proInfo.SetValue(oModel, newValue, null);//设置其中新的值
199 }
200 }
201
202 return _DbContextHandle.SaveChanges() > 0;
203 }
204 /// <summary>
205 /// 释放缓存
206 /// </summary>
207 public void Dispose()
208 {
209 _DbContextHandle.Dispose();
210 }
211
212 /// <summary>
213 /// 查询单个对象
214 /// </summary>
215 /// <typeparam name="T"></typeparam>
216 /// <param name="ID">主键ID</param>
217 /// <returns></returns>
218 public T FindByID<T>(dynamic ID) where T : class
219 {
220 return _DbContextHandle.Set<T>().Find(ID) ?? null;
221 }
222
223
224 /// <summary>
225 /// 获取全部数据的列表
226 /// </summary>
227 /// <typeparam name="T"></typeparam>
228 /// <param name="Order">排序</param>
229 /// <returns></returns>
230 public List<T> GetAll<T>(string Order = null) where T : class
231 {
232 return Order != null ? _DbContextHandle.Set<T>().OrderBy(Order).ToList() ?? null : _DbContextHandle.Set<T>().ToList() ?? null;
233 }
234
235 /// <summary>
236 ///根据查询条件进行查询列表
237 /// </summary>
238 /// <typeparam name="T"></typeparam>
239 /// <param name="WhereLambda"></param>
240 /// <returns></returns>
241 public List<T> GetAllQuery<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class
242 {
243 return WhereLambda != null ? _DbContextHandle.Set<T>().Where(WhereLambda).ToList() ?? null : _DbContextHandle.Set<T>().ToList() ?? null;
244 }
245
246 /// <summary>
247 ///判断对象是否存在
248 /// </summary>
249 /// <typeparam name="T"></typeparam>
250 /// <param name="WhereLambda"></param>
251 /// <returns></returns>
252 public bool GetAny<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class
253 {
254 return WhereLambda != null ? _DbContextHandle.Set<T>().Where(WhereLambda).Any() : _DbContextHandle.Set<T>().Any();
255 }
256
257 /// <summary>
258 /// 获取查询条件的记录数
259 /// </summary>
260 /// <typeparam name="T"></typeparam>
261 /// <param name="WhereLambda"></param>
262 /// <returns></returns>
263 public int GetCount<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class
264 {
265 return WhereLambda != null ? _DbContextHandle.Set<T>().Where(WhereLambda).Count() : _DbContextHandle.Set<T>().Count();
266 }
267
268
269 /// <summary>
270 /// 获取单条的记录
271 /// </summary>
272 /// <typeparam name="T"></typeparam>
273 /// <param name="WhereLambda"></param>
274 /// <returns></returns>
275 public T GetFristDefault<T>(Expression<Func<T, bool>> WhereLambda = null) where T : class
276 {
277 return WhereLambda != null ? _DbContextHandle.Set<T>().Where(WhereLambda).FirstOrDefault() ?? null : _DbContextHandle.Set<T>().FirstOrDefault() ?? null;
278 }
279
280
281 /// <summary>
282 /// 查询对象的转化
283 /// </summary>
284 /// <typeparam name="T"></typeparam>
285 /// <param name="WhereLambda"></param>
286 /// <returns></returns>
287 public List<T> GetSelect<T>(Expression<Func<T, bool>> WhereLambda) where T : class
288 {
289 return _DbContextHandle.Set<T>().Where(WhereLambda).ToList() ?? null;
290 }
291
292 /// <summary>
293 ///根据查询条件进行分页
294 /// </summary>
295 /// <typeparam name="T"></typeparam>
296 /// <param name="PageIndex">当前页</param>
297 /// <param name="PageSize">每页的大小</param>
298 /// <param name="TotalCount">总记录数</param>
299 /// <param name="ordering">排序条件</param>
300 /// <param name="WhereLambda">查询条件</param>
301 /// <returns></returns>
302 public List<T> Pagination<T>(int PageIndex, int PageSize, out int TotalCount, string Ordering, Expression<Func<T, bool>> WhereLambda = null) where T : class
303 {
304 //分页的时候一定要注意 Order 一定在Skip 之前
305 var QueryList = _DbContextHandle.Set<T>().OrderBy(Ordering);
306 if (WhereLambda != null)
307 {
308 QueryList = QueryList.Where(WhereLambda);
309 }
310
311 TotalCount = QueryList.Count();
312 return QueryList.Skip(PageSize * (PageIndex - 1)).Take(PageSize).ToList() ?? null;
313 }
314
315 /// <summary>
316 ///根据查询条件进行分页
317 /// </summary>
318 /// <typeparam name="T"></typeparam>
319 /// <param name="PageIndex">当前页</param>
320 /// <param name="PageSize">每页的大小</param>
321 /// <param name="TotalCount">总记录数</param>
322 /// <param name="OrderBy">排序条件</param>
323 /// <param name="WhereLambda">查询的条件</param>
324 /// <param name="IsOrder"></param>
325 /// <returns></returns>
326 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
327 {
328 //分页的时候一定要注意 Order一定在Skip 之前
329 IQueryable<T> QueryList = IsOrder == true ? _DbContextHandle.Set<T>().OrderBy(OrderBy) : _DbContextHandle.Set<T>().OrderByDescending(OrderBy);
330
331 if (WhereLambda != null)
332 {
333 QueryList = QueryList.Where(WhereLambda);
334 }
335
336 TotalCount = QueryList.Count();
337 return QueryList.Skip(PageSize * (PageIndex - 1)).Take(PageSize).ToList() ?? null;
338 }
339
340
341 /// <summary>
342 /// 执行存储过程的SQL 语句
343 /// </summary>
344 /// <typeparam name="T"></typeparam>
345 /// <param name="Sql">执行的SQL语句</param>
346 /// <param name="Parms">SQL 语句的参数</param>
347 /// <param name="CmdType"></param>
348 /// <returns></returns>
349 public List<T> QueryPro<T>(string Sql, List<MySqlParameter> Parms, CommandType CmdType = CommandType.Text) where T : class
350 {
351 //进行执行存储过程
352 if (CmdType == CommandType.StoredProcedure)
353 {
354 StringBuilder paraNames = new StringBuilder();
355 foreach (var item in Parms)
356 {
357 paraNames.Append($" @{item},");
358 }
359 Sql = paraNames.Length > 0 ? $"exec {Sql} {paraNames.ToString().Trim(',')}" : $"exec {Sql} ";
360 }
361 return _DbContextHandle.Set<T>().SqlQuery(Sql, Parms.ToArray()).ToList();
362 }
363
364
365 /// <summary>
366 /// 进行回滚
367 /// </summary>
368 /// <typeparam name="T"></typeparam>
369 public void RollBackChanges<T>() where T : class
370 {
371 var Query = _DbContextHandle.ChangeTracker.Entries().ToList();
372
373 Query.ForEach(p => p.State = EntityState.Unchanged);
374 }
375
376 }
377 }
以上内容 全部是基于原创 部分观点 引用了百度百科 以及个人的对于EF 的理解。如需转载请表明！