欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

MVC项目结构搭建及单个类的实现学习笔记1

程序员文章站 2023-11-30 08:01:57
新人刚开始学习asp.net mvc,若有不足之处希望能得到您的指点,不胜感激! 先来一张项目的层级结构图: model:模型层,主要是各种类型、枚举以及orm框架...

新人刚开始学习asp.net mvc,若有不足之处希望能得到您的指点,不胜感激!

先来一张项目的层级结构图:

model:模型层,主要是各种类型、枚举以及orm框架,框架完成数据库和实体类的映射。项目中选用了微软的开源orm框架 entityframework 6.0 (以下简称ef),数据库则选择了微软的轻量级数据库sql server compact 4.0本地数据库(简称compact),compact对ef支持比较完美,又属于文档型数据库,部署起来比较简洁。

dal:数据访问层,主要是对数据库的操作层,为业务逻辑层或表示层提供数据服务。

idal:数据访问接口层,是数据访问层的接口,降低耦合。

dalfactory:数据会话层,封装了所有数据操作类实例的创建,将数据访问层与业务逻辑层解耦。

bll:业务逻辑层,主要负责对数据层的操作,把一些数据层的操作进行组合以完成业务的需要。

ibll:业务逻辑接口层,业务逻辑层的接口,降低耦合。

webapp:表现层,是一个asp.net mvc项目,完成具体网站的实现。

common:通用层,用来存放一些工具类。

下面是各个层级之间具体的实现,首先创建以 项目名.层级名 命名的各个层次,除webapp层为asp.net mvc项目外,其余均创建为类库项目。

模型层的构建

先建立模型层,新建asp.net 实体数据模型,关联到已经设计好的数据库,ef自动完成模型类的创建。

数据访问层的构建

      dal层中,我们首先需要一个方法来获取单例的ef数据操纵上下文对象,以保证每个用户访问时只有使用一个上下文对象对数据库进行操作。

dbcontextfactory.cs

using system.data.entity;
using system.runtime.remoting.messaging;
using pms.model;

namespace pms.dal
{
  public class dbcontextfactory
  {
    /// <summary>
    /// 负责创建ef数据操作上下文实例,必须保证线程内唯一
    /// </summary>
    public static dbcontext createcontext()
    {
      dbcontext dbcontext = (dbcontext)callcontext.getdata("dbcontext");
      if (dbcontext != null) return dbcontext;
      dbcontext = new pmsentities();
      callcontext.setdata("dbcontext", dbcontext);
      return dbcontext;
    }
  }
}

 

为user类创建dal层,实现查询、分页查询、增加、删除和修改这五个基本的方法:

userdal.cs

using system;
using system.data.entity;
using system.linq;
using pms.idal;

namespace pms.dal
{
  public partial class userdal   {
    public dbcontext dbentities = dbcontextfactory.createcontext();

    /// <summary>
    /// 查询过滤
    /// </summary>
    /// <param name="wherelamada">过滤条件lambda表达式</param>
    /// <returns>实体集合</returns>
    public iqueryable<userdal> loadentities(system.linq.expressions.expression<func<userdal, bool>> wherelamada)
    {
      return dbentities.set<userdal>().where(wherelamada);
    }

    /// <summary>
    /// 分页查询
    /// </summary>
    /// <typeparam name="ts">排序类型</typeparam>
    /// <param name="pageindex">查询的页码</param>
    /// <param name="pagesize">每页显示的数目</param>
    /// <param name="totalcount">符合条件的总行数</param>
    /// <param name="wherelambda">过滤条件lambda表达式</param>
    /// <param name="orderbylambda">排序lambda表达式</param>
    /// <param name="isasc">排序方向</param>
    /// <returns>实体集合</returns>
    public iqueryable<userdal> loadpageentities<ts>(int pageindex, int pagesize, out int totalcount, system.linq.expressions.expression<func<userdal, bool>> wherelambda, system.linq.expressions.expression<func<userdal, ts>> orderbylambda, bool isasc)
    {
      var temp = dbentities.set<userdal>().where(wherelambda);
      totalcount = temp.count();
      temp = isasc ? temp.orderby(orderbylambda).skip((pageindex - 1) * pagesize).take(pagesize) : temp.orderbydescending(orderbylambda).skip((pageindex - 1) * pagesize).take(pagesize);
      return temp;
    }

    /// <summary>
    /// 删除数据
    /// </summary>
    /// <param name="entity">待删数据</param>
    /// <returns>删除结果</returns>
    public bool deleteentity(userdal entity)
    {
      dbentities.entry(entity).state = entitystate.deleted;
      return true;
    }

    /// <summary>
    /// 编辑数据
    /// </summary>
    /// <param name="entity">待编辑数据</param>
    /// <returns>编辑结果</returns>
    public bool editentity(userdal entity)
    {
      dbentities.entry(entity).state = entitystate.modified;
      return true;
    }

