EntityFreamWork 项目总结

　　前段时间一直在忙着处理一个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主要用于数据库的交互，进行保存数据或者查询数据。

　　

 　　 /// <summary>
     /// 封装的数据操作类
     /// </summary>
     public partial class DBSession
     {
         /// <summary>
         /// EF上下文对象，由工厂创建
         /// </summary>
         DbContext dbContext=TDB2C.DbContextFacory.DbContextFactory.GetDbContext();
         /// <summary>
         /// 执行特殊SQL语句或存储过程
         /// </summary>
         /// <param name="sql">Sql语句或存储过程</param>
         /// <param name="parameters">参数数组</param>
         /// <returns>返回影响行数</returns>
         public int ExecutNoneQuery(string sql, SqlParameter[] parameters)
         {
             return dbContext.Database.ExecuteSqlCommand(sql, parameters);
         }
         /// <summary>
         /// 执行SQL语句，返回指定类型的对象集合
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="sql"></param>
         /// <param name="parameters"></param>
         /// <returns></returns>
         public List<T> ExecutDataTable<T>(string sql, SqlParameter[] parameters)
         {
             return dbContext.Database.SqlQuery<T>(sql, parameters).ToList();
         }
         /// <summary>
         /// 将所有操作一次性保存会数据库，避免频繁连接和操作数据库
         /// </summary>
         /// <returns></returns>
         public int SaveChanges()
         {
             try
             {
                 return dbContext.SaveChanges();
             }
             catch(Exception ex)
             {
                 TDB2C.Common.LogHelper.LogFatal(ex.Message, ex);
                 throw ex;
             }
         }
     }

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

