当前位置：Gxlcms > asp.net > ASP.NET MVC5 网站开发框架模型、数据存储、业务逻辑（三）

ASP.NET MVC5 网站开发框架模型、数据存储、业务逻辑（三）

时间：2021-07-01 10:21:17 帮助过：15人阅读

前面项目的层次和调用关系都说明了，关系如下图

采用三层架构的时候，研究过BLL层的必要性，觉得业务逻辑完全可以在controller里实现，没有必要单独做一个项目，另一个分层多了会影响性能。后来我还是把业务逻辑独立出来，原因如下：

  • 业务逻辑写进controller里代码看着比较混乱，时间久了代码容易理不清。
  • 在controller里直接写逻辑重复代码会不较多，开发效率低。
  • 分项目有利于代码重用，有时候可以直接拿到其他项目中稍作修改就可以用。

对于性能我觉得分层多了肯定会有影响，但是不会很大。现在硬件的更新速度远大于软件，对业务逻辑处理起来很轻松，多实例化几个类对性能影响不大。一般来说网站运行基本上是一个存数据库和取数据库的过程，业务逻辑还是比较少，只不过现在的网站使用的图片、动画更多，效果更加绚丽。我觉得网站的效率瓶颈主要出现在服务器的带宽、IO性能和存取数据库上。在代码方面能做的就是优化数据库的存取。对了一般项目来说，为了百分之几的运行效率远不如提高开发效率和更加容易的代码管理重要，能实现需求就好，运行效率是哪是大牛要做的事。

对IDAL、DAL、IBLL 、BLL这四个项目：

IDAL写一个Base接口，接口中固定几个数据库操作方法，其他接口都继承自这个接口；

DAL项目做个base类实现这个IDAL的base接口，其他类都继承自base类。

同样IBLL中也写一个Base接口，固定几个基本的操作方法，同样其他接口也继承自这个base接口

IBLL中也写一个base类来实现IBLL中的base接口，其他类继承自这个base类。

这里以对用户的操作来构建代码的基本模式：

一、模型
这里写三个模型类。打开Ninesk.Models分别添加User、UserGroup、UserConfig三个模型类。

1、用户模型—User类
用户模型或者叫账户模型，为什么这么说看下面代码

  1. using System;
  2. using System.ComponentModel.DataAnnotations;
  3. namespace Ninesky.Models
  4. {
  5.  /// <summary>
  6.  /// 用户模型
  7.  /// <remarks>
  8.  /// 创建：2014.02.02<br />
  9.  /// 修改：2014.02.05
  10.  /// </remarks>
  11.  /// </summary>
  12.  public class User
  13.  {
  14.   [Key]
  15.   public int UserID { get; set; }
  16.   /// <summary>
  17.   /// 用户名
  18.   /// </summary>
  19.   [Required(ErrorMessage="必填")]
  20.   [StringLength(20,MinimumLength=4,ErrorMessage="{1}到{0}个字符")]
  21.   [Display(Name="用户名")]
  22.   public string UserName { get; set; }
  23.   /// <summary>
  24.   /// 用户组ID
  25.   /// </summary>
  26.   [Required(ErrorMessage = "必填")]
  27.   [Display(Name = "用户组ID")]
  28.   public int GroupID { get; set; }
  29.   /// <summary>
  30.   /// 显示名
  31.   /// </summary>
  32.   [Required(ErrorMessage = "必填")]
  33.   [StringLength(20, MinimumLength = 2, ErrorMessage = "{1}到{0}个字符")]
  34.   [Display(Name = "显示名")]
  35.   public string DisplayName { get; set; }
  36.   /// <summary>
  37.   /// 密码
  38.   /// </summary>
  39.   [Required(ErrorMessage = "必填")]
  40.   [Display(Name = "密码")]
  41.   [DataType(DataType.Password)]
  42.   public string Password { get; set; }
  43.   /// <summary>
  44.   /// 邮箱
  45.   /// </summary>
  46.   [Required(ErrorMessage = "必填")]
  47.   [Display(Name = "邮箱")]
  48.   [DataType(DataType.EmailAddress)]
  49.   public string Email { get; set; }
  50.   /// <summary>
  51.   /// 用户状态<br />
  52.   /// 0正常，1锁定，2未通过邮件验证，3未通过管理员
  53.   /// </summary>
  54.   public int Status { get; set; }
  55.   /// <summary>
  56.   /// 注册时间
  57.   /// </summary>
  58.   public DateTime RegistrationTime { get; set; }
  59.   /// <summary>
  60.   /// 上次登陆时间
  61.   /// </summary>
  62.   public DateTime LoginTime { get; set; }
  63.   /// <summary>
  64.   /// 上次登陆IP
  65.   /// </summary>
  66.   public DateTime LoginIP { get; set; }
  67.   public virtual UserGroup Group { get; set; }
  68.  }
  69. }