    /// <summary>
    /// 添加数据
    /// </summary>
    /// <param name="entity">待添加数据</param>
    /// <returns>已添加数据</returns>
    public userdal addentity(userdal entity)
    {
      entity = dbentities.set<userdal>().add(entity);
      return entity;
    }    
  }
}

注:这里的增删改操作并不即时进行,而是在封装在数据会话层中,以实现工作单元模式,提高数据库的操作效率。

考虑到每个类都需要实现相同的数据操作,我们可以将以上方法封装到一个泛型基类中,各类型只需要继承泛型基类就可以实现以上方法:

basedal.cs

using system;
using system.data.entity;
using system.linq;

namespace pms.dal
{
  public class basedal<t> where t:class ,new()
  {
    public dbcontext dbentities = dbcontextfactory.createcontext();

    /// <summary>
    /// 查询过滤
    /// </summary>
    /// <param name="wherelamada">过滤条件lambda表达式</param>
    /// <returns>实体集合</returns>
    public iqueryable<t> loadentities(system.linq.expressions.expression<func<t, bool>> wherelamada)
    {
      return dbentities.set<t>().where(wherelamada);
    }

    /// <summary>
    /// 分页查询
    /// </summary>
    /// <typeparam name="ts">排序类型</typeparam>
    /// <param name="pageindex">查询的页码</param>
    /// <param name="pagesize">每页显示的数目</param>
    /// <param name="totalcount">符合条件的总行数</param>
    /// <param name="wherelambda">过滤条件lambda表达式</param>
    /// <param name="orderbylambda">排序lambda表达式</param>
    /// <param name="isasc">排序方向</param>
    /// <returns>实体集合</returns>
    public iqueryable<t> loadpageentities<ts>(int pageindex, int pagesize, out int totalcount, system.linq.expressions.expression<func<t, bool>> wherelambda, system.linq.expressions.expression<func<t, ts>> orderbylambda, bool isasc)
    {
      var temp = dbentities.set<t>().where(wherelambda);
      totalcount = temp.count();
      temp = isasc ? temp.orderby(orderbylambda).skip((pageindex - 1) * pagesize).take(pagesize) : temp.orderbydescending(orderbylambda).skip((pageindex - 1) * pagesize).take(pagesize);
      return temp;
    }

    /// <summary>
    /// 删除数据
    /// </summary>
    /// <param name="entity">待删数据</param>
    /// <returns>删除结果</returns>
    public bool deleteentity(t entity)
    {
      dbentities.entry(entity).state = entitystate.deleted;
      return true;
    }

    /// <summary>
    /// 编辑数据
    /// </summary>
    /// <param name="entity">待编辑数据</param>
    /// <returns>编辑结果</returns>
    public bool editentity(t entity)
    {
      dbentities.entry(entity).state = entitystate.modified;
      return true;
    }

    /// <summary>
    /// 添加数据
    /// </summary>
    /// <param name="entity">待添加数据</param>
    /// <returns>已添加数据</returns>
    public t addentity(t entity)
    {
      entity = dbentities.set<t>().add(entity);
      //dbentities.savechanges();
      return entity;
    }
  }
}

userdal继承basedal

using pms.idal;
using pms.model;

namespace pms.dal
{
  public partial class userdal : basedal<user>
  {
    
  }
}

数据访问接口层的构建

然后我们建立相应的ibasedal接口和iuserdal接口,并且使userdal类实现iuserdal接口

ibasedal:

using system;
using system.linq;

namespace pms.idal
{
  public interface ibasedal<t> where t:class,new()
  {
    iqueryable<t> loadentities(system.linq.expressions.expression<func<t, bool>> wherelamada);

    iqueryable<t> loadpageentities<s>(int pageindex, int pagesize, out int totalcount,
      system.linq.expressions.expression<func<t, bool>> wherelambda,
      system.linq.expressions.expression<func<t, s>> orderbylambda, bool isasc);

    bool deleteentity(t entity);
    
    bool editentity(t entity);

    t addentity(t entity);
  }
}

iuserdal:

using pms.model;
namespace pms.idal
{
  public partial interface iuserdal:ibasedal<user>
  {

  }
}

userdal实现iuserdal接口:

public partial class userdal : basedal<user>,iuserdal

数据会话层的构建

抽象工厂类abstractfactory:

using system.configuration;
using system.reflection;
using pms.idal;