　　2.Interface中两个接口。

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

　　

  public interface IBaseDAL<T> where T:class,new()
     {
         /// <summary>
         /// 根据条件，获取当个对象，带排序
         /// </summary>
         T LoadEntity(Expression<Func<T, bool>> whereLambda, params OrderModelField[] orderByExpression);
         /// <summary>
         /// 获取满足条件的所有数据
         /// </summary>
         IQueryable<T> LoadEntities(Expression<Func<T, bool>> whereLambda, params OrderModelField[] orderByExpression);
         /// <summary>
         /// 获取前几条数据，根据条件，排序条件，数量
         /// </summary>
         IQueryable<T> LoadEntities(int top, Expression<Func<T, bool>> whereLambda, params OrderModelField[] orderByExpression);
         /// <summary>
         /// 获取分页数据，根据过滤条件，排序条件，页码，页容量，
         /// </summary>
         IQueryable<T> LoadEntities(int pageIndex, int pageSize, out int totalCount, Expression<Func<T, bool>> whereLambda, params OrderModelField[] orderByExpression);
         /// <summary>
         /// 增加新实体
         /// </summary>
         T AddEntity(T entity);
         /// <summary>
         /// 删除该实体
         /// </summary>
         void DeleteEntity(T entity);
         /// <summary>
         /// 修改实体
         /// </summary>
         void UpdateEntity(T entity);

         #region 聚合函数
         /// <summary>
         /// 统计合计,若统计字段中包含null值，则不计入运算结果
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回合计值</returns>
         int? GetSum(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int?>> fieldLambda);
         /// <summary>
         /// 统计合计,若统计字段中包含null值，则不计入运算结果
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回合计值</returns>
         decimal? GetSum(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal?>> fieldLambda);
         /// <summary>
         /// 获得最大值,若统计字段中包含null值，则不计入运算结果
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回最大值</returns>
         int? GetMax(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int?>> fieldLambda);
         /// <summary>
         /// 获得最大值,若统计字段中包含null值，则不计入运算结果
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回最大值</returns>
         decimal? GetMax(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal?>> fieldLambda);
         /// <summary>
         /// 获得最小值,若统计字段中包含null值，则不计入运算结果
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回最小值</returns>
         int? GetMin(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int?>> fieldLambda);
         /// <summary>
         /// 获得最小值,若统计字段中包含null值，则不计入运算结果
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回最小值</returns>
         decimal? GetMin(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal?>> fieldLambda);
         /// <summary>
         /// 获得平均值,若统计字段中包含null值，则不计入运算结果
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回平均值</returns>
         int? GetAverage(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int?>> fieldLambda);
         /// <summary>
         /// 获得平均值,若统计字段中包含null值，则不计入运算结果
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回平均值</returns>
         decimal? GetAverage(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal?>> fieldLambda);

         /// <summary>
         /// 统计合计,若统计字段中包含null值，则抛异常
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回合计值</returns>
         int GetSum(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int>> fieldLambda);
         /// <summary>
         /// 统计合计,若统计字段中包含null值，则抛异常
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回合计值</returns>
         decimal GetSum(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal>> fieldLambda);
         /// <summary>
         /// 获得最大值,若统计字段中包含null值，则抛异常
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回最大值</returns>
         int GetMax(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int>> fieldLambda);
         /// <summary>
         /// 获得最大值,若统计字段中包含null值，则抛异常
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回最大值</returns>
         decimal GetMax(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal>> fieldLambda);
         /// <summary>
         /// 获得最小值,若统计字段中包含null值，则抛异常
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回最小值</returns>
         int GetMin(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int>> fieldLambda);
         /// <summary>
         /// 获得最小值,若统计字段中包含null值，则抛异常
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回最小值</returns>
         decimal GetMin(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal>> fieldLambda);
         /// <summary>
         /// 获得平均值,若统计字段中包含null值，则抛异常
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回平均值</returns>
         int GetAverage(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int>> fieldLambda);
         /// <summary>
         /// 获得平均值,若统计字段中包含null值，则抛异常
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回平均值</returns>
         decimal GetAverage(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal>> fieldLambda);

         /// <summary>
         /// 获得指定条件统计结果
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <returns></returns>
         int GetCount(Expression<Func<T, bool>> whereLambda);

         #endregion

         /// <summary>
         /// 查找是否存在
         /// </summary>
         bool ExistsEntity(Expression<Func<T, bool>> whereLabmda);
         /// <summary>
         /// 查找是否存在
         /// </summary>
         bool ExistsEntity(int id);
     }

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

　　

     /// <summary>
     /// 业务逻辑接口层（Business Logic Layer InterFace）,供表现层和业务逻辑层使用
     /// </summary>
     /// <typeparam name="T"></typeparam>
     public interface IBaseBLL<T> where T:class,new()
     {

         /// <summary>
         /// 获取指定对象,根据主键Id
         /// </summary>
         /// <param name="id">主键</param>
         /// <returns>获取到的对象,不存在则为Null</returns>
         T LoadEntity(int id);
         /// <summary>
         /// 获取指定对象,根据过滤条件字符串
         /// </summary>
         /// <param name="strWhere">过滤条件 where条件字符串</param>
         /// <returns>获取到的对象,不存在则为Null</returns>
         T LoadEntity(string strWhere);
         /// <summary>
         /// 获取指定对象,根据过滤条件字符串,带排序
         /// </summary>
         /// <param name="strWhere">过滤条件 where条件字符串</param>
         /// <param name="fieldOrder">排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者""</param>
         /// <returns>获取到的对象,不存在则为Null</returns>
         T LoadEntity(string strWhere, string fieldOrder);
         /// <summary>
         /// 获取指定对象,根据过滤条件Lambda表达式
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <returns>获取到的对象,不存在则为Null</returns>
         T LoadEntity(Expression<Func<T, bool>> whereLambda);
         /// <summary>
         /// 获取指定对象,根据过滤条件Lambda表达式,带排序
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldOrder">排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者""</param>
         /// <returns>获取到的对象,不存在则为Null</returns>
         T LoadEntity(Expression<Func<T, bool>> whereLambda, string fieldOrder);

         /// <summary>
         /// 获取对象集合,根据过滤条件字符串
         /// </summary>
         /// <param name="strWhere">过滤条件 where条件字符串</param>
         /// <returns>获取到的对象集合,不存在则为new List()</returns>
         List<T> LoadEntities(string strWhere);
         /// <summary>
         /// 获取对象集合,根据过滤条件字符串,带排序
         /// </summary>
         /// <param name="strWhere">过滤条件 where条件字符串</param>
         /// <param name="fieldOrder">排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者""</param>
         /// <returns>获取到的对象集合,不存在则为new List()</returns>
         List<T> LoadEntities(string strWhere, string fieldOrder);

         /// <summary>
         /// 获取对象集合,根据过滤条件Lambda表达式
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <returns>获取到的对象集合,不存在则为new List()</returns>
         List<T> LoadEntities(Expression<Func<T, bool>> whereLambda);
         /// <summary>
         /// 获取对象集合,根据过滤条件Lambda表达式,带排序
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldOrder">排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者""</param>
         /// <returns>获取到的对象集合,不存在则为new List()</returns>
         List<T> LoadEntities(Expression<Func<T, bool>> whereLambda, string fieldOrder);

         /// <summary>
         /// 获取前几条对象集合,根据过滤条件字符串
         /// </summary>
         /// <param name="top">指定记录数</param>
         /// <param name="strWhere">过滤条件 where条件字符串</param>
         /// <returns>获取到的对象集合,不存在则为new List()</returns>
         List<T> LoadEntities(int top, string strWhere);
         /// <summary>
         /// 获取前几条对象集合,根据过滤条件字符串,带排序
         /// </summary>
         /// <param name="top">指定记录数</param>
         /// <param name="strWhere">过滤条件 where条件字符串</param>
         /// <param name="fieldOrder">排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者""</param>
         /// <returns>获取到的对象集合,不存在则为new List()</returns>
         List<T> LoadEntities(int top, string strWhere, string fieldOrder);

         /// <summary>
         /// 获取前几条对象集合,根据过滤条件Lambda表达式
         /// </summary>
         /// <param name="top">指定记录数</param>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <returns>获取到的对象集合,不存在则为new List()</returns>
         List<T> LoadEntities(int top, Expression<Func<T, bool>> whereLambda);
         /// <summary>
         /// 获取前几条对象集合,根据过滤条件Lambda表达式,带排序
         /// </summary>
         /// <param name="top">指定记录数</param>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldOrder">排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者""</param>
         /// <returns>获取到的对象集合,不存在则为new List()</returns>
         List<T> LoadEntities(int top, Expression<Func<T, bool>> whereLambda, string fieldOrder);

         /// <summary>
         /// 获取分页对象集合,根据过滤条件字符串
         /// </summary>
         /// <param name="pageIndex">当前页码</param>
         /// <param name="pageSize">页容量</param>
         /// <param name="totalCount">总记录数</param>
         /// <param name="strWhere">过滤条件 where条件字符串</param>
         /// <returns>获取到的对象集合,不存在则为new List()</returns>
         List<T> LoadEntities(int pageIndex, int pageSize, out int totalCount, string strWhere);
         /// <summary>
         /// 获取分页对象集合,根据过滤条件字符串，带排序
         /// </summary>
         /// <param name="pageIndex">当前页码</param>
         /// <param name="pageSize">页容量</param>
         /// <param name="totalCount">总记录数</param>
         /// <param name="strWhere">过滤条件 where条件字符串</param>
         /// <param name="fieldOrder">排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者""</param>
         /// <returns>获取到的对象集合,不存在则为new List()</returns>
         List<T> LoadEntities(int pageIndex, int pageSize, out int totalCount, string strWhere, string fieldOrder);

         /// <summary>
         /// 获取分页对象集合,根据过滤条件Lambda表达式
         /// </summary>
         /// <param name="pageIndex">当前页码</param>
         /// <param name="pageSize">页容量</param>
         /// <param name="totalCount">总记录数</param>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <returns>获取到的对象集合,不存在则为new List()</returns>
         List<T> LoadEntities(int pageIndex, int pageSize, out int totalCount, Expression<Func<T, bool>> whereLambda);
         /// <summary>
         /// 获取分页对象集合,根据过滤条件Lambda表达式，带排序
         /// </summary>
         /// <param name="pageIndex">当前页码</param>
         /// <param name="pageSize">页容量</param>
         /// <param name="totalCount">总记录数</param>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldOrder">排序字符串 格式为:"id desc" 或者 "sort_id asc,add_time desc,....,id asc" 或者""</param>
         /// <returns>获取到的对象集合,不存在则为new List()</returns>
         List<T> LoadEntities(int pageIndex, int pageSize, out int totalCount, Expression<Func<T, bool>> whereLambda, string fieldOrder);

         /// <summary>
         /// 添加新实体，返回刚添加的实体
         /// </summary>
         /// <param name="entity">要添加的实体</param>
         /// <returns>返回的添加成功后的实体</returns>
         T AddEntity(T entity);
         /// <summary>
         /// 添加实体，返回添加成功的实体及成功数量
         /// </summary>
         /// <param name="entity">要添加的实体</param>
         /// <param name="changes">成功记录数</param>
         /// <returns>返回添加成功后的实体</returns>
         T AddEntity(T entity, out int changes);
         /// <summary>
         /// 添加实体，返回添加成功的数量
         /// </summary>
         /// <param name="entity">要添加的实体</param>
         /// <returns>添加成功的数量</returns>
         int AddEntityChanges(T entity);

         /// <summary>
         /// 更新实体，返回是否成功
         /// </summary>
         /// <param name="entity">要更新的实体</param>
         /// <returns>成功状态 true为成功,false为失败</returns>
         bool UpdateEntity(T entity);

         /// <summary>
         /// 查找是否存在
         /// </summary>
         /// <param name="whereLabmda">过滤条件 Lambda表达式</param>
         /// <returns>存在状态 true为存在,false为不存在</returns>
         bool ExistsEntity(Expression<Func<T, bool>> whereLabmda);
         /// <summary>
         /// 查找是否存在
         /// </summary>
         /// <param name="strWhere">过滤条件 where条件字符串</param>
         /// <returns>存在状态 true为存在,false为不存在</returns>
         bool ExistsEntity(string strWhere);
         /// <summary>
         /// 查找是否存在
         /// </summary>
         /// <param name="id">对象主键Id</param>
         /// <returns>存在状态 true为存在,false为不存在</returns>
         bool ExistsEntity(int id);

         /// <summary>
         /// 修改指定对象的（一个或多个）字段值
         /// </summary>
         /// <param name="id">主键Id</param>
         /// <param name="strValue">字段值，格式必须为"key=value"或"key1=value1&&key2=value2&&...&&keyN=valueN"</param>
         /// <returns>返回成功状态 true为成功,false为失败</returns>
         bool UpdateFieldsEntity(int id, string strValue);
         /// <summary>
         /// 修改满足条件的所有对象的（一个或多个）字段值
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="strValue">字段值，格式必须为"key=value"或"key1=value1&&key2=value2&&...&&keyN=valueN"</param>
         /// <returns>返回成功状态 true为成功,false为失败</returns>
         bool UpdateFieldsEntity(Expression<Func<T, bool>> whereLambda, string strValue);
         /// <summary>
         /// 根据条件，修改满足条件的所以的对象的（一个或多个）字段值
         /// </summary>
         /// <param name="strWhere">过滤条件 where条件字符串</param>
         /// <param name="strValue">字段值，格式必须为"key=value"或"key1=value1&&key2=value2&&...&&keyN=valueN"</param>
         /// <returns>返回成功状态 true为成功,false为失败</returns>
         bool UpdateFieldsEntity(string strWhere, string strValue);

         /// <summary>
         /// 软删除实体
         /// </summary>
         /// <param name="id">主键Id</param>
         /// <returns>返回成功状态 true为成功,false为失败</returns>
         bool DeleteSoftEntity(int id);
         /// <summary>
         /// 软删除实体，删除满足Lambda条件的实体对象
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <returns>返回成功状态 true为成功,false为失败</returns>
         bool DeleteSoftEntity(Expression<Func<T, bool>> whereLambda);
         /// <summary>
         /// 软删除实体，删除满足条件的实体对象
         /// </summary>
         /// <param name="strWhere">过滤条件 where条件字符串</param>
         /// <returns>返回成功状态 true为成功,false为失败</returns>
         bool DeleteSoftEntity(string strWhere);

         /// <summary>
         /// 真删除实体
         /// </summary>
         /// <param name="id">主键Id</param>
         /// <returns>返回成功状态 true为成功,false为失败</returns>
         bool DeleteEntity(int id);
         /// <summary>
         /// 真删除实体，删除满足Lambda条件的实体对象
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <returns>返回成功状态 true为成功,false为失败</returns>
         bool DeleteEntity(Expression<Func<T, bool>> whereLambda);
         /// <summary>
         /// 真删除实体，返回是否成功
         /// </summary>
         /// <param name="entity">要删除的实体</param>
         /// <returns>成功状态 true为成功,false为失败</returns>
         bool DeleteEntity(T entity);
         /// <summary>
         /// 真删除实体，返回是否成功
         /// </summary>
         /// <param name="strWhere">过滤条件 where条件字符串</param>
         /// <returns>成功状态 true为成功,false为失败</returns>
         bool DeleteEntity(string strWhere);
         #region 聚合函数

         /// <summary>
         /// 统计合计,若统计字段中包含null值，则不计入运算结果
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回合计值</returns>
         int? GetSum(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int?>> fieldLambda);
         /// <summary>
         /// 统计合计,若统计字段中包含null值，则不计入运算结果
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回合计值</returns>
         decimal? GetSum(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal?>> fieldLambda);
         /// <summary>
         /// 获得最大值,若统计字段中包含null值，则不计入运算结果
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回最大值</returns>
         int? GetMax(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int?>> fieldLambda);
         /// <summary>
         /// 获得最大值,若统计字段中包含null值，则不计入运算结果
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回最大值</returns>
         decimal? GetMax(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal?>> fieldLambda);
         /// <summary>
         /// 获得最小值,若统计字段中包含null值，则不计入运算结果
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回最小值</returns>
         int? GetMin(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int?>> fieldLambda);
         /// <summary>
         /// 获得最小值,若统计字段中包含null值，则不计入运算结果
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回最小值</returns>
         decimal? GetMin(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal?>> fieldLambda);
         /// <summary>
         /// 获得平均值,若统计字段中包含null值，则不计入运算结果
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回平均值</returns>
         int? GetAverage(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int?>> fieldLambda);
         /// <summary>
         /// 获得平均值,若统计字段中包含null值，则不计入运算结果
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回平均值</returns>
         decimal? GetAverage(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal?>> fieldLambda);

         /// <summary>
         /// 统计合计,若统计字段中包含null值，则抛异常
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回合计值</returns>
         int GetSum(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int>> fieldLambda);
         /// <summary>
         /// 统计合计,若统计字段中包含null值，则抛异常
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回合计值</returns>
         decimal GetSum(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal>> fieldLambda);
         /// <summary>
         /// 获得最大值,若统计字段中包含null值，则抛异常
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回最大值</returns>
         int GetMax(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int>> fieldLambda);
         /// <summary>
         /// 获得最大值,若统计字段中包含null值，则抛异常
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回最大值</returns>
         decimal GetMax(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal>> fieldLambda);
         /// <summary>
         /// 获得最小值,若统计字段中包含null值，则抛异常
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回最小值</returns>
         int GetMin(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int>> fieldLambda);
         /// <summary>
         /// 获得最小值,若统计字段中包含null值，则抛异常
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回最小值</returns>
         decimal GetMin(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal>> fieldLambda);
         /// <summary>
         /// 获得平均值,若统计字段中包含null值，则抛异常
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回平均值</returns>
         int GetAverage(Expression<Func<T, bool>> whereLambda, Expression<Func<T, int>> fieldLambda);
         /// <summary>
         /// 获得平均值,若统计字段中包含null值，则抛异常
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <param name="fieldLambda">选择字段的 Lambda表达式</param>
         /// <returns>返回平均值</returns>
         decimal GetAverage(Expression<Func<T, bool>> whereLambda, Expression<Func<T, decimal>> fieldLambda);
         /// <summary>
         /// 根据条件获得记录数
         /// </summary>
         /// <param name="whereLambda">过滤条件 Lambda表达式</param>
         /// <returns>记录数</returns>
         int GetCount(Expression<Func<T, bool>> whereLambda);
         /// <summary>
         /// 根据条件获得记录数
         /// </summary>
         /// <param name="strWhere">过滤条件 where字符串</param>
         /// <returns>记录数</returns>
         int GetCount(string strWhere);
         #endregion
     }

　　