这个模型类中只包含用户名、密码、用户组、显示名、邮箱等属性，纯粹是基本的账户信息，目的是让用户注册的时候尽可能的少填信息。其他信息如果需要可以再写新类与账户进行关联，用户需要的时候登录后再进行补填（如：资本资料、个人信息、联系方式等。这里先不考虑这些）。这里的显示名根据需要可以做昵称、真实姓名等来使用。

2、用户组模型—UserGroup类
这个类注意下GroupType，这个用来对用户组进行一下分类的，方便管理，其实没什么特别的意义。我的想法是普通类型就放普通的注册用户的组，如果大的网站允许用户升级的话，限定在这个类型的用户组内。特权组可以放一些vip之类的用户组，需要管理员给予，区别普通用户组，但又没有管理权。管理类型的用户组需要后台管理员给予，可以对文章、评论、咨询进行管理。

  1. using System.ComponentModel.DataAnnotations;
  2. namespace Ninesky.Models
  3. {
  4.  /// <summary>
  5.  /// 用户组
  6.  /// <remarks>
  7.  /// 创建：2014.02.02
  8.  /// 修改：2014.02.08
  9.  /// </remarks>
  10.  /// </summary>
  11.  public class UserGroup
  12.  {
  13.   [Key]
  14.   public int GroupID { get; set; }
  15.   /// <summary>
  16.   /// 名称
  17.   /// </summary>
  18.   [Required(ErrorMessage="必填")]
  19.   [StringLength(20, MinimumLength = 2, ErrorMessage = "{1}到{0}个字")]
  20.   [Display(Name="名称")]
  21.   public string Name { get; set; }
  22.   /// <summary>
  23.   /// 用户组类型<br />
  24.   /// 0普通类型（普通注册用户），1特权类型（像VIP之类的类型），3管理类型（管理权限的类型）
  25.   /// </summary>
  26.   [Required(ErrorMessage = "必填")]
  27.   [Display(Name = "用户组类型")]
  28.   public int GroupType { get; set; }
  29.   /// <summary>
  30.   /// 说明
  31.   /// </summary>
  32.   [Required(ErrorMessage = "必填")]
  33.   [StringLength(50, ErrorMessage = "少于{0}个字")]
  34.   [Display(Name = "说明")]
  35.   public string Description { get; set; }
  36.  }
  37. }

