[Asp.net MVC]Asp.net MVC5系列——从控制器访问模型中的数据 - wolfy - 推酷
[Asp.net MVC]Asp.net MVC5系列——从控制器访问模型中的数据 - wolfy
上篇文章介绍了如何添加Model，在这篇文章中，我们将通过控制器访问模型中的数据，还有有写朋友问我，这么简单的东西有必要分享吗？其实有些东西真的很简单，没必要分享，但是这也是我学习的历程，希望记录自己是如何学习Asp.net mvc5，这还是看个人心态了，别总以为这简单，那也简单，这东西简单，一看就会，还是那句话，
好记性不如烂笔头，好思路不如烂键盘！
，别人敲的是别人的，自己实践一下，才有可能是自己的。
从控制器访问模型中的数据
上篇文章，通过ef添加了student，score，course类，这里我们先使用控制器访问student中的数据。（你也可以新建一个测试的数据库，数据不必多，如果有个学习用的测试数据库，再好不过了。）
添加一个StudentController控制器（如何添加控制器，可以参考本系列的第一篇文章），这里我们还是添加一个空的控制器，虽然有专门针对ef的。
StudentController控制器代码
public class StudentController : Controller
// GET: /Student/
public ActionResult Index()
return View();
然后打开，如图所示的cs文件
可以看到TestDataBaseEntityies类继承DbContext（数据库上下文）。
修改学生控制器中的代码，修改后的完整代码如下：
public class StudentController : Controller
/// &summary&
/// entity数据库上下文 实例
/// &/summary&
TestDataBaseEntities entity = new TestDataBaseEntities();
// GET: /Student/
public ActionResult StudentList()
//使用linq查询所有的80后的学生。
var students = from s in entity.Student
where s.stuBirthdate.Year &= 1980 && s.stuBirthdate.Year&1990
return View(students.ToList());
这段代码实施了一个LINQ查询来获取80后的所有学生。我们还需要一个视图模板来显示这个学生列表，所以在StudentList方法内点击鼠标右键，然后点击“添加视图”来添加一个视图。
由于这里我们需要将一个Student类传递给视图，所以在“添加视图”对话框中，与本教程中前几次在该对话框中之行的操作有所不同，前几次我们都是直接点击添加按钮来创建一个空白的视图模板，但是这一次我们想让Visual Web Developer为我们自动创建一个具有一些默认处理的强类型的视图，因为这里我们要显示学生列表，所以我们选择List模板，如下图所示：
点击添加按钮，Visual Web Developer自动生成一个视图，并且自动在视图文件中添加显示学生列表所需要的代码。这里，我们首先用与前面修改HelloWorld控制器所用的视图中的标题同样的方法来修改这个Student控制器所用视图中的标题。
另外，将列表标题中的文字全部修改为中文名称，并修改操作为中文，全部代码如下。
@model IEnumerable&Wolfy.FirstMVCProject.Models.Student&
Layout = null;
&!DOCTYPE html&
&meta name=&viewport& content=&width=device-width& /&
&title&学生信息&/title&
@Html.ActionLink(&添加&, &Create&)
&table class=&table&&
@foreach (var item in Model) {
@Html.DisplayFor(modelItem =& item.stuName)
@Html.DisplayFor(modelItem =& item.stuSex)
@Html.DisplayFor(modelItem =& item.stuBirthdate)
@Html.DisplayFor(modelItem =& item.stuStudydate)
@Html.DisplayFor(modelItem =& item.stuAddress)
@Html.DisplayFor(modelItem =& item.stuEmail)
@Html.DisplayFor(modelItem =& item.stuPhone)
@Html.DisplayFor(modelItem =& item.stuIsDel)
@Html.DisplayFor(modelItem =& item.stuInputtime)
@Html.DisplayFor(modelItem =& item.Course.className)
@Html.ActionLink(&编辑&, &Edit&, new { id=item.stuId }) |
@Html.ActionLink(&详细&, &Details&, new { id=item.stuId }) |
@Html.ActionLink(&删除&, &Delete&, new { id=item.stuId })
然后在Models下找到Student文件夹，选择StudentList.cshtml,右键，在浏览器中查看。
强类型模型与@model关键字
在本教程的前文中，我们介绍了一个控制器可以使用ViewBag对象来将数据或对象传递到视图模板中。ViewBag是一个动态对象，它提供了一种便利的，后期绑定的方法来将信息从控制器传递到视图中。
ASP.NET MVC也提供了一种利用强类型的方法来将数据或对象传递到视图模板中。这种强类型的方法为你的编码过程提供了很丰富的编辑时的智能输入提示信息与非常好的编译时的检查。
接下来我们将结合这种方法与我们的Student控制器（StudentController）与视图模板（StudentList.cshtml）一起使用。
请注意在我们的StudentController控制器的StudentList方法中，我们在调用View()方法时传入了一个参数，代码如下所示。
public class StudentController : Controller
/// &summary&
/// entity数据库上下文 实例
/// &/summary&
TestDataBaseEntities entity = new TestDataBaseEntities();
// GET: /Student/
public ActionResult StudentList()
//使用linq查询所有的80后的学生。
var students = from s in entity.Student
where s.stuBirthdate.Year &= 1980 && s.stuBirthdate.Year&1990
return View(students.ToList());
请注意如下这一行代码表示将一个Student列表从控制器传递到了视图中。
return View(students.ToList());
通过在视图模板文件的头部使用@model语句，视图模板可以识别传入的参数中的对象类型是否是该视图模板所需要的对象类型。当我们在创建这个Student控制器所使用的模板时，我们在“添加视图”对话框中选择了模型类Student，&在支架模板下拉框中选择了“List”。所以Visual Web Developer自动在我们的视图模板文件的第一行中添加了如下所示的语句。
@model IEnumerable&Wolfy.FirstMVCProject.Models.Student&
@model关键字允许我们在视图模板中直接访问在控制器类中通过使用强类型的“模型”而传递过来的Student类的列表。例如，在我们的StudentList.cshtml视图模板中，我们可以通过foreach语句来遍历这个强类型的模型，访问其中的每一个Student对象。代码如下所示。
@foreach (var item in Model) {
@Html.DisplayFor(modelItem =& item.stuName)
@Html.DisplayFor(modelItem =& item.stuSex)
@Html.DisplayFor(modelItem =& item.stuBirthdate)
@Html.DisplayFor(modelItem =& item.stuStudydate)
@Html.DisplayFor(modelItem =& item.stuAddress)
@Html.DisplayFor(modelItem =& item.stuEmail)
@Html.DisplayFor(modelItem =& item.stuPhone)
@Html.DisplayFor(modelItem =& item.stuIsDel)
@Html.DisplayFor(modelItem =& item.stuInputtime)
@Html.DisplayFor(modelItem =& item.Course.className)
@Html.ActionLink(&编辑&, &Edit&, new { id=item.stuId }) |
@Html.ActionLink(&详细&, &Details&, new { id=item.stuId }) |
@Html.ActionLink(&删除&, &Delete&, new { id=item.stuId })
因为这里的“模型”是强类型的（IEnumerable&Student&),所以在循环遍历时“模型”中的每一个项目（“item”）也是一个强类型的Student对象，可以直接访问该对象的每一个属性。同时这也意味着我们可以在编译时检查我们的代码，同时在书写代码时也可以使用代码编辑器提供的智能输入提示信息，如图所示。
这篇文章介绍了如何从控制器访问模型中的数据，需要注意的地方，在使用ef的时候，首先需要数据上下文对象。
介绍了强类型模型与@model关键字。
ViewBag是一个动态对象，它提供了一种便利的，后期绑定的方法来将信息从控制器传递到视图中。
通过在视图模板文件的头部使用@model语句，视图模板可以识别传入的参数中的对象类型是否是该视图模板所需要的对象类型。
就啰嗦到这里吧。
已发表评论数()
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
主题不准确
没有分页内容
图片无法显示
视频无法显示
与原文不一致ASP.NET（96）
前面项目的层次和调用关系都说明了，关系如下图
采用三层架构的时候，把业务逻辑独立出来，原因如下：
业务逻辑写进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类
用户模型或者叫账户模型，为什么这么说看下面代码
using ponentModel.DataA
namespace Ninesky.Models
/// &summary&
/// 用户模型
/// &remarks&
/// 创建：&br /&
/// 修改：
/// &/remarks&
/// &/summary&
public class User
public int UserID { get; set; }
/// &summary&
/// 用户名
/// &/summary&
[Required(ErrorMessage=&必填&)]
[StringLength(20,MinimumLength=4,ErrorMessage=&{1}到{0}个字符&)]
[Display(Name=&用户名&)]
public string UserName { get; set; }
/// &summary&
/// 用户组ID
/// &/summary&
[Required(ErrorMessage = &必填&)]
[Display(Name = &用户组ID&)]
public int GroupID { get; set; }
/// &summary&
/// 显示名
/// &/summary&
[Required(ErrorMessage = &必填&)]
[StringLength(20, MinimumLength = 2, ErrorMessage = &{1}到{0}个字符&)]
[Display(Name = &显示名&)]
public string DisplayName { get; set; }
/// &summary&
/// &/summary&
[Required(ErrorMessage = &必填&)]
[Display(Name = &密码&)]
[DataType(DataType.Password)]
public string Password { get; set; }
/// &summary&
/// &/summary&
[Required(ErrorMessage = &必填&)]
[Display(Name = &邮箱&)]
[DataType(DataType.EmailAddress)]
public string Email { get; set; }
/// &summary&
/// 用户状态&br /&
/// 0正常，1锁定，2未通过邮件验证，3未通过管理员
/// &/summary&
public int Status { get; set; }
/// &summary&
/// 注册时间
/// &/summary&
public DateTime RegistrationTime { get; set; }
/// &summary&
/// 上次登陆时间
/// &/summary&
public DateTime LoginTime { get; set; }
/// &summary&
/// 上次登陆IP
/// &/summary&
public DateTime LoginIP { get; set; }
public virtual UserGroup Group { get; set; }
这个模型类中只包含用户名、密码、用户组、显示名、邮箱等属性，纯粹是基本的账户信息，目的是让用户注册的时候尽可能的少填信息。其他信息如果需要可以再写新类与账户进行关联，用户需要的时候登录后再进行补填（如：资本资料、个人信息、联系方式等。这里先不考虑这些）。这里的显示名根据需要可以做昵称、真实姓名等来使用。
2、用户组模型—UserGroup类
这个类注意下GroupType，这个用来对用户组进行一下分类的，方便管理，其实没什么特别的意义。我的想法是普通类型就放普通的注册用户的组，如果大的网站允许用户升级的话，限定在这个类型的用户组内。特权组可以放一些vip之类的用户组，需要管理员给予，区别普通用户组，但又没有管理权。管理类型的用户组需要后台管理员给予，可以对文章、评论、咨询进行管理。
using ponentModel.DataA
namespace Ninesky.Models
/// &summary&
/// 用户组
/// &remarks&
/// 创建：
/// 修改：
/// &/remarks&
/// &/summary&
public class UserGroup
public int GroupID { get; set; }
/// &summary&
/// &/summary&
[Required(ErrorMessage=&必填&)]
[StringLength(20, MinimumLength = 2, ErrorMessage = &{1}到{0}个字&)]
[Display(Name=&名称&)]
public string Name { get; set; }
/// &summary&
/// 用户组类型&br /&
/// 0普通类型（普通注册用户），1特权类型（像VIP之类的类型），3管理类型（管理权限的类型）
/// &/summary&
[Required(ErrorMessage = &必填&)]
[Display(Name = &用户组类型&)]
public int GroupType { get; set; }
/// &summary&
/// &/summary&
[Required(ErrorMessage = &必填&)]
[StringLength(50, ErrorMessage = &少于{0}个字&)]
[Display(Name = &说明&)]
public string Description { get; set; }
3、用户配置模型类—UserConfig类
这个类是一些用户配置信息（暂时只考虑了注册设置），在后台管理员处进行设置。
using ponentModel.DataA
namespace Ninesky.Models
/// &summary&
/// 用户配置
/// &remarks&
/// &/remarks&
/// &/summary&
public class UserConfig
public int ConfigID { get; set; }
/// &summary&
/// 启用注册
/// &/summary&
[Display(Name = &启用注册&)]
[Required(ErrorMessage=&必填&)]
public bool Enabled { get; set; }
/// &summary&
/// 禁止使用的用户名&br /&
/// 用户名之间用“|”隔开
/// &/summary&
[Display(Name = &禁止使用的用户名&)]
public string ProhibitUserName { get; set; }
/// &summary&
/// 启用管理员验证
/// &/summary&
[Display(Name = &启用管理员验证&)]
[Required(ErrorMessage = &必填&)]
public bool EnableAdminVerify { get; set; }
/// &summary&
/// 启用邮件验证
/// &/summary&
[Display(Name = &启用邮件验证&)]
[Required(ErrorMessage = &必填&)]
public bool EnableEmailVerify { get; set; }
/// &summary&
/// 默认用户组Id
/// &/summary&
[Display(Name = &默认用户组Id&)]
[Required(ErrorMessage = &必填&)]
public int DefaultGroupId { get; set; }
二、数据存储层
数据存储层负责与数据库打交道，由于使用了接口产生了两个项目DAL和IDAL。IDAL是接口项目，DAL是接口的实现项目。
在与数据库的方便有一些共同的操作，像添加、修改、删除、查询等。不想在实际写代码的时候在用户类写一遍这些东西，用户组类再写一遍、以后文章、评论都再重复写这些代码。怎么办，弄个基类。以后其他类从基类继承就把这些公共方法继承过来了。
1、IDAL项目
首先打开IDAL项目，添加类InterfaceBaseRepository，代码如下。
using System.L
using System.Linq.E
namespace Ninesky.IDAL
/// &summary&
/// 接口基类
/// &remarks&创建： &br /&
/// 修改：&/remarks&
/// &/summary&
/// &typeparam name=&T&&类型&/typeparam&
public interface InterfaceBaseRepository&T&
/// &summary&
/// &/summary&
/// &param name=&entity&&数据实体&/param&
/// &returns&添加后的数据实体&/returns&
T Add(T entity);
/// &summary&
/// 查询记录数
/// &/summary&
/// &param name=&predicate&&条件表达式&/param&
/// &returns&记录数&/returns&
int Count(Expression&Func&T, bool&& predicate);
/// &summary&
/// &/summary&
/// &param name=&entity&&数据实体&/param&
/// &returns&是否成功&/returns&
bool Update(T entity);
/// &summary&
/// &/summary&
/// &param name=&entity&&数据实体&/param&
/// &returns&是否成功&/returns&
bool Delete(T entity);
/// &summary&
/// 是否存在
/// &/summary&
/// &param name=&anyLambda&&查询表达式&/param&
/// &returns&布尔值&/returns&
bool Exist(Expression&Func&T, bool&& anyLambda);
/// &summary&
/// 查询数据
/// &/summary&
/// &param name=&whereLambda&&查询表达式&/param&
/// &returns&实体&/returns&
T Find(Expression&Func&T, bool&& whereLambda);
/// &summary&
/// 查找数据列表
/// &/summary&
/// &typeparam name=&S&&排序&/typeparam&
/// &param name=&whereLamdba&&查询表达式&/param&
/// &param name=&isAsc&&是否升序&/param&
/// &param name=&orderLamdba&&排序表达式&/param&
/// &returns&&/returns&
IQueryable&T& FindList&S&(Expression&Func&T, bool&& whereLamdba, bool isAsc, Expression&Func&T, S&& orderLamdba);
/// &summary&
/// 查找分页数据列表
/// &/summary&
/// &typeparam name=&S&&排序&/typeparam&
/// &param name=&pageIndex&&当前页&/param&
/// &param name=&pageSize&&每页记录数&/param&
/// &param name=&totalRecord&&总记录数&/param&
/// &param name=&whereLamdba&&查询表达式&/param&
/// &param name=&isAsc&&是否升序&/param&
/// &param name=&orderLamdba&&排序表达式&/param&
/// &returns&&/returns&
IQueryable&T& FindPageList&S&(int pageIndex, int pageSize, out int totalRecord, Expression&Func&T, bool&& whereLamdba, bool isAsc, Expression&Func&T, S&& orderLamdba);
这里定义了增、删、改、判断存在、返回模型的查询、返回集合的查询，返回分页集合的查询7个公共方法。这几个方法基本满足一般需要，特殊的方法在继承的时候再添加。
还使用了泛型，在继承的时候传入实体类型就可以直接继承这些方法了。具体看下InterfaceUserRepository接口就清楚了。
using Ninesky.M
namespace Ninesky.IDAL
/// &summary&
/// 用户接口
/// &remarks&创建：&/remarks&
/// &/summary&
public interface InterfaceUserRepository:InterfaceBaseRepository&User&
简单吧，继承自InterfaceBaseRepository接口并传入实体类User就行了。我们在类视图中看下，是不是继承了基类的接口。
2、DAL项目
DAL项目是对IDAL项目接口的实现，项目中要创建DbContext类，对于DbContext类很多人讨论过它对数据库存取的效率，MSDN中说其是轻量的， 创建不需要很大开销，它也不是线程安全的对象，并且具有数据容器的性质（跟踪），因此很多人认为不应该将其静态化、单例化。但是对用户的单次请求来说实现DbContext唯一是合理的。 先看代码吧，非常简单。
using Ninesky.M
using System.Data.E
namespace Ninesky.DAL
/// &summary&
/// 数据上下文
/// &remarks&创建：&/remarks&
/// &/summary&
public class NineskyDbContext:DbContext
public DbSet&User& Users { get; set; }
public DbSet&UserGroup& UserGroups { get; set; }
public DbSet&UserConfig& UserConfig { get; set; }
public NineskyDbContext()
: base(&DefaultConnection&)
下面创建一个BaseRepository类，继承自InterfaceBaseRepository并实现类其接口的方法。
using Ninesky.IDAL;
using System.L
using System.Linq.E
namespace Ninesky.DAL
/// &summary&
/// 仓储基类
/// &remarks&创建：&/remarks&
/// &/summary&
public class BaseRepository&T&: InterfaceBaseRepository&T& where T : class
protected NineskyDbContext nContext = ContextFactory.GetCurrentContext();
public T Add(T entity)
nContext.Entry&T&(entity).State = System.Data.Entity.EntityState.A
nContext.SaveChanges();
public int Count(Expression&Func&T, bool&& predicate)
return nContext.Set&T&().Count(predicate);
public bool Update(T entity)
nContext.Set&T&().Attach(entity);
nContext.Entry&T&(entity).State = System.Data.Entity.EntityState.M
return nContext.SaveChanges() & 0;
public bool Delete(T entity)
nContext.Set&T&().Attach(entity);
nContext.Entry&T&(entity).State = System.Data.Entity.EntityState.D
return nContext.SaveChanges() & 0;
public bool Exist(Expression&Func&T, bool&& anyLambda)
return nContext.Set&T&().Any(anyLambda);
public T Find(Expression&Func&T, bool&& whereLambda)
T _entity = nContext.Set&T&().FirstOrDefault&T&(whereLambda);
public IQueryable&T& FindList&S&(Expression&Func&T, bool&& whereLamdba, bool isAsc, Expression&Func&T, S&& orderLamdba)
var _list = nContext.Set&T&().Where&T&(whereLamdba);
if (isAsc) _list = _list.OrderBy&T, S&(orderLamdba);
else _list = _list.OrderByDescending&T, S&(orderLamdba);
public IQueryable&T& FindPageList&S&(int pageIndex, int pageSize, out int totalRecord, Expression&Func&T, bool&& whereLamdba, bool isAsc, Expression&Func&T, S&& orderLamdba)
var _list = nContext.Set&T&().Where&T&(whereLamdba);
totalRecord = _list.Count();
if (isAsc) _list = _list.OrderBy&T, S&(orderLamdba).Skip&T&((pageIndex - 1) * pageSize).Take&T&(pageSize);
else _list = _list.OrderByDescending&T, S&(orderLamdba).Skip&T&((pageIndex - 1) * pageSize).Take&T&(pageSize);
代码中都是对数据库的操作。比较有看头的是这句protected NineskyDbContext nContext = ContextFactory.GetCurrentContext();
ContextFactory是一个简单工厂类，GetCurrentContext()是一个静态函数。利用简单工厂获取请求内的当前DbContext，也就是请求内的DbContext单例。先添加一个工厂类ContextFactory
using System.Data.E
using System.Runtime.Remoting.M
namespace Ninesky.DAL
/// &summary&
/// 上下文简单工厂
/// &remarks&
/// 创建：
/// &/remarks&
/// &/summary&
public class ContextFactory
/// &summary&
/// 获取当前数据上下文
/// &/summary&
/// &returns&&/returns&
public static NineskyDbContext GetCurrentContext()
NineskyDbContext _nContext = CallContext.GetData(&NineskyContext&) as NineskyDbC
if (_nContext == null)
_nContext = new NineskyDbContext();
CallContext.SetData(&NineskyContext&, _nContext);
return _nC
这里是先在CallContext中获取NineskyContext，如果为空则初始化一个NineskyContext，如果存在则直接返回。看CallContext，MSDN中讲CallContext提供对每个逻辑执行线程都唯一的数据槽，而在WEB程序里，每一个请求恰巧就是一个逻辑线程所以可以使用CallContext来实现单个请求之内的DbContext单例。
下面添加具体的仓储代码。
在DAL中再添加一个UserRepository类，继承自BaseRepository和InterfaceUserRepository。目的是继承自BaseRepository类，实现InterfaceUserRepositor接口。
using Ninesky.IDAL;
using Ninesky.M
using System.L
namespace Ninesky.DAL
/// &summary&
/// 用户仓库
/// &remarks&创建：&/remarks&
/// &/summary&
class UserRepository: BaseRepository&User&, InterfaceUserRepository
UserRepository就直接继承了基类中的方法，基类中的方法能满足绝大部分需要，UserRepository就不用再增加函数了，其他Repository类都类似，不在贴代码了。
这里我们在建一个Repository工厂，用来返回项目中的所有Repository类。
using Ninesky.IDAL;
namespace Ninesky.DAL
/// &summary&
/// 简单工厂？
/// &remarks&创建：&/remarks&
/// &/summary&
public static class RepositoryFactory
/// &summary&
/// 用户仓储
/// &/summary&
public static InterfaceUserRepository UserRepository { get { return new UserRepository(); } }
以后在BLL中调用的时候就不用每次都写InterfaceUserRepository _iUserRsy = new& UserRepository()了，直接写成InterfaceUserRepository _iUserRsy = RepositoryFactory.UserRepository这个东西的好处就是，以后在DAL项目中实现InterfaceUserRepository接口的类需要修改时我们可以直接创建个新类，然后RepositoryFactory类中让UserRepository属性返回新类就行了。
3、IBLL项目
IBLL是业务逻辑层的接口，业务逻辑层对数据库的操作上基本还是增、删、改。同样写一个基接口把这三个操作写进去，这里与IDAL思路类似。
namespace Ninesky.IBLL
/// &summary&
/// 接口基类
/// &remarks&创建：&/remarks&
/// &/summary&
public interface InterfaceBaseService&T& where T : class
/// &summary&
/// &/summary&
/// &param name=&entity&&数据实体&/param&
/// &returns&添加后的数据实体&/returns&
T Add(T entity);
/// &summary&
/// &/summary&
/// &param name=&entity&&数据实体&/param&
/// &returns&是否成功&/returns&
bool Update(T entity);
/// &summary&
/// &/summary&
/// &param name=&entity&&数据实体&/param&
/// &returns&是否成功&/returns&
bool Delete(T entity);
在添加一个InterfaceUserService接口，继承自InterfaceBaseService。根据需要在接口中又添加了几个方法。在这里对Find方法的名称进行统一，凡是返回实体类的名称为Find()或FindByXXX(),返回一组数据的方法名称为FindList()或FindXXXList，分页的名称格式为FindPageList()或FindxxxPageList()
using Ninesky.M
using System.L
namespace Ninesky.IBLL
/// &summary&
/// 用户相关接口
/// &remarks&
/// 创建：
/// &/remarks&
/// &/summary&
public interface InterfaceUserService:InterfaceBaseService&User&
/// &summary&
/// 用户是否存在
/// &/summary&
/// &param name=&userName&&用户名&/param&
/// &returns&布尔值&/returns&
bool Exist(string userName);
/// &summary&
/// 查找用户
/// &/summary&
/// &param name=&userID&&用户ID&/param&
/// &returns&&/returns&
User Find(int userID);
/// &summary&
/// 查找用户
/// &/summary&
/// &param name=&userName&&用户名&/param&
/// &returns&&/returns&
User Find(string userName);
/// &summary&
/// 用户列表
/// &/summary&
/// &param name=&pageIndex&&页码数&/param&
/// &param name=&pageSize&&每页记录数&/param&
/// &param name=&totalRecord&&总记录数&/param&
/// &param name=&order&&排序：0-ID升序（默认），1ID降序，2注册时间升序，3注册时间降序，4登录时间升序，5登录时间降序&/param&
/// &returns&&/returns&
IQueryable&User& FindPageList(int pageIndex, int pageSize, out int totalRecord,int order);
4、BLL项目
BLL项目中要实现InterfaceUserService接口的方法，先添加BaseService的
using Ninesky.IBLL;
using Ninesky.IDAL;
namespace Ninesky.BLL
/// &summary&
/// 服务基类
/// &remarks&创建：&/remarks&
/// &/summary&
public abstract class BaseService&T& : InterfaceBaseService&T& where T : class
protected InterfaceBaseRepository&T& CurrentRepository { get; set; }
public BaseService(InterfaceBaseRepository&T& currentRepository) { CurrentRepository = currentR }
public T Add(T entity) { return CurrentRepository.Add(entity); }
public bool Update(T entity) { return CurrentRepository.Update(entity); }
public bool Delete(T entity) { return CurrentRepository.Delete(entity); }
这个类的构造函数中要传入一个参数就是currentRepository 这个在继承的时候进行传入。这里还是看用户类。
using Ninesky.DAL;
using Ninesky.IBLL;
using Ninesky.M
using System.L
namespace Ninesky.BLL
/// &summary&
/// 用户服务类
/// &remarks&
/// 创建：
/// &/remarks&
/// &/summary&
public class UserService:BaseService&User&,InterfaceUserService
public UserService() : base(RepositoryFactory.UserRepository) { }
public bool Exist(string userName) { return CurrentRepository.Exist(u =& u.UserName == userName);}
public User Find(int userID) { return CurrentRepository.Find(u =& u.UserID == userID); }
public User Find(string userName) { return CurrentRepository.Find(u =& u.UserName == userName); }
public IQueryable&User& FindPageList(int pageIndex, int pageSize, out int totalRecord, int order)
switch(order)
case 0: return CurrentRepository.FindPageList(pageIndex, pageSize, out totalRecord, u =& true, true, u =& u.UserID);
case 1: return CurrentRepository.FindPageList(pageIndex, pageSize, out totalRecord, u =& true, false, u =& u.UserID);
case 2: return CurrentRepository.FindPageList(pageIndex, pageSize, out totalRecord, u =& true, true, u =& u.RegistrationTime);
case 3: return CurrentRepository.FindPageList(pageIndex, pageSize, out totalRecord, u =& true, false, u =& u.RegistrationTime);
case 4: return CurrentRepository.FindPageList(pageIndex, pageSize, out totalRecord, u =& true, true, u =& u.LoginTime);
case 5: return CurrentRepository.FindPageList(pageIndex, pageSize, out totalRecord, u =& true, false, u =& u.LoginTime);
default: return CurrentRepository.FindPageList(pageIndex, pageSize, out totalRecord, u =& true, true, u =& u.UserID);
上面这个FindPageList代码太累赘了，一时还没想到好方法。
今天写到这里还是在想项目间的调用实现，写了两个base接口、两个base类，以后其他的类都从它们继承，写法都很类似。下次可以开始做界面了，在Ninesky.Web项目中基本上是通过IBLL，BLL跟数据进行打交道了。
===================================================
FindPageList()&这个排序的方法确实不太通用，代码修改如下：
1、接口 InterfaceBaseRepository
修改两个接口方法如图红框部分。
2、BaseRepository类
添加OrderBy方法，代码如下：
/// &summary&
/// &/summary&
/// &typeparam name=&T&&类型&/typeparam&
/// &param name=&source&&原IQueryable&/param&
/// &param name=&propertyName&&排序属性名&/param&
/// &param name=&isAsc&&是否正序&/param&
/// &returns&排序后的IQueryable&T&&/returns&
private IQueryable&T& OrderBy(IQueryable&T& source, string propertyName, bool isAsc)
if (source == null) throw new ArgumentNullException(&source&, &不能为空&);
if (string.IsNullOrEmpty(propertyName)) return
var _parameter = Expression.Parameter(source.ElementType);
var _property = Expression.Property(_parameter, propertyName);
if (_property == null) throw new ArgumentNullException(&propertyName&, &属性不存在&);
var _lambda = Expression.Lambda(_property, _parameter);
var _methodName = isAsc ? &OrderBy& : &OrderByDescending&;
var _resultExpression = Expression.Call(typeof(Queryable), _methodName, new Type[] { source.ElementType, _property.Type }, source.Expression, Expression.Quote(_lambda));
return source.Provider.CreateQuery&T&(_resultExpression);
修改FindList和FindPageList方法，修改下图
3、修改UserService的FindPageList方法
修改后的代码如下：
public IQueryable&User& FindPageList(int pageIndex, int pageSize, out int totalRecord, int order)
bool _isAsc = true;
string _orderName = string.E
switch(order)
_isAsc = true;
_orderName = &UserID&;
_isAsc = false;
_orderName = &UserID&;
_isAsc = true;
_orderName = &RegistrationTime&;
_isAsc = false;
_orderName = &RegistrationTime&;
_isAsc = true;
_orderName = &LoginTime&;
case 5: _isAsc = false;
_orderName = &LoginTime&;
_isAsc = false;
_orderName = &UserID&;
return CurrentRepository.FindPageList(pageIndex, pageSize, out totalRecord, u =& true, _orderName, _isAsc);
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：80178次
积分：1188
积分：1188
排名：千里之外
转载：212篇
(2)(6)(4)(2)(4)(4)(13)(17)(23)(1)(1)(1)(3)(2)(2)(1)(2)(16)(17)(16)(30)(6)(7)(1)(1)(7)(2)(5)(8)(10)(1)(1)