首页 > > 程序设计 > delphi >

EntityFreamWork 项目总结

2018-06-17 19:27:32来源：未知阅读 ()

　　前段时间一直在忙着处理一个B2C的商城项目，未来得整理这次项目的心得，今天偶有空闲便写下这篇文章以记录整个项目的设计及自我总结。

这个项目是我综合传智播客教学基础将传统三层架构与EntityFramework进行整合，其中如有不对之处，还望各位高手指点。

　　 一、项目结构:经典三层+EF

　　首先，先说说整个项目的结构。该项目使用 Visual Studio2013+EF4.4 来进行开发，可能有同学会说，EF6都出来了，为什么还使用4.4版本？

　　　　原因一、.net4.0只支持到4.4版本，
　　　　原因二、windows 2003 只支持到 .net 4.0

　　该项目整体结构如图所示，

　　API:主要用于支持第三方扩展，比如支付和登录。

　　BLL层:业务逻辑处理层。

　　Common:公用方法封装。

　　DAL层:数据访问层。

　　DBSessionFactory:数据访问会话层，主要用于DAL和数据库之间的连接。

　　DBUtility:常规三层中ADO.Net 方式与数据库的连接。

　　Interface:封装了BLL调用DAL中的IBLL接口，及DAL中方法调用DBSession时其中的基本的CURD的方法的接口。

　　Web.UI:表现层与业务逻辑层之间调用方法的封装。

　　Web:表现层。数据来源于UI及BLL层中。

　　二、数据库主要结构　　

　　
　　主要表结构设计为：订单模块、会员模块、商品模块、文章模块、后台管理模块和其他一些表的设计。

　　三、各个模块的功能介绍

　　　　1.DBSessionFactory模块。

　　　　DBsession主要用于数据库的交互，进行保存数据或者查询数据。

 1 　　 /// <summary>
 2     /// 封装的数据操作类
 3     /// </summary>
 4     public partial class DBSession
 5     {
 6         /// <summary>
 7         /// EF上下文对象，由工厂创建
 8         /// </summary>
 9         DbContext dbContext=TDB2C.DbContextFacory.DbContextFactory.GetDbContext();
10         /// <summary>
11         /// 执行特殊SQL语句或存储过程
12         /// </summary>
13         /// <param name="sql">Sql语句或存储过程</param>
14         /// <param name="parameters">参数数组</param>
15         /// <returns>返回影响行数</returns>
16         public int ExecutNoneQuery(string sql, SqlParameter[] parameters)
17         {
18             return dbContext.Database.ExecuteSqlCommand(sql, parameters);
19         }
20         /// <summary>
21         /// 执行SQL语句，返回指定类型的对象集合
22         /// </summary>
23         /// <typeparam name="T"></typeparam>
24         /// <param name="sql"></param>
25         /// <param name="parameters"></param>
26         /// <returns></returns>
27         public List<T> ExecutDataTable<T>(string sql, SqlParameter[] parameters)
28         {
29             return dbContext.Database.SqlQuery<T>(sql, parameters).ToList();
30         }
31         /// <summary>
32         /// 将所有操作一次性保存会数据库，避免频繁连接和操作数据库
33         /// </summary>
34         /// <returns></returns>
35         public int SaveChanges()
36         {
37             try
38             {
39                 return dbContext.SaveChanges();
40             }
41             catch(Exception ex)
42             {
43                 TDB2C.Common.LogHelper.LogFatal(ex.Message, ex);
44                 throw ex;
45             }
46         }
47     }

　　　　AbstructFacotry.tt 主要用于反射出 DAL对象与DBSession层之间的 IDAL 对象。

　　2.Interface中两个接口。