3、用户配置模型类—UserConfig类
这个类是一些用户配置信息（暂时只考虑了注册设置），在后台管理员处进行设置。

  1. using System.ComponentModel.DataAnnotations;
  2. namespace Ninesky.Models
  3. {
  4.  /// <summary>
  5.  /// 用户配置
  6.  /// <remarks>
  7.  /// 创建:2014.02.06
  8.  /// </remarks>
  9.  /// </summary>
  10.  public class UserConfig
  11.  {
  12.   [Key]
  13.   public int ConfigID { get; set; }
  14.   /// <summary>
  15.   /// 启用注册
  16.   /// </summary>
  17.   [Display(Name = "启用注册")]
  18.   [Required(ErrorMessage="必填")]
  19.   public bool Enabled { get; set; }
  20.   /// <summary>
  21.   /// 禁止使用的用户名<br />
  22.   /// 用户名之间用“|”隔开
  23.   /// </summary>
  24.   [Display(Name = "禁止使用的用户名")]
  25.   public string ProhibitUserName { get; set; }
  26.   /// <summary>
  27.   /// 启用管理员验证
  28.   /// </summary>
  29.   [Display(Name = "启用管理员验证")]
  30.   [Required(ErrorMessage = "必填")]
  31.   public bool EnableAdminVerify { get; set; }
  32.   /// <summary>
  33.   /// 启用邮件验证
  34.   /// </summary>
  35.   [Display(Name = "启用邮件验证")]
  36.   [Required(ErrorMessage = "必填")]
  37.   public bool EnableEmailVerify { get; set; }
  38.   /// <summary>
  39.   /// 默认用户组Id
  40.   /// </summary>
  41.   [Display(Name = "默认用户组Id")]
  42.   [Required(ErrorMessage = "必填")]
  43.   public int DefaultGroupId { get; set; }
  44.  }
  45. }

二、数据存储层
数据存储层负责与数据库打交道，由于使用了接口产生了两个项目DAL和IDAL。IDAL是接口项目，DAL是接口的实现项目。

在与数据库的方便有一些共同的操作，像添加、修改、删除、查询等。不想在实际写代码的时候在用户类写一遍这些东西，用户组类再写一遍、以后文章、评论都再重复写这些代码。怎么办，弄个基类。以后其他类从基类继承就把这些公共方法继承过来了。

1、IDAL项目
首先打开IDAL项目，添加类InterfaceBaseRepository，代码如下。

  1. using System;
  2. using System.Linq;
  3. using System.Linq.Expressions;
  4. namespace Ninesky.IDAL
  5. {
  6.  /// <summary>
  7.  /// 接口基类
  8.  /// <remarks>创建：2014.02.03 <br />
  9.  /// 修改：2014.02.09</remarks>
  10.  /// </summary>
  11.  /// <typeparam name="T">类型</typeparam>
  12.  public interface InterfaceBaseRepository<T>
  13.  {
  14.   /// <summary>
  15.   /// 添加
  16.   /// </summary>
  17.   /// <param name="entity">数据实体</param>
  18.   /// <returns>添加后的数据实体</returns>
  19.   T Add(T entity);
  20.   /// <summary>
  21.   /// 查询记录数
  22.   /// </summary>
  23.   /// <param name="predicate">条件表达式</param>
  24.   /// <returns>记录数</returns>
  25.   int Count(Expression<Func<T, bool>> predicate);
  26.   /// <summary>
  27.   /// 更新
  28.   /// </summary>
  29.   /// <param name="entity">数据实体</param>
  30.   /// <returns>是否成功</returns>
  31.   bool Update(T entity);
  32.   /// <summary>
  33.   /// 删除
  34.   /// </summary>
  35.   /// <param name="entity">数据实体</param>
  36.   /// <returns>是否成功</returns>
  37.   bool Delete(T entity);
  38.   /// <summary>
  39.   /// 是否存在
  40.   /// </summary>
  41.   /// <param name="anyLambda">查询表达式</param>
  42.   /// <returns>布尔值</returns>
  43.   bool Exist(Expression<Func<T, bool>> anyLambda);
  44.   /// <summary>
  45.   /// 查询数据
  46.   /// </summary>
  47.   /// <param name="whereLambda">查询表达式</param>
  48.   /// <returns>实体</returns>
  49.   T Find(Expression<Func<T, bool>> whereLambda);
  50.   /// <summary>
  51.   /// 查找数据列表
  52.   /// </summary>
  53.   /// <typeparam name="S">排序</typeparam>
  54.   /// <param name="whereLamdba">查询表达式</param>
  55.   /// <param name="isAsc">是否升序</param>
  56.   /// <param name="orderLamdba">排序表达式</param>
  57.   /// <returns></returns>
  58.   IQueryable<T> FindList<S>(Expression<Func<T, bool>> whereLamdba, bool isAsc, Expression<Func<T, S>> orderLamdba);
  59.   
  60.   /// <summary>
  61.   /// 查找分页数据列表
  62.   /// </summary>
  63.   /// <typeparam name="S">排序</typeparam>
  64.   /// <param name="pageIndex">当前页</param>
  65.   /// <param name="pageSize">每页记录数</param>
  66.   /// <param name="totalRecord">总记录数</param>
  67.   /// <param name="whereLamdba">查询表达式</param>
  68.   /// <param name="isAsc">是否升序</param>
  69.   /// <param name="orderLamdba">排序表达式</param>
  70.   /// <returns></returns>
  71.   IQueryable<T> FindPageList<S>(int pageIndex, int pageSize, out int totalRecord, Expression<Func<T, bool>> whereLamdba, bool isAsc, Expression<Func<T, S>> orderLamdba);
  72.  }
  73. }

