前段时间一直在忙着处理一个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的方法。

EntityFreamWork 项目总结的更多相关文章

  1. EntityFreamWork和Mvc 精品知识点

    定义了DbRepository<TEntity>:IRepository<TEntity> ,SimpleDbContext继承了DbContext, UnitOfWork:I ...

  2. Fis3前端工程化之项目实战

    Fis3项目 项目目录结构: E:. │ .gitignore │ fis-conf.js │ index.html │ package.json │ README.md │ ├─material │ ...

  3. 【原】Android热更新开源项目Tinker源码解析系列之三:so热更新

    本系列将从以下三个方面对Tinker进行源码解析: Android热更新开源项目Tinker源码解析系列之一:Dex热更新 Android热更新开源项目Tinker源码解析系列之二:资源文件热更新 A ...

  4. 最近帮客户实施的基于SQL Server AlwaysOn跨机房切换项目

    最近帮客户实施的基于SQL Server AlwaysOn跨机房切换项目 最近一个来自重庆的客户找到走起君,客户的业务是做移动互联网支付,是微信支付收单渠道合作伙伴,数据库里存储的是支付流水和交易流水 ...

  5. Hangfire项目实践分享

    Hangfire项目实践分享 目录 Hangfire项目实践分享 目录 什么是Hangfire Hangfire基础 基于队列的任务处理(Fire-and-forget jobs) 延迟任务执行(De ...

  6. Travis CI用来持续集成你的项目

    这里持续集成基于GitHub搭建的博客为项目 工具: zqz@ubuntu:~$ node --version v4.2.6 zqz@ubuntu:~$ git --version git versi ...

  7. 【原】Android热更新开源项目Tinker源码解析系列之一:Dex热更新

    [原]Android热更新开源项目Tinker源码解析系列之一:Dex热更新 Tinker是微信的第一个开源项目,主要用于安卓应用bug的热修复和功能的迭代. Tinker github地址:http ...

  8. 【原】Android热更新开源项目Tinker源码解析系列之二:资源文件热更新

    上一篇文章介绍了Dex文件的热更新流程,本文将会分析Tinker中对资源文件的热更新流程. 同Dex,资源文件的热更新同样包括三个部分:资源补丁生成,资源补丁合成及资源补丁加载. 本系列将从以下三个方 ...

  9. Angular企业级开发(5)-项目框架搭建

    1.AngularJS Seed项目目录结构 AngularJS官方网站提供了一个angular-phonecat项目,另外一个就是Angular-Seed项目.所以大多数团队会基于Angular-S ...

随机推荐

  1. 当使用 SelfHost 的 OWIN 承载 SignalR 时,重启 OWIN 后,SignalR 不能正常工作

    需要在初始化时,重新对 Resolver 赋值一个新的实例: public class Startup { public void Configuration(IAppBuilder app) { v ...

  2. mysql 按照月份自动创建表,以年和月为表明,动态生成。

    需求:mysql5.5 数据库,想要根据月份自动创建表,每个月创建一张表,需要数据库自动创建,并根据当前年和月动态生成表名称. 解决办法:1 连接数据库工具为Navicat  2  首先创建存储过程, ...

  3. Scratch 可能能帮你找到学习编程的初心

    Scratch 是MIT 出品的一款少儿编程软件,基于Adobe Air开发,这个运行环境在如今已经显得有些过时,但只要这个软件有用,软件本身就不会过时. 编程的本质大致是调用计算机的指令编写一系列任 ...

  4. Oracle分析函数-keep(dense_rank first/last)

    select * from criss_sales where dept_id = 'D02' order by sale_date ; 此时有个新需求,希望查看部门 D02 内,销售记录时间最早,销 ...

  5. DatagramSocket(邮递员):对应数据报的Socket概念,不需要创建两个socket,不可使用输入输出流。

    UDP编程: DatagramSocket(邮递员):对应数据报的Socket概念,不需要创建两个socket,不可使用输入输出流. DatagramPacket(信件):数据包,是UDP下进行传输数 ...

  6. Adding ASP.NET MVC5 Identity Authentication to an existing project

    Configuring Identity to your existing project is not hard thing. You must install some NuGet package ...

  7. 【Excel】读取固定长文本

    '******************************************************************************* ' 固定長形式テキストファイルを読み込 ...

  8. 【App】Android Studio 海马玩

    一.工程创建及配置 1.gradle环境变量 2.首次创建工程慢:https://www.cnblogs.com/xiadewang/p/7820377.html 二.海马玩虚拟机 C:\Users\ ...

  9. windows安装mysql8

    1:首先去官网下载安装包 下载地址:https://dev.mysql.com/downloads/mysql/ 2:将解压文件解压到你安装的目录:E:\mysql-8.0.11-winx64  (我 ...

  10. MQTT 嵌入式端通讯协议解析(转)

    MQTT,目前物联网的最主要的协议,基本所有收费的云平台都是基于MQTT协议,比如机智云,和所有的开放云平台比如中国移动的oneNet.百度的云平台也都支持MQTT的接入.虽然MQTT很火,但是目前对 ...