　　3.DAL层

　　

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

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

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

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

　　

　　四、总结

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

     /// <summary>
     /// 商品评论参数 标签表
     /// </summary>
     [Serializable]
     public partial class Product_comment_merit:IModel
     {
        public Product_comment_merit()
         {
             this.Id=;
                    this.Product_category_ids="";
                    this.Title="";
                    this.Sort_id=;
                    this.Add_time=DateTime.Now;
                    this.Is_del=;
                }

         /// <summary>
         /// 主键Id
         /// </summary>
         public int Id { get; set; }
         /// <summary>
         /// 所属分类
         /// </summary>
         public string Product_category_ids { get; set; }
         /// <summary>
         /// 标题
         /// </summary>
         public string Title { get; set; }
         /// <summary>
         /// 排序
         /// </summary>
         public int Sort_id { get; set; }
         /// <summary>
         /// 添加时间
         /// </summary>
         public DateTime Add_time { get; set; }
         /// <summary>
         /// 删除标识
         /// </summary>
         public int Is_del { get; set; }
     }

　　model.tt文件，将数据库中的关系，映射成C#中的model，并保留字段备注，表说明。

　　所有BLL中的类，都继承了BaseBLL，所以每一个业务逻辑都有IBLL中的 52个方法，这些方法基本涵盖了所有常规的数据操作。

　　自己所特有的业务逻辑在单独编写，因为T4模版生成出来的Class 都是partial 的。

　　整体实现的功能为, 新建立某个关系模型，重新运行T4模版文件，则 就拥有了该对象的 IBLL中的 52个常用 CRUD的方法。