这里定义了增、删、改、判断存在、返回模型的查询、返回集合的查询，返回分页集合的查询7个公共方法。这几个方法基本满足一般需要，特殊的方法在继承的时候再添加。
还使用了泛型，在继承的时候传入实体类型就可以直接继承这些方法了。具体看下InterfaceUserRepository接口就清楚了。

  1. using Ninesky.Models;
  2. namespace Ninesky.IDAL
  3. {
  4.  /// <summary>
  5.  /// 用户接口
  6.  /// <remarks>创建：2014.02.03</remarks>
  7.  /// </summary>
  8.  public interface InterfaceUserRepository:InterfaceBaseRepository<User>
  9.  {
  10.  }
  11. }

简单吧，继承自InterfaceBaseRepository接口并传入实体类User就行了。我们在类视图中看下，是不是继承了基类的接口。

2、DAL项目
DAL项目是对IDAL项目接口的实现，项目中要创建DbContext类，对于DbContext类很多人讨论过它对数据库存取的效率，MSDN中说其是轻量的， 创建不需要很大开销，它也不是线程安全的对象，并且具有数据容器的性质（跟踪），因此很多人认为不应该将其静态化、单例化。但是对用户的单次请求来说实现DbContext唯一是合理的。 先看代码吧，非常简单。

  1. using Ninesky.Models;
  2. using System.Data.Entity;
  3. namespace Ninesky.DAL
  4. {
  5.  /// <summary>
  6.  /// 数据上下文
  7.  /// <remarks>创建：2014.02.03</remarks>
  8.  /// </summary>
  9.  public class NineskyDbContext:DbContext
  10.  {
  11.   public DbSet<User> Users { get; set; }
  12.   public DbSet<UserGroup> UserGroups { get; set; }
  13.   public DbSet<UserConfig> UserConfig { get; set; }
  14.   public NineskyDbContext()
  15.    : base("DefaultConnection")
  16.   {
  17.   }
  18.  }
  19. }

