1_MVC+EF+Autofac(dbfirst)轻型项目框架_core层(以登陆为例)

public partial interface ITeacher{}

    public partial class Teacher : BaseCore<Entity.Teacher>, ICore.ITeacher
    {
        public Teacher(DbContext dbContext)
        {
            db = dbContext;
        }
    }

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Data.Entity;
  4 using System.Data.Entity.Infrastructure;
  5 using System.Linq;
  6 using System.Linq.Expressions;
  7 using System.Reflection;
  8 using System.Text;
  9 
 10 namespace EDUA_Core
 11 {
 12     /// <summary>
 13     /// 业务帮助父类
 14     /// </summary>
 15     /// <typeparam name="T">之类类型</typeparam>
 16     public class BaseCore<T> where T : class,new()
 17     {
 18         /// <summary>
 19         /// EF上下文对象
 20         /// </summary>
 21         protected DbContext db { get; set; }
 22 
 23         #region 1.0新增实体 + void Add(T model)
 24         /// <summary>
 25         /// 新增实体
 26         /// </summary>
 27         /// <param name="model">新增的实体</param>
 28         protected void Add(T model)
 29         {
 30             db.Set<T>().Add(model);
 31         }  
 32         #endregion
 33 
 34         #region 1.0.1新增实体并保存 +　int AddAndSave(T model)
 35         /// <summary>
 36         /// 新增实体并保存
 37         /// </summary>
 38         /// <param name="model">新增的实体</param>
 39         /// <returns>受影响的行数</returns>
 40         protected int AddAndSave(T model)
 41         {
 42             Add(model);
 43             return db.SaveChanges();
 44         } 
 45         #endregion
 46 
 47         #region 2.0删除实体 + void Del(T model)
 48         /// <summary>
 49         /// 删除实体
 50         /// </summary>
 51         /// <param name="model">删除的实体</param>
 52         protected void Del(T model)
 53         {
 54             db.Set<T>().Attach(model);
 55             db.Set<T>().Remove(model);
 56         } 
 57         #endregion
 58 
 59         #region 2.0.1删除实体并保存 + int DelAndSave(T model)
 60         /// <summary>
 61         /// 删除实体并保存
 62         /// </summary>
 63         /// <param name="model">删除的实体</param>
 64         /// <returns>受影响的行数</returns>
 65         protected int DelAndSave(T model)
 66         {
 67             Del(model);
 68             return db.SaveChanges();
 69         } 
 70         #endregion
 71 
 72         #region 2.1根据条件删除 + void DelBy(Expression<Func<T, bool>> delWhere)
 73         /// <summary>
 74         /// 根据条件删除
 75         /// </summary>
 76         /// <param name="delWhere">条件</param>
 77         protected void DelBy(Expression<Func<T, bool>> delWhere)
 78         {
 79             //3.1查询要删除的数据
 80             List<T> listDeleting = db.Set<T>().Where(delWhere).ToList();
 81             //3.2将要删除的数据 用删除方法添加到 EF 容器中
 82             listDeleting.ForEach(u =>
 83             {
 84                 db.Set<T>().Attach(u);//先附加到 EF容器
 85                 db.Set<T>().Remove(u);//标识为 删除 状态
 86             });
 87         } 
 88         #endregion
 89 
 90         #region 2.1.1根据条件删除并保存 + int DelByAndSave(Expression<Func<T, bool>> delWhere)
 91         /// <summary>
 92         /// 根据条件删除并保存
 93         /// </summary>
 94         /// <param name="delWhere">条件</param>
 95         /// <returns>受影响的行数</returns>
 96         protected int DelByAndSave(Expression<Func<T, bool>> delWhere)
 97         {
 98             DelBy(delWhere);
 99             return db.SaveChanges();
100         } 
101         #endregion
102 
103         #region 3.0修改实体 + void Modify(T model, params string[] proNames)
104         /// <summary>
105         /// 修改，如：
106         /// T u = new T() { uId = 1, uLoginName = "asdfasdf" };
107         /// this.Modify(u, "uLoginName");
108         /// </summary>
109         /// <param name="model">要修改的实体对象</param>
110         /// <param name="proNames">要修改的 属性 名称</param>
111         protected void Modify(T model, params string[] proNames)
112         {
113             //4.1将 对象 添加到 EF中
114             DbEntityEntry entry = db.Entry<T>(model);
115             //4.2先设置 对象的包装 状态为 Unchanged
116             entry.State = (System.Data.Entity.EntityState)System.Data.EntityState.Unchanged;
117             //4.3循环 被修改的属性名 数组
118             foreach (string proName in proNames)
119             {
120                 //4.4将每个 被修改的属性的状态 设置为已修改状态;后面生成update语句时，就只为已修改的属性 更新
121                 entry.Property(proName).IsModified = true;
122             }
123         } 
124         #endregion
125 
126         #region 3.0.1修改和保存 + int ModifyAndSave(T model, params string[] proNames)
127         /// <summary>
128         /// 修改和保存，如：
129         /// T u = new T() { uId = 1, uLoginName = "asdfasdf" };
130         /// this.Modify(u, "uLoginName");
131         /// </summary>
132         /// <param name="model">要修改的实体对象</param>
133         /// <param name="proNames">要修改的 属性 名称</param>
134         /// <returns>受影响的行数</returns>
135         protected int ModifyAndSave(T model, params string[] proNames)
136         {
137             Modify(model, proNames);
138             return db.SaveChanges();
139         } 
140         #endregion
141 
142         #region 3.1批量修改 +　void ModifyBy(T model, Expression<Func<T, bool>> whereLambda, params string[] modifiedProNames)
143         /// <summary>
144         /// 批量修改
145         /// </summary>
146         /// <param name="model">要修改的实体对象</param>
147         /// <param name="whereLambda">查询条件</param>
148         /// <param name="proNames">要修改的 属性 名称</param>
149         protected void ModifyBy(T model, Expression<Func<T, bool>> whereLambda, params string[] modifiedProNames)
150         {
151             //4.1查询要修改的数据
152             List<T> listModifing = db.Set<T>().Where(whereLambda).ToList();
153 
154             //获取 实体类 类型对象
155             Type t = typeof(T); // model.GetType();
156             //获取 实体类 所有的 公有属性
157             List<PropertyInfo> proInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();
158             //创建 实体属性 字典集合
159             Dictionary<string, PropertyInfo> dictPros = new Dictionary<string, PropertyInfo>();
160             //将 实体属性 中要修改的属性名 添加到 字典集合中 键：属性名  值：属性对象
161             proInfos.ForEach(p =>
162             {
163                 if (modifiedProNames.Contains(p.Name))
164                 {
165                     dictPros.Add(p.Name, p);
166                 }
167             });
168 
169             //4.3循环 要修改的属性名
170             foreach (string proName in modifiedProNames)
171             {
172                 //判断 要修改的属性名是否在 实体类的属性集合中存在
173                 if (dictPros.ContainsKey(proName))
174                 {
175                     //如果存在，则取出要修改的 属性对象
176                     PropertyInfo proInfo = dictPros[proName];
177                     //取出 要修改的值
178                     object newValue = proInfo.GetValue(model, null); //object newValue = model.uName;
179 
180                     //4.4批量设置 要修改 对象的 属性
181                     foreach (T usrO in listModifing)
182                     {
183                         //为 要修改的对象 的 要修改的属性 设置新的值
184                         proInfo.SetValue(usrO, newValue, null); //usrO.uName = newValue;
185                     }
186                 }
187             }
188         } 
189         #endregion
190 
191         #region 3.1.1批量修改并保存 + int ModifyByAndSave(T model, Expression<Func<T, bool>> whereLambda, params string[] modifiedProNames)
192         /// <summary>
193         /// 批量修改并保存
194         /// </summary>
195         /// <param name="model">要修改的实体对象</param>
196         /// <param name="whereLambda">查询条件</param>
197         /// <param name="proNames">要修改的 属性 名称</param>
198         /// <returns>受影响的行数</returns>
199         protected int ModifyByAndSave(T model, Expression<Func<T, bool>> whereLambda, params string[] modifiedProNames)
200         {
201             ModifyBy(model, whereLambda, modifiedProNames);
202             return db.SaveChanges();
203         } 
204         #endregion
205 
206         #region 4.0根据条件获取记录条数 + int GetCountBy(Expression<Func<T, bool>> whereLambda)
207         /// <summary>
208         /// 根据条件获取记录条数
209         /// </summary>
210         /// <returns>总记录条数</returns>
211         protected int GetCountBy(Expression<Func<T, bool>> whereLambda)
212         {
213             return db.Set<T>().Where(whereLambda).Count();
214         } 
215         #endregion
216 
217         #region 5.0获取所有记录 + List<T> GetAllList()
218         /// <summary>
219         /// 获取所有记录
220         /// </summary>
221         /// <returns>返回的集合</returns>
222         protected List<T> GetAllList()
223         {
224             return db.Set<T>().ToList();
225         } 
226         #endregion
227 
228         #region 5.1根据条件查询 + List<T> GetListBy(Expression<Func<T, bool>> whereLambda)
229         /// <summary>
230         /// 根据条件查询
231         /// </summary>
232         /// <param name="whereLambda">条件Lambda表达式</param>
233         /// <returns>返回的集合</returns>
234         protected List<T> GetListBy(Expression<Func<T, bool>> whereLambda)
235         {
236             return db.Set<T>().Where(whereLambda).ToList();
237         } 
238         #endregion
239 
240         #region 5.2根据条件 排序 和查询 + List<T> GetListBy<TKey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool IsDes = false)
241         /// <summary>
242         /// 根据条件 排序 和查询
243         /// </summary>
244         /// <typeparam name="TKey">排序字段类型</typeparam>
245         /// <param name="whereLambda">查询条件 lambda表达式</param>
246         /// <param name="orderLambda">排序条件 lambda表达式</param>
247         /// // <param name="IsDes">是否逆序</param>
248         /// <returns>返回的集合</returns>
249         protected List<T> GetListBy<TKey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool IsDes = false)
250         {
251             if(IsDes)
252                 return db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda).ToList();
253             return db.Set<T>().Where(whereLambda).OrderBy(orderLambda).ToList();
254         } 
255         #endregion
256 
257         #region 5.3分页查询 + List<T> GetPagedList<TKey>(int pageIndex, int pageSize, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderBy, bool IsDes = false)
258         /// <summary>
259         /// 分页查询
260         /// </summary>
261         /// <param name="pageIndex">页码</param>
262         /// <param name="pageSize">页容量</param>
263         /// <param name="whereLambda">条件 lambda表达式</param>
264         /// <param name="orderBy">排序 lambda表达式</param>
265         /// <param name="IsDes">是否逆序</param>
266         /// <returns>返回的集合</returns>
267         protected List<T> GetPagedList<TKey>(int pageIndex, int pageSize, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderBy, bool IsDes = false)
268         {
269             if (IsDes)
270                 return db.Set<T>().Where(whereLambda).OrderByDescending(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
271             return db.Set<T>().Where(whereLambda).OrderBy(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
272         } 
273         #endregion
274 
275     }
276 }