　　IDAL 接口: 将数据库中的常用方法进行抽象。具体实现交给DAL层来完成。

  1  public interface IBaseDAL<T> where T:class,new()
  2     {
  3         /// <summary>
  4         /// 根据条件，获取当个对象，带排序
  5         /// </summary>
  6         T LoadEntity(Expression<Func<T, bool>> whereLambda, params OrderModelField[] orderByExpression);
  7         /// <summary>
  8         /// 获取满足条件的所有数据
  9         /// </summary>
 10         IQueryable<T> LoadEntities(Expression<Func<T, bool>> whereLambda, params OrderModelField[] orderByExpression);
 11         /// <summary>
 12         /// 获取前几条数据，根据条件，排序条件，数量
 13         /// </summary>
 14         IQueryable<T> LoadEntities(int top, Expression<Func<T, bool>> whereLambda, params OrderModelField[] orderByExpression);
 15         /// <summary>
 16         /// 获取分页数据，根据过滤条件，排序条件，页码，页容量，
 17         /// </summary>
 18         IQueryable<T> LoadEntities(int pageIndex, int pageSize, out int totalCount, Expression<Func<T, bool>> whereLambda, params OrderModelField[] orderByExpression);
 19         /// <summary>
 20         /// 增加新实体
 21         /// </summary>
 22         T AddEntity(T entity);
 23         /// <summary>
 24         /// 删除该实体
 25         /// </summary>
 26         void DeleteEntity(T entity);
 27         /// <summary>
 28         /// 修改实体
 29         /// </summary>
 30         void UpdateEntity(T entity);
 31 
 32         #region 聚合函数
 33         /// <summary>
 34         /// 统计合计,若统计字段中包含null值，则不计入运算结果
 35         /// </summary>
 36         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
 37         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
 38         /// <returns>返回合计值</returns>
 39         int? GetSum(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int?>> fieldLambda);
 40         /// <summary>
 41         /// 统计合计,若统计字段中包含null值，则不计入运算结果
 42         /// </summary>
 43         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
 44         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
 45         /// <returns>返回合计值</returns>
 46         decimal? GetSum(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal?>> fieldLambda);
 47         /// <summary>
 48         /// 获得最大值,若统计字段中包含null值，则不计入运算结果
 49         /// </summary>
 50         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
 51         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
 52         /// <returns>返回最大值</returns>
 53         int? GetMax(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int?>> fieldLambda);
 54         /// <summary>
 55         /// 获得最大值,若统计字段中包含null值，则不计入运算结果
 56         /// </summary>
 57         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
 58         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
 59         /// <returns>返回最大值</returns>
 60         decimal? GetMax(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal?>> fieldLambda);
 61         /// <summary>
 62         /// 获得最小值,若统计字段中包含null值，则不计入运算结果
 63         /// </summary>
 64         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
 65         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
 66         /// <returns>返回最小值</returns>
 67         int? GetMin(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int?>> fieldLambda);
 68         /// <summary>
 69         /// 获得最小值,若统计字段中包含null值，则不计入运算结果
 70         /// </summary>
 71         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
 72         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
 73         /// <returns>返回最小值</returns>
 74         decimal? GetMin(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal?>> fieldLambda);
 75         /// <summary>
 76         /// 获得平均值,若统计字段中包含null值，则不计入运算结果
 77         /// </summary>
 78         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
 79         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
 80         /// <returns>返回平均值</returns>
 81         int? GetAverage(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int?>> fieldLambda);
 82         /// <summary>
 83         /// 获得平均值,若统计字段中包含null值，则不计入运算结果
 84         /// </summary>
 85         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
 86         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
 87         /// <returns>返回平均值</returns>
 88         decimal? GetAverage(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal?>> fieldLambda);
 89 
 90 
 91 
 92         /// <summary>
 93         /// 统计合计,若统计字段中包含null值，则抛异常
 94         /// </summary>
 95         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
 96         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
 97         /// <returns>返回合计值</returns>
 98         int GetSum(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int>> fieldLambda);
 99         /// <summary>
100         /// 统计合计,若统计字段中包含null值，则抛异常
101         /// </summary>
102         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
103         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
104         /// <returns>返回合计值</returns>
105         decimal GetSum(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal>> fieldLambda);
106         /// <summary>
107         /// 获得最大值,若统计字段中包含null值，则抛异常
108         /// </summary>
109         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
110         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
111         /// <returns>返回最大值</returns>
112         int GetMax(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int>> fieldLambda);
113         /// <summary>
114         /// 获得最大值,若统计字段中包含null值，则抛异常
115         /// </summary>
116         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
117         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
118         /// <returns>返回最大值</returns>
119         decimal GetMax(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal>> fieldLambda);
120         /// <summary>
121         /// 获得最小值,若统计字段中包含null值，则抛异常
122         /// </summary>
123         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
124         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
125         /// <returns>返回最小值</returns>
126         int GetMin(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int>> fieldLambda);
127         /// <summary>
128         /// 获得最小值,若统计字段中包含null值，则抛异常
129         /// </summary>
130         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
131         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
132         /// <returns>返回最小值</returns>
133         decimal GetMin(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal>> fieldLambda);
134         /// <summary>
135         /// 获得平均值,若统计字段中包含null值，则抛异常
136         /// </summary>
137         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
138         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
139         /// <returns>返回平均值</returns>
140         int GetAverage(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int>> fieldLambda);
141         /// <summary>
142         /// 获得平均值,若统计字段中包含null值，则抛异常
143         /// </summary>
144         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
145         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
146         /// <returns>返回平均值</returns>
147         decimal GetAverage(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal>> fieldLambda);
148 
149 
150 
151 
152         /// <summary>
153         /// 获得指定条件统计结果
154         /// </summary>
155         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
156         /// <returns></returns>
157         int GetCount(Expression<Func<T, bool>> whereLambda);
158 
159         #endregion
160 
161         /// <summary>
162         /// 查找是否存在
163         /// </summary>
164         bool ExistsEntity(Expression<Func<T, bool>> whereLabmda);
165         /// <summary>
166         /// 查找是否存在
167         /// </summary>
168         bool ExistsEntity(int id);
169     }