下面创建一个BaseRepository类，继承自InterfaceBaseRepository并实现类其接口的方法。

  1. using Ninesky.IDAL;
  2. using System;
  3. using System.Linq;
  4. using System.Linq.Expressions;
  5. namespace Ninesky.DAL
  6. {
  7.  /// <summary>
  8.  /// 仓储基类
  9.  /// <remarks>创建：2014.02.03</remarks>
  10.  /// </summary>
  11.  public class BaseRepository<T>: InterfaceBaseRepository<T> where T : class 
  12.  {
  13.   protected NineskyDbContext nContext = ContextFactory.GetCurrentContext();
  14.   public T Add(T entity)
  15.   {
  16.    nContext.Entry<T>(entity).State = System.Data.Entity.EntityState.Added;
  17.    nContext.SaveChanges();
  18.    return entity;
  19.   }
  20.   public int Count(Expression<Func<T, bool>> predicate)
  21.   {
  22.    return nContext.Set<T>().Count(predicate);
  23.   }
  24.   public bool Update(T entity)
  25.   {
  26.    nContext.Set<T>().Attach(entity);
  27.    nContext.Entry<T>(entity).State = System.Data.Entity.EntityState.Modified;
  28.    return nContext.SaveChanges() > 0;
  29.   }
  30.   public bool Delete(T entity)
  31.   {
  32.    nContext.Set<T>().Attach(entity);
  33.    nContext.Entry<T>(entity).State = System.Data.Entity.EntityState.Deleted;
  34.    return nContext.SaveChanges() > 0;
  35.   }
  36.   public bool Exist(Expression<Func<T, bool>> anyLambda)
  37.   {
  38.    return nContext.Set<T>().Any(anyLambda);
  39.   }
  40.   public T Find(Expression<Func<T, bool>> whereLambda)
  41.   {
  42.    T _entity = nContext.Set<T>().FirstOrDefault<T>(whereLambda);
  43.    return _entity;
  44.   }
  45.   public IQueryable<T> FindList<S>(Expression<Func<T, bool>> whereLamdba, bool isAsc, Expression<Func<T, S>> orderLamdba)
  46.   {
  47.    var _list = nContext.Set<T>().Where<T>(whereLamdba);
  48.    if (isAsc) _list = _list.OrderBy<T, S>(orderLamdba);
  49.    else _list = _list.OrderByDescending<T, S>(orderLamdba);
  50.    return _list;
  51.   }
  52.   public IQueryable<T> FindPageList<S>(int pageIndex, int pageSize, out int totalRecord, Expression<Func<T, bool>> whereLamdba, bool isAsc, Expression<Func<T, S>> orderLamdba)
  53.   {
  54.    var _list = nContext.Set<T>().Where<T>(whereLamdba);
  55.    totalRecord = _list.Count();
  56.    if (isAsc) _list = _list.OrderBy<T, S>(orderLamdba).Skip<T>((pageIndex - 1) * pageSize).Take<T>(pageSize);
  57.    else _list = _list.OrderByDescending<T, S>(orderLamdba).Skip<T>((pageIndex - 1) * pageSize).Take<T>(pageSize);
  58.    return _list;
  59.   }
  60.  }
  61. }

代码中都是对数据库的操作。比较有看头的是这句protected NineskyDbContext nContext = ContextFactory.GetCurrentContext();

ContextFactory是一个简单工厂类，GetCurrentContext()是一个静态函数。利用简单工厂获取请求内的当前DbContext，也就是请求内的DbContext单例。先添加一个工厂类ContextFactory

  1. using System.Data.Entity;
  2. using System.Runtime.Remoting.Messaging;
  3. namespace Ninesky.DAL
  4. {
  5.  /// <summary>
  6.  /// 上下文简单工厂
  7.  /// <remarks>
  8.  /// 创建：2014.02.05
  9.  /// </remarks>
  10.  /// </summary>
  11.  public class ContextFactory
  12.  {
  13.   /// <summary>
  14.   /// 获取当前数据上下文
  15.   /// </summary>
  16.   /// <returns></returns>
  17.   public static NineskyDbContext GetCurrentContext()
  18.   {
  19.    NineskyDbContext _nContext = CallContext.GetData("NineskyContext") as NineskyDbContext;
  20.    if (_nContext == null)
  21.    {
  22.     _nContext = new NineskyDbContext();
  23.     CallContext.SetData("NineskyContext", _nContext);
  24.    }
  25.    return _nContext;
  26.   }
  27.  }
  28. }

这里是先在CallContext中获取NineskyContext，如果为空则初始化一个NineskyContext，如果存在则直接返回。看CallContext，MSDN中讲CallContext提供对每个逻辑执行线程都唯一的数据槽，而在WEB程序里，每一个请求恰巧就是一个逻辑线程所以可以使用CallContext来实现单个请求之内的DbContext单例。

