前段时间一直在忙着处理一个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. MySQL利用mysqldump在线修复或新增从库

    如果数据库的数据量不是很大,可以利用mysqldump导出备份修复从库故障或新增从库实例 主库IP:192.168.1.1从库IP:192.168.1.2 1.主库服务器导出备份:db_name=`m ...

  2. UBANTU zongjie

    1.fatal error: openssl/aes.h: No such file or directory 要在Debian.Ubuntu或者其他衍生版上安装OpenSSL: $ sudo apt ...

  3. JSSDK微信支付封装的支付类方法,代码比较齐全,适合收藏

    第1肯定是配置的参数类 public class JsApiConfig { #region 字段 private string mch_id = string.Empty; private stri ...

  4. C# 托管内存与非托管内存之间的转换

    c#有自己的内存回收机制,所以在c#中我们可以只new,不用关心怎样delete,c#使用gc来清理内存,这部分内存就是managed memory,大部分时候我们工作于c#环境中,都是在使用托管内存 ...

  5. Elasticsearch常用配置及性能参数[转]

    cluster.name: estest   集群名称node.name: “testanya”  节点名称 node.master: false  是否主节点node.data: true   是否 ...

  6. mybatis查询结果和接收的不一样

    记一次大坑:mybatis查询结果和接收的不一样,折腾我好几个小时. 先上代码:代码是要查询排名,sql执行的结果 SELECT b.operator_id, b.class_count, b.cla ...

  7. Spring-boot之 swagger2

    Swagger是一个简单但功能强大的API表达工具. 结合springboot 配置起来很简单,附上教程 :https://www.xncoding.com/2017/07/08/spring/sb- ...

  8. .NET Core Session的使用方法

    刚使用.NET Core会不习惯,比如如何使用Session:不仅需要引用相应的类库,还需要在Startup.cs里进行注册. 1.在你的项目上基于NuGet添加: install-package M ...

  9. Android 解析未知格式的json数据

    1.递归一有的时候我们需要解析未知的json.或者说是动态的json.那么我们并不知道key具体是多少,或者说key不是固定的.这时候就需要解析动态key的方法. 这个方法是我在实现解析前台传入的js ...

  10. 查看和修改 mysql库、表、字段编码

    查看编码 查看数据库编码. show variables like '%char%'; 查看表编码 show create table <表名>; 例:show create table ...