View Code

　　IBLL接口: 将IDAL中的方法进行扩充，然后交给BLL中去具体实现。

  1     /// <summary>
  2     /// 业务逻辑接口层（Business Logic Layer InterFace）,供表现层和业务逻辑层使用
  3     /// </summary>
  4     /// <typeparam name="T"></typeparam>
  5     public interface IBaseBLL<T> where T:class,new()
  6     {
  7 
  8         /// <summary>
  9         /// 获取指定对象,根据主键Id 
 10         /// </summary>
 11         /// <param name="id">主键</param>
 12         /// <returns>获取到的对象,不存在则为Null</returns>
 13         T LoadEntity(int id);
 14         /// <summary>
 15         /// 获取指定对象,根据过滤条件字符串
 16         /// </summary>
 17         /// <param name="strWhere">过滤条件 where条件字符串</param>
 18         /// <returns>获取到的对象,不存在则为Null</returns>
 19         T LoadEntity(string strWhere);
 20         /// <summary>
 21         /// 获取指定对象,根据过滤条件字符串,带排序
 22         /// </summary>
 23         /// <param name="strWhere">过滤条件 where条件字符串</param>
 24         /// <param name="fieldOrder">排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者""</param>
 25         /// <returns>获取到的对象,不存在则为Null</returns>
 26         T LoadEntity(string strWhere, string fieldOrder);
 27         /// <summary>
 28         /// 获取指定对象,根据过滤条件Lambda表达式
 29         /// </summary>
 30         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
 31         /// <returns>获取到的对象,不存在则为Null</returns>
 32         T LoadEntity(Expression<Func<T, bool>> whereLambda);
 33         /// <summary>
 34         /// 获取指定对象,根据过滤条件Lambda表达式,带排序
 35         /// </summary>
 36         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
 37         /// <param name="fieldOrder">排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者""</param>
 38         /// <returns>获取到的对象,不存在则为Null</returns>
 39         T LoadEntity(Expression<Func<T, bool>> whereLambda, string fieldOrder);
 40 
 41         /// <summary>
 42         /// 获取对象集合,根据过滤条件字符串
 43         /// </summary>
 44         /// <param name="strWhere">过滤条件 where条件字符串</param>
 45         /// <returns>获取到的对象集合,不存在则为new List()</returns>
 46         List<T> LoadEntities(string strWhere);
 47         /// <summary>
 48         /// 获取对象集合,根据过滤条件字符串,带排序
 49         /// </summary>
 50         /// <param name="strWhere">过滤条件 where条件字符串</param>
 51         /// <param name="fieldOrder">排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者""</param>
 52         /// <returns>获取到的对象集合,不存在则为new List()</returns>
 53         List<T> LoadEntities(string strWhere, string fieldOrder);
 54 
 55         /// <summary>
 56         /// 获取对象集合,根据过滤条件Lambda表达式
 57         /// </summary>
 58         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
 59         /// <returns>获取到的对象集合,不存在则为new List()</returns>
 60         List<T> LoadEntities(Expression<Func<T, bool>> whereLambda);
 61         /// <summary>
 62         /// 获取对象集合,根据过滤条件Lambda表达式,带排序
 63         /// </summary>
 64         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
 65         /// <param name="fieldOrder">排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者""</param>
 66         /// <returns>获取到的对象集合,不存在则为new List()</returns>
 67         List<T> LoadEntities(Expression<Func<T, bool>> whereLambda, string fieldOrder);
 68 
 69         /// <summary>
 70         /// 获取前几条对象集合,根据过滤条件字符串
 71         /// </summary>
 72         /// <param name="top">指定记录数</param>
 73         /// <param name="strWhere">过滤条件 where条件字符串</param>
 74         /// <returns>获取到的对象集合,不存在则为new List()</returns>
 75         List<T> LoadEntities(int top, string strWhere);
 76         /// <summary>
 77         /// 获取前几条对象集合,根据过滤条件字符串,带排序
 78         /// </summary>
 79         /// <param name="top">指定记录数</param>
 80         /// <param name="strWhere">过滤条件 where条件字符串</param>
 81         /// <param name="fieldOrder">排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者""</param>
 82         /// <returns>获取到的对象集合,不存在则为new List()</returns>
 83         List<T> LoadEntities(int top, string strWhere, string fieldOrder);
 84 
 85         /// <summary>
 86         /// 获取前几条对象集合,根据过滤条件Lambda表达式
 87         /// </summary>
 88         /// <param name="top">指定记录数</param>
 89         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
 90         /// <returns>获取到的对象集合,不存在则为new List()</returns>
 91         List<T> LoadEntities(int top, Expression<Func<T, bool>> whereLambda);
 92         /// <summary>
 93         /// 获取前几条对象集合,根据过滤条件Lambda表达式,带排序
 94         /// </summary>
 95         /// <param name="top">指定记录数</param>
 96         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
 97         /// <param name="fieldOrder">排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者""</param>
 98         /// <returns>获取到的对象集合,不存在则为new List()</returns>
 99         List<T> LoadEntities(int top, Expression<Func<T, bool>> whereLambda, string fieldOrder);
100 
101         /// <summary>
102         /// 获取分页对象集合,根据过滤条件字符串
103         /// </summary>
104         /// <param name="pageIndex">当前页码</param>
105         /// <param name="pageSize">页容量</param>
106         /// <param name="totalCount">总记录数</param>
107         /// <param name="strWhere">过滤条件 where条件字符串</param>
108         /// <returns>获取到的对象集合,不存在则为new List()</returns>
109         List<T> LoadEntities(int pageIndex, int pageSize, out int totalCount, string strWhere);
110         /// <summary>
111         /// 获取分页对象集合,根据过滤条件字符串，带排序
112         /// </summary>
113         /// <param name="pageIndex">当前页码</param>
114         /// <param name="pageSize">页容量</param>
115         /// <param name="totalCount">总记录数</param>
116         /// <param name="strWhere">过滤条件 where条件字符串</param>
117         /// <param name="fieldOrder">排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者""</param>
118         /// <returns>获取到的对象集合,不存在则为new List()</returns>
119         List<T> LoadEntities(int pageIndex, int pageSize, out int totalCount, string strWhere, string fieldOrder);
120 
121         /// <summary>
122         /// 获取分页对象集合,根据过滤条件Lambda表达式
123         /// </summary>
124         /// <param name="pageIndex">当前页码</param>
125         /// <param name="pageSize">页容量</param>
126         /// <param name="totalCount">总记录数</param>
127         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
128         /// <returns>获取到的对象集合,不存在则为new List()</returns>
129         List<T> LoadEntities(int pageIndex, int pageSize, out int totalCount, Expression<Func<T, bool>> whereLambda);
130         /// <summary>
131         /// 获取分页对象集合,根据过滤条件Lambda表达式，带排序
132         /// </summary>
133         /// <param name="pageIndex">当前页码</param>
134         /// <param name="pageSize">页容量</param>
135         /// <param name="totalCount">总记录数</param>
136         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
137         /// <param name="fieldOrder">排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者""</param>
138         /// <returns>获取到的对象集合,不存在则为new List()</returns>
139         List<T> LoadEntities(int pageIndex, int pageSize, out int totalCount, Expression<Func<T, bool>> whereLambda, string fieldOrder);
140 
141 
142         /// <summary>
143         /// 添加新实体，返回刚添加的实体
144         /// </summary>
145         /// <param name="entity">要添加的实体</param>
146         /// <returns>返回的添加成功后的实体</returns>
147         T AddEntity(T entity);
148         /// <summary>
149         /// 添加实体，返回添加成功的实体及成功数量
150         /// </summary>
151         /// <param name="entity">要添加的实体</param>
152         /// <param name="changes">成功记录数</param>
153         /// <returns>返回添加成功后的实体</returns>
154         T AddEntity(T entity, out int changes);
155         /// <summary>
156         /// 添加实体，返回添加成功的数量
157         /// </summary>
158         /// <param name="entity">要添加的实体</param>
159         /// <returns>添加成功的数量</returns>
160         int AddEntityChanges(T entity);
161 
162         /// <summary>
163         /// 更新实体，返回是否成功
164         /// </summary>
165         /// <param name="entity">要更新的实体</param>
166         /// <returns>成功状态 true为成功,false为失败</returns>
167         bool UpdateEntity(T entity);
168 
169         /// <summary>
170         /// 查找是否存在
171         /// </summary>
172         /// <param name="whereLabmda">过滤条件 Lambda表达式</param>
173         /// <returns>存在状态 true为存在,false为不存在</returns>
174         bool ExistsEntity(Expression<Func<T, bool>> whereLabmda);
175         /// <summary>
176         /// 查找是否存在
177         /// </summary>
178         /// <param name="strWhere">过滤条件 where条件字符串</param>
179         /// <returns>存在状态 true为存在,false为不存在</returns>
180         bool ExistsEntity(string strWhere);
181         /// <summary>
182         /// 查找是否存在
183         /// </summary>
184         /// <param name="id">对象主键Id</param>
185         /// <returns>存在状态 true为存在,false为不存在</returns>
186         bool ExistsEntity(int id);
187 
188         /// <summary>
189         /// 修改指定对象的（一个或多个）字段值
190         /// </summary>
191         /// <param name="id">主键Id</param>
192         /// <param name="strValue">字段值，格式必须为"key=value"或"key1=value1&&key2=value2&&...&&keyN=valueN"</param>
193         /// <returns>返回成功状态 true为成功,false为失败</returns>
194         bool UpdateFieldsEntity(int id, string strValue);
195         /// <summary>
196         /// 修改满足条件的所有对象的（一个或多个）字段值
197         /// </summary>
198         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
199         /// <param name="strValue">字段值，格式必须为"key=value"或"key1=value1&&key2=value2&&...&&keyN=valueN"</param>
200         /// <returns>返回成功状态 true为成功,false为失败</returns>
201         bool UpdateFieldsEntity(Expression<Func<T, bool>> whereLambda, string strValue);
202         /// <summary>
203         /// 根据条件，修改满足条件的所以的对象的（一个或多个）字段值
204         /// </summary>
205         /// <param name="strWhere">过滤条件 where条件字符串</param>
206         /// <param name="strValue">字段值，格式必须为"key=value"或"key1=value1&&key2=value2&&...&&keyN=valueN"</param>
207         /// <returns>返回成功状态 true为成功,false为失败</returns>
208         bool UpdateFieldsEntity(string strWhere, string strValue);
209 
210         /// <summary>
211         /// 软删除实体
212         /// </summary>
213         /// <param name="id">主键Id</param>
214         /// <returns>返回成功状态 true为成功,false为失败</returns>
215         bool DeleteSoftEntity(int id);
216         /// <summary>
217         /// 软删除实体，删除满足Lambda条件的实体对象
218         /// </summary>
219         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
220         /// <returns>返回成功状态 true为成功,false为失败</returns>
221         bool DeleteSoftEntity(Expression<Func<T, bool>> whereLambda);
222         /// <summary>
223         /// 软删除实体，删除满足条件的实体对象
224         /// </summary>
225         /// <param name="strWhere">过滤条件 where条件字符串</param>
226         /// <returns>返回成功状态 true为成功,false为失败</returns>
227         bool DeleteSoftEntity(string strWhere);
228 
229         /// <summary>
230         /// 真删除实体
231         /// </summary>
232         /// <param name="id">主键Id</param>
233         /// <returns>返回成功状态 true为成功,false为失败</returns>
234         bool DeleteEntity(int id);
235         /// <summary>
236         /// 真删除实体，删除满足Lambda条件的实体对象
237         /// </summary>
238         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
239         /// <returns>返回成功状态 true为成功,false为失败</returns>
240         bool DeleteEntity(Expression<Func<T, bool>> whereLambda);
241         /// <summary>
242         /// 真删除实体，返回是否成功
243         /// </summary>
244         /// <param name="entity">要删除的实体</param>
245         /// <returns>成功状态 true为成功,false为失败</returns>
246         bool DeleteEntity(T entity);
247         /// <summary>
248         /// 真删除实体，返回是否成功
249         /// </summary>
250         /// <param name="strWhere">过滤条件 where条件字符串</param>
251         /// <returns>成功状态 true为成功,false为失败</returns>
252         bool DeleteEntity(string strWhere);
253         #region 聚合函数
254 
255         /// <summary>
256         /// 统计合计,若统计字段中包含null值，则不计入运算结果
257         /// </summary>
258         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
259         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
260         /// <returns>返回合计值</returns>
261         int? GetSum(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int?>> fieldLambda);
262         /// <summary>
263         /// 统计合计,若统计字段中包含null值，则不计入运算结果
264         /// </summary>
265         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
266         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
267         /// <returns>返回合计值</returns>
268         decimal? GetSum(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal?>> fieldLambda);
269         /// <summary>
270         /// 获得最大值,若统计字段中包含null值，则不计入运算结果
271         /// </summary>
272         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
273         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
274         /// <returns>返回最大值</returns>
275         int? GetMax(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int?>> fieldLambda);
276         /// <summary>
277         /// 获得最大值,若统计字段中包含null值，则不计入运算结果
278         /// </summary>
279         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
280         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
281         /// <returns>返回最大值</returns>
282         decimal? GetMax(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal?>> fieldLambda);
283         /// <summary>
284         /// 获得最小值,若统计字段中包含null值，则不计入运算结果
285         /// </summary>
286         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
287         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
288         /// <returns>返回最小值</returns>
289         int? GetMin(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int?>> fieldLambda);
290         /// <summary>
291         /// 获得最小值,若统计字段中包含null值，则不计入运算结果
292         /// </summary>
293         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
294         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
295         /// <returns>返回最小值</returns>
296         decimal? GetMin(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal?>> fieldLambda);
297         /// <summary>
298         /// 获得平均值,若统计字段中包含null值，则不计入运算结果
299         /// </summary>
300         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
301         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
302         /// <returns>返回平均值</returns>
303         int? GetAverage(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int?>> fieldLambda);
304         /// <summary>
305         /// 获得平均值,若统计字段中包含null值，则不计入运算结果
306         /// </summary>
307         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
308         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
309         /// <returns>返回平均值</returns>
310         decimal? GetAverage(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal?>> fieldLambda);
311 
312 
313         /// <summary>
314         /// 统计合计,若统计字段中包含null值，则抛异常
315         /// </summary>
316         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
317         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
318         /// <returns>返回合计值</returns>
319         int GetSum(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int>> fieldLambda);
320         /// <summary>
321         /// 统计合计,若统计字段中包含null值，则抛异常
322         /// </summary>
323         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
324         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
325         /// <returns>返回合计值</returns>
326         decimal GetSum(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal>> fieldLambda);
327         /// <summary>
328         /// 获得最大值,若统计字段中包含null值，则抛异常
329         /// </summary>
330         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
331         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
332         /// <returns>返回最大值</returns>
333         int GetMax(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int>> fieldLambda);
334         /// <summary>
335         /// 获得最大值,若统计字段中包含null值，则抛异常
336         /// </summary>
337         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
338         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
339         /// <returns>返回最大值</returns>
340         decimal GetMax(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal>> fieldLambda);
341         /// <summary>
342         /// 获得最小值,若统计字段中包含null值，则抛异常
343         /// </summary>
344         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
345         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
346         /// <returns>返回最小值</returns>
347         int GetMin(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int>> fieldLambda);
348         /// <summary>
349         /// 获得最小值,若统计字段中包含null值，则抛异常
350         /// </summary>
351         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
352         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
353         /// <returns>返回最小值</returns>
354         decimal GetMin(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal>> fieldLambda);
355         /// <summary>
356         /// 获得平均值,若统计字段中包含null值，则抛异常
357         /// </summary>
358         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
359         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
360         /// <returns>返回平均值</returns>
361         int GetAverage(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int>> fieldLambda);
362         /// <summary>
363         /// 获得平均值,若统计字段中包含null值，则抛异常
364         /// </summary>
365         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
366         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
367         /// <returns>返回平均值</returns>
368         decimal GetAverage(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal>> fieldLambda);
369         /// <summary>
370         /// 根据条件获得记录数
371         /// </summary>
372         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
373         /// <returns>记录数</returns>
374         int GetCount(Expression<Func<T, bool>> whereLambda);
375         /// <summary>
376         /// 根据条件获得记录数
377         /// </summary>
378         /// <param name="strWhere">过滤条件 where字符串</param>
379         /// <returns>记录数</returns>
380         int GetCount(string strWhere);
381         #endregion
382     }