下面添加具体的仓储代码。

在DAL中再添加一个UserRepository类，继承自BaseRepository和InterfaceUserRepository。目的是继承自BaseRepository类，实现InterfaceUserRepositor接口。

  1. using Ninesky.IDAL;
  2. using Ninesky.Models;
  3. using System.Linq;
  4. namespace Ninesky.DAL
  5. {
  6.  /// <summary>
  7.  /// 用户仓库
  8.  /// <remarks>创建：2014.02.03</remarks>
  9.  /// </summary>
  10.  class UserRepository: BaseRepository<User>, InterfaceUserRepository
  11.  {
  12.  }
  13. }

UserRepository就直接继承了基类中的方法，基类中的方法能满足绝大部分需要，UserRepository就不用再增加函数了，其他Repository类都类似，不在贴代码了。

这里我们在建一个Repository工厂，用来返回项目中的所有Repository类。

  1. using Ninesky.IDAL;
  2. namespace Ninesky.DAL
  3. {
  4.  /// <summary>
  5.  /// 简单工厂？
  6.  /// <remarks>创建：2014.02.03</remarks>
  7.  /// </summary>
  8.  public static class RepositoryFactory
  9.  {
  10.   /// <summary>
  11.   /// 用户仓储
  12.   /// </summary>
  13.   public static InterfaceUserRepository UserRepository { get { return new UserRepository(); } }
  14.  }
  15. }

以后在BLL中调用的时候就不用每次都写InterfaceUserRepository _iUserRsy = new  UserRepository()了，直接写成InterfaceUserRepository _iUserRsy = RepositoryFactory.UserRepository这个东西的好处就是，以后在DAL项目中实现InterfaceUserRepository接口的类需要修改时我们可以直接创建个新类，然后RepositoryFactory类中让UserRepository属性返回新类就行了。

3、IBLL项目
IBLL是业务逻辑层的接口，业务逻辑层对数据库的操作上基本还是增、删、改。同样写一个基接口把这三个操作写进去，这里与IDAL思路类似。

  1. namespace Ninesky.IBLL
  2. {
  3.  /// <summary>
  4.  /// 接口基类
  5.  /// <remarks>创建：2014.02.03</remarks>
  6.  /// </summary>
  7.  public interface InterfaceBaseService<T> where T : class
  8.  {
  9.   /// <summary>
  10.   /// 添加
  11.   /// </summary>
  12.   /// <param name="entity">数据实体</param>
  13.   /// <returns>添加后的数据实体</returns>
  14.   T Add(T entity);
  15.   /// <summary>
  16.   /// 更新
  17.   /// </summary>
  18.   /// <param name="entity">数据实体</param>
  19.   /// <returns>是否成功</returns>
  20.   bool Update(T entity);
  21.   /// <summary>
  22.   /// 删除
  23.   /// </summary>
  24.   /// <param name="entity">数据实体</param>
  25.   /// <returns>是否成功</returns>
  26.   bool Delete(T entity);
  27.  }
  28. }