namespace pms.dalfactory
{
  public partial class abstractfactory
  {
    //读取保存在配置文件中的程序集名称与命名空间名
    private static readonly string assemblypath = configurationmanager.appsettings["assemblypath"];
    private static readonly string namespace = configurationmanager.appsettings["namespace"];
    /// <summary>
    /// 获取userdal的实例
    /// </summary>
    /// <returns></returns>
    public static iuserdal createuserinfodal()
    {
      var fullclassname = namespace + ".userinfodal";
      return createinstance(fullclassname) as iuserdal;
    }
    /// <summary>
    /// 通过反射获得程序集中某类型的实例
    /// </summary>
    /// <param name="classname"></param>
    /// <returns></returns>
    private static object createinstance(string classname)
    {
      var assembly = assembly.load(assemblypath);
      return assembly.createinstance(classname);
    }
  }
}

数据会话类dbsession:

using system.data.entity;
using pms.idal;
using pms.dal;

namespace pms.dalfactory
{
  public partial class dbsession:idbsession
  {
    public dbcontext db
    {
      get { return dbcontextfactory.createcontext(); }
    }

    private iuserdal _userdal;
    public iuserdal userdal
    {
      get { return _userdal ?? (_userdal = abstractfactory.createuserinfodal()); }
      set { _userdal = value; }
    }

    /// <summary>
    /// 工作单元模式,统一保存数据
    /// </summary>
    /// <returns></returns>
    public bool savechanges()
    {
      return db.savechanges() > 0;
    }
  }
}

业务逻辑层的构建

业务类基类baseservice

using system;
using system.linq;
using system.linq.expressions;
using pms.dalfactory;
using pms.idal;

namespace pms.bll
{
  public abstract class baseservice<t> where t:class,new()
  {
    public idbsession currentdbsession
    {
      get
      {
        return new dbsession();
      }
    }
    public ibasedal<t> currentdal { get; set; }
    public abstract void setcurrentdal();
    public baseservice()
    {
      setcurrentdal();//子类一定要实现抽象方法,以指明当前类的子类类型。
    }

    /// <summary>
    /// 查询过滤
    /// </summary>
    /// <param name="wherelambda"></param>
    /// <returns></returns>
    public iqueryable<t> loadentities(expression<func<t, bool>> wherelambda)
    {
      return currentdal.loadentities(wherelambda);
    }

    /// <summary>
    /// 分页
    /// </summary>
    /// <typeparam name="s"></typeparam>
    /// <param name="pageindex"></param>
    /// <param name="pagesize"></param>
    /// <param name="totalcount"></param>
    /// <param name="wherelambda"></param>
    /// <param name="orderbylambda"></param>
    /// <param name="isasc"></param>
    /// <returns></returns>
    public iqueryable<t> loadpageentities<s>(int pageindex, int pagesize, out int totalcount, expression<func<t, bool>> wherelambda,
      expression<func<t, s>> orderbylambda, bool isasc)
    {
      return currentdal.loadpageentities<s>(pageindex, pagesize, out totalcount, wherelambda, orderbylambda, isasc);
    }

    /// <summary>
    /// 删除
    /// </summary>
    /// <param name="entity"></param>
    /// <returns></returns>
    public bool deleteentity(t entity)
    {
      currentdal.deleteentity(entity);
      return currentdbsession.savechanges();
    }

    /// <summary>
    /// 编辑
    /// </summary>
    /// <param name="entity"></param>
    /// <returns></returns>
    public bool editentity(t entity)
    {
      currentdal.editentity(entity);
      return currentdbsession.savechanges();
    }

    /// <summary>
    /// 添加数据
    /// </summary>
    /// <param name="entity"></param>
    /// <returns></returns>
    public t addentity(t entity)
    {
      currentdal.addentity(entity);
      currentdbsession.savechanges();
      return entity;
    }
  }
}

userservice类:

using pms.ibll;
using pms.model;

namespace pms.bll
{
  public partial class userservice : baseservice<user>
  {
    public override void setcurrentdal()
    {
      currentdal = currentdbsession.userdal;
    }
  }
}

 

业务逻辑接口层的构建

直接建立对应的接口并使用userservice类实现iuserservice接口

ibaseservice接口:

using system;
using system.linq;
using system.linq.expressions;
using pms.idal;

namespace pms.ibll
{
  public interface ibaseservice<t> where t : class,new()
  {
    idbsession currentdbsession { get; }
    ibasedal<t> currentdal { get; set; }
    void setcurrentdal();
    iqueryable<t> loadentities(expression<func<t, bool>> wherelambda);

    iqueryable<t> loadpageentities<s>(int pageindex, int pagesize, out int totalcount,
      expression<func<t, bool>> wherelambda,
      expression<func<t, s>> orderbylambda, bool isasc);

    bool deleteentity(t entity);
    bool editentity(t entity);
    t addentity(t entity);
  }
}

iuserservice接口:

using pms.model;

namespace pms.ibll
{
  public partial interface iuserservice:ibaseservice<user>
  {

  }
}

使用userservice类实现iuserservice接口:

public partial class userservice : baseservice<user>, iuserservice  

以上我们就完成了整个框架中关于user类的各层次的实现。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。