View Code

　　3.DAL层

　　DAL层中，定义了泛型约束的基类，所有的Model 继承BaseDAL，里面显示实现了所有的IDAL，具体实现就不贴出来了。

1 public class BaseDAL<T> where T:class,new()
2 {
3 　　//代码的具体实现...
4 }

　　4.同样的BLL层中也是定义相同的泛型约束基类，所有的Model继承BaseBLL，显示实现所有IBLL中定义的方法。

1 public class BaseBLL<T> where T:class,new()
2 {
3  　//代码的具体实现...
4 }

　　四、总结

　　这次的项目EntityFrameWork的使用方式依然是 DBFirst模式，在数据库中建立表结构之后，生成对应的Model，这里我将原始的T4文件进行了修改，支持将数据库中表名称，字段备注说明，一并生成到Model中，如：

 1     /// <summary>
 2     /// 商品评论参数 标签表
 3     /// </summary>
 4     [Serializable]
 5     public partial class Product_comment_merit:IModel
 6     {
 7        public Product_comment_merit()
 8         {
 9             this.Id=0;
10                    this.Product_category_ids="";
11                    this.Title="";
12                    this.Sort_id=0;
13                    this.Add_time=DateTime.Now;
14                    this.Is_del=0;
15                }
16     
17         /// <summary>
18         /// 主键Id
19         /// </summary>
20         public int Id { get; set; }
21         /// <summary>
22         /// 所属分类
23         /// </summary>
24         public string Product_category_ids { get; set; }
25         /// <summary>
26         /// 标题
27         /// </summary>
28         public string Title { get; set; }
29         /// <summary>
30         /// 排序
31         /// </summary>
32         public int Sort_id { get; set; }
33         /// <summary>
34         /// 添加时间
35         /// </summary>
36         public DateTime Add_time { get; set; }
37         /// <summary>
38         /// 删除标识
39         /// </summary>
40         public int Is_del { get; set; }
41     }