在添加一个InterfaceUserService接口，继承自InterfaceBaseService。根据需要在接口中又添加了几个方法。在这里对Find方法的名称进行统一，凡是返回实体类的名称为Find()或FindByXXX(),返回一组数据的方法名称为FindList()或FindXXXList，分页的名称格式为FindPageList()或FindxxxPageList()

  1. using Ninesky.Models;
  2. using System.Linq;
  3. namespace Ninesky.IBLL
  4. {
  5.  /// <summary>
  6.  /// 用户相关接口
  7.  /// <remarks>
  8.  /// 创建：2014.02.09
  9.  /// </remarks>
  10.  /// </summary>
  11.  public interface InterfaceUserService:InterfaceBaseService<User>
  12.  {
  13.   /// <summary>
  14.   /// 用户是否存在
  15.   /// </summary>
  16.   /// <param name="userName">用户名</param>
  17.   /// <returns>布尔值</returns>
  18.   bool Exist(string userName);
  19.   /// <summary>
  20.   /// 查找用户
  21.   /// </summary>
  22.   /// <param name="userID">用户ID</param>
  23.   /// <returns></returns>
  24.   User Find(int userID);
  25.   /// <summary>
  26.   /// 查找用户
  27.   /// </summary>
  28.   /// <param name="userName">用户名</param>
  29.   /// <returns></returns>
  30.   User Find(string userName);
  31.   /// <summary>
  32.   /// 用户列表
  33.   /// </summary>
  34.   /// <param name="pageIndex">页码数</param>
  35.   /// <param name="pageSize">每页记录数</param>
  36.   /// <param name="totalRecord">总记录数</param>
  37.   /// <param name="order">排序：0-ID升序（默认），1ID降序，2注册时间升序，3注册时间降序，4登录时间升序，5登录时间降序</param>
  38.   /// <returns></returns>
  39.   IQueryable<User> FindPageList(int pageIndex, int pageSize, out int totalRecord,int order);
  40.  }
  41. }

4、BLL项目
BLL项目中要实现InterfaceUserService接口的方法，先添加BaseService的

  1. using Ninesky.IBLL;
  2. using Ninesky.IDAL;
  3. namespace Ninesky.BLL
  4. {
  5.  /// <summary>
  6.  /// 服务基类
  7.  /// <remarks>创建：2014.02.03</remarks>
  8.  /// </summary>
  9.  public abstract class BaseService<T> : InterfaceBaseService<T> where T : class
  10.  {
  11.   protected InterfaceBaseRepository<T> CurrentRepository { get; set; }
  12.   public BaseService(InterfaceBaseRepository<T> currentRepository) { CurrentRepository = currentRepository; }
  13.   public T Add(T entity) { return CurrentRepository.Add(entity); }
  14.   public bool Update(T entity) { return CurrentRepository.Update(entity); }
  15.   public bool Delete(T entity) { return CurrentRepository.Delete(entity); }
  16.  }
  17. }

这个类的构造函数中要传入一个参数就是currentRepository 这个在继承的时候进行传入。这里还是看用户类。

  1. using Ninesky.DAL;
  2. using Ninesky.IBLL;
  3. using Ninesky.Models;
  4. using System.Linq;
  5. namespace Ninesky.BLL
  6. {
  7.  /// <summary>
  8.  /// 用户服务类
  9.  /// <remarks>
  10.  /// 创建：2014.02.12
  11.  /// </remarks>
  12.  /// </summary>
  13.  public class UserService:BaseService<User>,InterfaceUserService
  14.  {
  15.   public UserService() : base(RepositoryFactory.UserRepository) { }
  16.   public bool Exist(string userName) { return CurrentRepository.Exist(u => u.UserName == userName);}
  17.   public User Find(int userID) { return CurrentRepository.Find(u => u.UserID == userID); }
  18.   public User Find(string userName) { return CurrentRepository.Find(u => u.UserName == userName); }
  19.   public IQueryable<User> FindPageList(int pageIndex, int pageSize, out int totalRecord, int order)
  20.   {
  21.    switch(order)
  22.    {
  23.     case 0: return CurrentRepository.FindPageList(pageIndex, pageSize, out totalRecord, u => true, true, u => u.UserID);
  24.     case 1: return CurrentRepository.FindPageList(pageIndex, pageSize, out totalRecord, u => true, false, u => u.UserID);
  25.     case 2: return CurrentRepository.FindPageList(pageIndex, pageSize, out totalRecord, u => true, true, u => u.RegistrationTime);
  26.     case 3: return CurrentRepository.FindPageList(pageIndex, pageSize, out totalRecord, u => true, false, u => u.RegistrationTime);
  27.     case 4: return CurrentRepository.FindPageList(pageIndex, pageSize, out totalRecord, u => true, true, u => u.LoginTime);
  28.     case 5: return CurrentRepository.FindPageList(pageIndex, pageSize, out totalRecord, u => true, false, u => u.LoginTime);
  29.     default: return CurrentRepository.FindPageList(pageIndex, pageSize, out totalRecord, u => true, true, u => u.UserID);
  30.    }
  31.    
  32.   }
  33.  }
  34. }

