女教师的课后辅导,华山儿童公园,依莎菲尔官网
学习asp.net 已经有近三个月的时间了，在asp.net mvc上花的时间最多，但个人真是有些菜，不得不说，asp.net mvc的水真的还是蛮深的。目前在公司实习，也见过公司几个项目的代码了。对项目的代码始终停留在一知半解的地步，能改一些简单的bug，但关于项目的来龙去脉始终云里雾里。对于asp.net mvc的架构始终看不懂。因此，照着传智博客的学习视频，学了一下简单的架构搭建。真个架构的搭建我看了将近两遍视频，才稍稍有些头绪，今天在这里记录一下，一方面加深理解，一方面如果以后忘记了，还能快速的想起来，当然如果我的这篇简陋的随笔能有幸被有需要的人看见，并对他们产生一些帮助，我心里肯定也是非常欢欣的。
好了，闲言少叙，那我就开始写了。
本篇博客我主要想讲如何使用 asp.net mvc + ef + spring.net 搭建一个简单的项目框架，我也并不是对前前后后所有的内容都理解，有的地方是囫囵吞枣，水平太菜，见谅。
在开始搭框架之前，先做一些准备工作：
（1）新建解决方案：
新建一个解决方案，然后在解决方案下间五个文件夹，分别为 common、bll、dal、model、ui.如下图所示：
（说明:我的项目命名为iotpf.proj，因为之前做过一个物联网云平台的项目，这里打算用.net重做实践一下，练练手）
（2）在model层中新建类库 model,然后添加ef数据库实体
添加实体的操作我就不啰嗦了，我以前的博客有讲到。结果如下：
（3）分别在bll里新建类库 xxx.bll 和 xxx.ibll,在dal里新建xxx.dal和xxx.idal,如图所示：
（4）在ui下面新建应用程序iotpf.ui
好了，准备工作已经做好了，下面进入正题。
1.首先在iofpf.dal中新建usersdal.cs文件，这个里面写对于user表的增删改查等系列数据库操作。如下入图所示：
下面列出在userdal中写的关于增删改查几个最常用操作的最基本写法，然后对其进行调用（当然只是那种最简单的调用，不涉及如和进行解耦的操作）：
看代码：
我要评论
1 public class userdal
2 {
3 iotpfmodel context = new iotpfmodel();
4 //使用lambda表示式查询
5 public iqueryable<users> getusersbylambda(expression<func<users,bool>> wherelambda)
6 {
7 return context.users.where(wherelambda).asqueryable();
8
9 }
10
11 //分页查询
12 #region 增删改
13 public users adduser(users user)
14 {
15 context.users.add(user);
16 context.savechanges();
17 return user;
18 }
19
20 public bool deleteuser(users user)
21 {
22 context.entry(user).state = system.data.entity.entitystate.deleted;
23 return context.savechanges() > 0;
24 }
25
26 public bool updateuser(users user)
27 {
28 context.entry(user).state = system.data.entity.entitystate.modified;
29 return context.savechanges() > 0;
30 }
31 #endregion
32 }
上面的代码写了增删改查四个方法，其中查询的方法是根据lambda表达式自定义查询条件。
上面的代存在一下几个方面的问题：（以很通俗化的语言描述，不写菜鸟看不懂的话）
（1）首先，userdal中对数据库进行操作首先要做的就是实例化上下文。目前，我们使用的是单一的ef操作数据库，所以实例化的就是ef的上下文，但是，操作数据的方式不止ef这一种，如果有一天我们的项目突然要求要用nh（另一种操作数据库的方式，但我没学过）操作数据库，那么如果我们像这样写的话，麻烦就大了。我们的项目肯定不会只有一个xxxdal，有很多个的，如果上下文变了，那我们就要改好多个xxxdal里的代码，这就牵一发而动全身了，相当麻烦，这就是第一个问题。
解决方法：可以把实例化上下文的操作单独的放在一个类中，在类中定义一个 getdalcontext()的方法，然后所有的xxxdal都可以调用这个方法，如果上下文变了，那么只需要改这一个文件就可以了，这就灵活一些了。
具体做法：
在iotpf.dal中新建dbcontextfactory.cs文件，然后编写代码如下：
1 public class dbcontextfactory
2 {
3 public static dbcontext getcurrentdbcontext()
4 {
5 return new iotpfmodel();
6 }
7 }
优化后的写法如下：
1 public static dbcontext getcurrentdbcontext()
2 {
3 dbcontext context = callcontext.getdata("dbcontext") as dbcontext;
4 if (context == null)
5 {
6 context = new iotpfmodel();
7 callcontext.setdata("dbcontext", context);
8 }
9
10 return context;
11}
（别问我为啥这么优化，尴尬的告诉你，本菜鸡不知道啊！）
（2）其次，userdal中的这几个方法是最最常用的方法，几乎每个xxxdal中都会用到这四个方法，那我们就在每个xxxdal中都写一遍吗？这显然是不合理的，这是无用功；
解决方法：常用的公共的方法，可以封装到一个基类中，所有需要用到的类都继承这个基类就可以了；
具体做法：
在iotpf.dal下新建一个basedal.cs，然后编辑代码如下：
1 public class basedal<t> where t : class ,new()
2 {
3 //实例化上下文
4 dbcontext context = dbcontextfactory.getcurrentdbcontext();
5 //使用lambda条件进行查询
6 public iqueryable<t> getentitybylambda(expression<func<t,bool>> wherelambda)
7 {
8 return context.set<t>().where(wherelambda).asqueryable();
9 }
10
11 //增删改
12 #region 增删改
13 public t addentity(t entity)
14 {
15 context.set<t>().add(entity);
16 context.savechanges();
17 return entity;
18 }
19 public bool deleteentity(t entity)
20 {
21 context.entry<t>(entity).state = entitystate.deleted;
22 return context.savechanges() > 0;
23 }
24 public bool updateentity(t entity)
25 {
26 context.entry<t>(entity).state = entitystate.modified;
27 return context.savechanges() > 0;
28 }
29 #endregion
30 }
然后，在userdal中的代码就可以注释掉了，直接让userdal继承basedal就可以了，其他的xxxdal也是如此：
1 public class userdal:basedal<users>
2.在iofpf.bll中编写业务逻辑层代码
在业务逻辑层中新建userservice.cs文件，然后书写一个添加数据的方法：
public class userservice
{
userdal userdal = new userdal();//这个地方问题严重
public users adduser(users user)
{
userdal.addentity(user);
return user;
}
}
好了，问题又来了，又到了一个要解耦的地方。
userdal userdal = new userdal();//这个地方问题严重
着重要讲的是这一句：
（1）首先，bll层（userservice）中直接用了dal层中的类（userdal），这使得两层之间的联系很紧，耦合度太高，只要userdal有任何变化，那么bll层就要进行相应的改动。
改进1：在dal层和bll层之间添加接口层idal,以后调用xxxdal的时候，使用ixxxdal进行调用，这样就用接口层把两个层隔离开来了：
具体做法：
在iotpf.idal下新建接口文件iuserdal.cs,然后让userdal继承iuserdal,当然，basedal的接口也是同理，下面给出代码如下：
ibasedal:
1 public interface ibasedal<t> where t : class,new()
2 {
3 iqueryable<t> getentitybylambda(expression<func<t, bool>> wherelambda);
4
5 t addentity(t entity);
6
7 bool deleteentity(t entity);
8
9 bool updateentity(t entity);
10 }
iuserdal:
public interface iuserdal:ibasedal<users>
{
}
userdal和basedal都要继承iuserdal和ibasedal才行哦，不然调不动的呢。
使用接口后则调用过程变为这样：
iuserdal userdal = new userdal();
其实像这样写问题仍然蛮严重的。为啥呢？且看第二个问题：
（2）我们肯定不止一个文件会用到userdal吧，实际上很多个文件都会用到userdal。但是，如果有一天，我的dal要由ef写的userdal换为nh写的nhuserdal,那可怎么整呢，我难道要在每个用到userdal的文件里分别去把new userdal() 换为 new nhuserdal()?,显然不啊，和上面那个上下文的类似，我们新建一个类，把new userdal的操作单独取出来，放在一个单独的方法中，这样只需要改一个地方就可以了。
具体做法：
在iotpf.factory下新建abstractfactory.cs,然后在里面添加如下代码：
1 public class abstractfactory
2 {
3 public static iuserdal getcurrentuserdal()
4 {
5 return new userdal();
6 }
7 }
然后调用过程进一步改进为如下：
iuserdal userdal = abstractfactory.getcurrentuserdal();
这样就要灵活多了。
这种做法其实就是工厂的概念啦。
但是，这样仍然不完美的啦，是不是很恼火，怎么这么麻烦，还能不能愉快的写代码了。哈哈哈，莫慌，麻烦是麻烦，但这种思想还是很牛逼的，好处多多哇。下面看问题：
（3）我接下来说 abstractfactory.cs里面的不足之处。什么不足之处呢？
现在我只写了一个getcurrentuserdal() 对吧，这改起来倒是方便了，但是做项目不可能只有一个userdal啊，以后肯定会有 adal啊，bdal,cdal等各种dal,一旦ef变为nh，那在这个工厂里不是又要改一堆名字了吗？这也太烦了啊。那怎么弄呢？看下面：
我们可以把所使用的数据库操作方式（ef还是nh还是ado.net）写进一个配置文件里面。假设我现在有两种方式操作数据库，ef和nh，一种操作数据库的方法写在项目efdal下，另一种写在nhdal项目下，然后让两个项目下各个操作方法的名字保持一致。如果要用ef操作，那就在配置文件中引用 efdal，如果用nh操作，那就在配置文件中引用nhdal,这样就可以切换自如了，是不是很方便呢，哈哈，确实挺溜的呀。
具体做法：
首先，在ui下的web.config文件中此处添加如下代码：
代码：
<add key="dalassemblyname" value="iotpf.dal"/>
然后在 abstractfactory.cs下添加如下代码：
//配置文件设置
public static string assemblyname = system.configuration.configurationmanager.appsettings["dalassemblyname"];
public static iuserdal getuserdal()
{
//配置文件设置 ,移到方法外面，会被多个getxxxdal使用
// string assemblyname = system.configuration.configurationmanager.appsettings["dalassemblyname"];
return assembly.load(assemblyname).createinstance(assemblyname + ".userdal") as iuserdal;
}
这里因为使用了配置文件，所以不要忘记添加下面这个引用哦：
这就是所谓的 抽象工厂的概念啦。
就像我现在用的是iotpf.dal，那我在配置文件里的value那个地方就写iotpf.dal,以后如果我需要用iotpf.xxxdal，那我就把value改为iotpf.xxxdal就好了。
3.下面我们来讲一下dbsession
dbsession是啥呢？说起dbsession那就要从上面的userservice接着讲啦。下面要说一下 上下文的 context.savechanges()了。
我们应该都知道的，如果我们操作上下文对数据库进行了 增、删、改的操作，那么操作结束后需要有一个 context.savechanges()的操作,用来把对实体的修改保存到数据库中。目前，我们这个操作是写在userdal中的。但是，这样做有一个问题，什么问题呢，我们先看一下下面这段代码：
1 iuserdal userdal = abstractfactory.getuserdal();
2 public users adduser(users user)
3 {
4 userdal.addentity(user);
5 userdal.deleteentity(user);
6 userdal.updateentity(user);
7 return user;
8 }
这段代码中调用了三个userdal中的方法，分别对数据库进行了三次不同的操作，每次操作之后相应的都会执行一次context.savechanges()的操作，也就是说与数据库交互了三次。有没有觉得三次有点多了呢，明明可以更少的呀，以后如果代码量大了，可能会交互更多次，那性能就很差了呀。这里呀，我们明明可以只交互一次就搞定的呀，怎么做呢，我们可以在把savechanges()的操作从userdal中迁移到userservice中的呀，在userdal中的每个方法先不写context.savechanges（）的操作，而是在userservice中把增删改这单个操作一起完成之后再统一进行提交，那岂不是更好吗。就像下面这样：
（此代码仅说明统一提交的意思，不是实际程序中的写法，看这个的同学不要粘这段代码）
1 iuserdal userdal = abstractfactory.getuserdal();
2 public users adduser(users user)
3 {
4 userdal.addentity(user);
5 userdal.deleteentity(user);
6 userdal.updateentity(user);
context.savechanges();//统一提交
7 return user;
8 }
下面具体来讲做法：
首先，在iotpf.factory下新建类 dbsession.cs,然后在里面编写如下代码：
1 public class dbsession
2 {
3 //声明userdal
4 public iuserdal userdal
5 {
6 get
7 {
8 return abstractfactory.getuserdal();
9 }
10 }
11 //保存实体
12 public int savechanges()
13 {
14 return dbcontextfactory.getcurrentdbcontext().savechanges();
15 }
16 }
看到没，声明userdal的操作现在搬到dbsession中了。
然后，userservice.cs现在变成下面这种写法：
1 public class userservice
2 {
3
4 //iuserdal userdal = abstractfactory.getuserdal();
5 dbsession dbsession = new dbsession();
6 public users adduser(users user)
7 {
8 dbsession.userdal.addentity(user);
9 dbsession.userdal.deleteentity(user);
10 dbsession.userdal.updateentity(user);
11 dbsession.savechanges();
12 return user;
13 }
14 }
保存操作已经不再由dal层控制了，而是提交到bll层，由bll层控制。当然，不要忘记回到dal层，把原来代码中的savechanges操作去掉：去掉后代码如下：
1 public class basedal<t> where t : class , new()
2 {
3 //实例化上下文
4 dbcontext context = dbcontextfactory.getcurrentdbcontext();
5 //使用lambda条件进行查询
6 public iqueryable<t> getentitybylambda(expression<func<t,bool>> wherelambda)
7 {
8 return context.set<t>().where(wherelambda).asqueryable();
9 }
10
11 //增删改
12 #region 增删改
13 public t addentity(t entity)
14 {
15 context.set<t>().add(entity);
16 // context.savechanges();
17 return entity;
18 }
19 public bool deleteentity(t entity)
20 {
21 context.entry<t>(entity).state = entitystate.deleted;
22 // return context.savechanges() > 0;
23 return true;
24 }
25 public bool updateentity(t entity)
26 {
27 context.entry<t>(entity).state = entitystate.modified;
28 // return context.savechanges() > 0;
29 return true;
30 }
31 #endregion
32 }
现在是不是就好多了，以后与数据库交互的次数就大大减少了，这样性能应该能提高不少吧，哈哈。
紧接着，我们需要将dbsession和bll层进行隔离，也就是这个操作：
现在应该已经轻车熟路了，先新建接口层 idbsession.cs ,然后新建dbsessionfactory.cs，下面给出代码：
idbsession.cs
1 public interface idbsession
2 {
3 iuserdal userdal { get; }
4 int savechanges();
5 }
dbsessionfactory.cs:
1 public static idbsession getcurrentdbsession()
2 {
3 idbsession dbsession = callcontext.getdata("dbsession") as idbsession;
4 if (dbsession == null)
5 {
6 dbsession = new dbsession();
7 callcontext.setdata("dbsession", dbsession);
8 }
9 return dbsession;
10 }
现在userservice.cs中的代码就变成这样：
1 idbsession dbsession = dbsessionfactory.getcurrentdbsession();
2 public users adduser(users user)
3 {
4 dbsession.userdal.addentity(user);
5 dbsession.userdal.deleteentity(user);
6 dbsession.userdal.updateentity(user);
7 dbsession.savechanges();
8 return user;
9 }
写到这里，数据访问层dal和业务逻辑成bll之间的解耦基本已经说完了，我感觉应该还是讲的比较清楚的了哈。
这个框架搭建的前半部分就已经讲完了，后面关于业务逻辑层bll和展示层ui之间的系列操作，我留到下一篇讲啦，哈哈，一下子写完我自己hold不住，你估计也看不下去了吧。
下面总结一下哈：
本篇内容扯了那么长，我也真是够有尿性的了，总结起来其实也就几个内容而已啦：
（1）使用接口层进行层与层之间的隔离；
（2）对重复多次使用的方法进行基类封装；
（3）使用工厂的概念，对数据库操作方法进行配置，便于应对数据库的更换，提高框架灵活性；
（4）使用dbsession将数据库保存操作的权限有dal层提交到业务逻辑层，减少与数据库交互次数，提高代码性能；
下一篇将介绍spring.net的使用，虽然我自己也不咋会 ，但还是把自己理解的写出来吧，以写代练，加深理解，大神们不要见笑啊。
我的email:3074596466@qq.com
完成框架代码就不往上贴了哈，有需要的同学可以给我发邮件索取。
明天就是国庆节啦，提前祝大家国庆节快乐，祝祖国繁荣昌盛！
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
asp.net搭建博客，使用BlogEngine.NET+MySql搭建博客
网友评论