上面这个FindPageList代码太累赘了，一时还没想到好方法。

5、总结
今天写到这里还是在想项目间的调用实现，写了两个base接口、两个base类，以后其他的类都从它们继承，写法都很类似。下次可以开始做界面了，在Ninesky.Web项目中基本上是通过IBLL，BLL跟数据进行打交道了。

 ===================================================

FindPageList() 这个排序的方法确实不太通用，代码修改如下：

1、接口 InterfaceBaseRepository

修改两个接口方法如图红框部分。

image

2、BaseRepository类

添加OrderBy方法，代码如下：

  1. /// <summary>
  2.   /// 排序
  3.   /// </summary>
  4.   /// <typeparam name="T">类型</typeparam>
  5.   /// <param name="source">原IQueryable</param>
  6.   /// <param name="propertyName">排序属性名</param>
  7.   /// <param name="isAsc">是否正序</param>
  8.   /// <returns>排序后的IQueryable<T></returns>
  9.   private IQueryable<T> OrderBy(IQueryable<T> source, string propertyName, bool isAsc)
  10.   {
  11.    if (source == null) throw new ArgumentNullException("source", "不能为空");
  12.    if (string.IsNullOrEmpty(propertyName)) return source;
  13.    var _parameter = Expression.Parameter(source.ElementType);
  14.    var _property = Expression.Property(_parameter, propertyName);
  15.    if (_property == null) throw new ArgumentNullException("propertyName", "属性不存在");
  16.    var _lambda = Expression.Lambda(_property, _parameter);
  17.    var _methodName = isAsc ? "OrderBy" : "OrderByDescending";
  18.    var _resultExpression = Expression.Call(typeof(Queryable), _methodName, new Type[] { source.ElementType, _property.Type }, source.Expression, Expression.Quote(_lambda));
  19.    return source.Provider.CreateQuery<T>(_resultExpression);
  20.   }
  21. 修改FindList和FindPageList方法，修改下图
  22. image
  23. 3、修改UserService的FindPageList方法
  24. 修改后的代码如下：
  25. public IQueryable<User> FindPageList(int pageIndex, int pageSize, out int totalRecord, int order)
  26.   {
  27.    bool _isAsc = true;
  28.    string _orderName = string.Empty;
  29.    switch(order)
  30.    {
  31.     case 0:
  32.      _isAsc = true;
  33.      _orderName = "UserID";
  34.      break;
  35.     case 1:
  36.      _isAsc = false;
  37.      _orderName = "UserID";
  38.      break;
  39.     case 2: 
  40.      _isAsc = true;
  41.      _orderName = "RegistrationTime";
  42.      break;
  43.     case 3: 
  44.      _isAsc = false;
  45.      _orderName = "RegistrationTime";
  46.      break;
  47.     case 4: 
  48.      _isAsc = true;
  49.      _orderName = "LoginTime";
  50.      break;
  51.     case 5: _isAsc = false;
  52.      _orderName = "LoginTime";
  53.      break;
  54.     default: 
  55.      _isAsc = false;
  56.      _orderName = "UserID";
  57.      break;
  58.    }
  59.    return CurrentRepository.FindPageList(pageIndex, pageSize, out totalRecord, u => true, _orderName, _isAsc);
  60.   }

以上就是ASP.NET MVC5 网站开发框架模型、数据存储以及业务逻辑的相关介绍，比之前两节的内容是不是更加丰富了，希望本文可以对大家的学习有所帮助。

人气教程排行

本站所有资源全部来源于网络，若本站发布的内容侵害到您的隐私或者利益，请联系我们删除！