Asp.net MVC 搭建属于自己的框架（一）

为什么要自己搭框架？

　　大家伙别急，让我慢慢地告诉你！大家有没有这种感觉，从一家跳槽到另一家公司，公司的框架往往是不相同的，这样你必须就得摒弃原来的，学习新的框架。

问题是你用习惯了一种框架，比如封装的扩展方法、工厂模式、实体映射等等，你用得很爽，但是跳槽到新的公司，又得学习他们公司的框架，往往你在这上面

要花费不少时间。

所以我才有了搭建自己的框架的想法，我的框架用到了EntityFramework6.0+Asp.NET MVC4+Autofac等，下面是我的框架结构：

 

MyFrame.Domain 实体模型层

MyFrame.DataMapping 数据映射层：映射实体类和数据库表关系，数据库上下文存放在该层

MyFrame.IDao 数据访问接口层

MyFrame.Dao 数据访问层

MyFrame.IService 业务逻辑接口层

MyFrame.Service 业务逻辑层

MyFrame.Common 通用扩展层

MyFrame.Web UI层

层与层之间的引用关系

　　Domain（最低层）=》每个层调用；IDao=>Dao,Service; IService=>Service ; IDao,IService=>Web

实体基类
　　MyFrame.Domain.DomainBase：实体基类，实体类都需要继承DomainBase，现在这个类只有两个属性，等之后慢慢扩展完善　　

using System;

namespace MyFrame.Domain
{
    /// <summary>
    /// 实体基类
    /// </summary>
    public class DomainBase
    {
        /// <summary>
        /// 编号
        /// </summary>
        public int Id { get; set; }

        /// <summary>
        /// 创建时间
        /// </summary>
        public DateTime CreateTime { get; set; }
    }
}

数据访问基类接口　

MyFrame.IDao.IDaoBase：封装了增删改查方法以及分页等

using System.Collections.Generic;
using PagedList;

namespace MyFrame.IDao
{
    /// <summary>
    /// 数据访问层的基类接口
    /// </summary>
    public interface IDaoBase<T> where T:class 
    {
        /// <summary>
        /// 增加
        /// </summary>
        /// <param name="domain">实体</param>
        /// <returns></returns>
        int Insert(T domain);

        /// <summary>
        /// 通过Id删除
        /// </summary>
        /// <param name="id">Id</param>
        /// <returns></returns>
        bool Delete(int id);

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="domain">实体</param>
        /// <returns></returns>
        bool Delete(T domain);

        /// <summary>
        /// 更新操作
        /// </summary>
        /// <param name="domain">实体</param>
        /// <returns></returns>
        bool Update(T domain);

        /// <summary>
        /// 通过Id查询
        /// </summary>
        /// <param name="id">Id</param>
        /// <returns></returns>
        T SelectById(int id);

        /// <summary>
        /// 查询所有
        /// </summary>
        /// <returns></returns>
        IEnumerable<T> SelectAll();

        /// <summary>
        /// 分页查询
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        IPagedList<T> SelectPageList(int? pageIndex = 1, int? pageSize = 10);
    }
}

数据访问实现基类

MyFrame.Dao.DaoBase：需要继承IDaoBase,IDisposable

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using MyFrame.Domain;
using MyFrame.IDao;
using MyFrame.DataMapping;
using PagedList;

namespace MyFrame.Dao
{
    /// <summary>
    /// 数据访问层基类
    /// </summary>
    public class DaoBase<T>  : IDisposable, IDaoBase<T> where T : DomainBase 
    {
        protected readonly DbContext DbContext;

        public DaoBase()
        {
            DbContext = new DataBaseContext();
        }

        public  int Insert(T t)
        {
            t.CreateTime = DateTime.Now;
            DbContext.Entry<T>(t);
            DbContext.Set<T>().Add(t);
            return SaveChanges();
        }

        public bool Delete(int id)
        {
            T domain = DbContext.Set<T>().FirstOrDefault(s => s.Id == id);
            if (domain == null)
                return false;
            DbContext.Set<T>().Attach(domain);
            DbContext.Set<T>().Remove(domain);
            return SaveChanges() > 0;
        }

        public bool Delete(T t)
        {
            DbContext.Set<T>().Attach(t);
            DbContext.Set<T>().Remove(t);
            return SaveChanges() > 0;
        }

        public bool Update(T t)
        {
            DbContext.Set<T>().Attach(t);
            DbContext.Entry(t).State = EntityState.Modified;
            return SaveChanges() > 0;
        }

        public T SelectById(int id)
        {
            return DbContext.Set<T>().FirstOrDefault(s => s.Id == id);
        }

        public IEnumerable<T> SelectAll()
        {
            return DbContext.Set<T>();
        }

        public IPagedList<T> SelectPageList(int? pageIndex, int? pageSize)
        {
            IEnumerable<T> list = DbContext.Set<T>().OrderByDescending(s=>s.CreateTime);
            return list.ToPagedList(pageIndex??1,pageSize??10);
        }

        /// <summary>
        /// 提交数据库操作进行异常捕捉
        /// </summary>
        /// <returns></returns>
        private int SaveChanges()
        {
            try
            {
                int result = DbContext.SaveChanges();
                return result;
            }
            catch (System.Data.Entity.Infrastructure.DbUpdateException ex)
            {
                string message = "error:";
                if (ex.InnerException == null)
                    message += ex.Message + ",";
                else if (ex.InnerException.InnerException == null)
                    message += ex.InnerException.Message + ",";
                else if (ex.InnerException.InnerException.InnerException == null)
                    message += ex.InnerException.InnerException.Message + ",";
                throw new Exception(message);
            }
        }

        public void Dispose()
        {
            DbContext.Dispose();
        }
    }
}

数据库访问上下文

MyFrame.DataMapping.DataBaseContext

using System.Data.Entity;
using MyFrame.DataMapping.Mapping;
using MyFrame.Domain;

namespace MyFrame.DataMapping
{
    /// <summary>
    /// 数据库访问上下文
    /// </summary>
    public class DataBaseContext : DbContext
    {
        public DataBaseContext()
            : base("Name=EhiBus")
        {
            Database.SetInitializer<DataBaseContext>(null);
        }
        //实体类
        public DbSet<User> Users { get; set; }
        public DbSet<Driver> Drivers { get; set; }
        //将实体映射到数据库表
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Configurations.Add(new UserMap());
            modelBuilder.Configurations.Add(new DriverMap());
        }
        
    }
}

using System.Data.Entity.ModelConfiguration;
using MyFrame.Domain;

namespace MyFrame.DataMapping.Mapping
{
    public class UserMap : EntityTypeConfiguration<User>
    {
        public UserMap()
        {
            this.HasKey(t => t.Id);
            this.ToTable("User");
            this.Property(t => t.Id).HasColumnName("Id");
            this.Property(t => t.CreateTime).HasColumnName("CreateTime");
        }
    }
}

扩展帮助类

MyFrame.Common.Helper：封装了一些常用的方法，我自己用起来比较顺手，增加自己的开发效率

using System;

namespace MyFrame.Common
{
    public static class Helper
    {
        #region 字符串转换为Int
        /// <summary>
        /// 将字符串转换为Int?类型
        /// </summary>
        public static int? ToInt32(this string s)
        {
            int? num;
            try
            {
                num = Convert.ToInt32(s);
            }
            catch (FormatException formatException)
            {
                num = null;
            }
            catch (OverflowException overflowException)
            {
                num = null;
            }
            return num;
        }
        
        /// <summary>
        /// 将字符串转换为Int类型
        /// </summary>
        public static int ToInt32Req(this string s)
        {
            try
            {
                int num = Convert.ToInt32(s);
                return num;
            }
            catch (FormatException ex)
            {
                throw new Exception(ex.Message);
            }
            catch (OverflowException overflowException)
            {
                throw new Exception(overflowException.Message);
            }
        }
        #endregion

        #region 字符串转换为Decimal
        /// <summary>
        /// 将字符串转换为Decimal?类型
        /// </summary>
        public static decimal? ToDecimal(this string s)
        {
            decimal? num;
            try
            {
                num = Convert.ToDecimal(s);
            }
            catch (Exception formatException)
            {
                num = null;
            }
            return num;
        }

        /// <summary>
        /// 将字符串转换为Decimal类型,无法转换抛出异常
        /// </summary>
        public static decimal ToDecimalReq(this string s)
        {
            try
            {
                decimal num = Convert.ToDecimal(s);
                return num;
            }
            catch (FormatException ex)
            {
                throw new Exception(ex.Message);
            }
            catch (OverflowException overflowException)
            {
                throw new Exception(overflowException.Message);
            }
        }
        #endregion

        #region 字符串转换为DateTime
        /// <summary>
        /// 将字符串转换为DateTime?类型
        /// </summary>
        public static DateTime? ToDateTime(this string s)
        {
            DateTime? num;
            try
            {
                num = Convert.ToDateTime(s);
            }
            catch (FormatException formatException)
            {
                num = null;
            }
            return num;
        }

        /// <summary>
        /// 将字符串转换为DateTime类型,无法转换抛出异常
        /// </summary>
        public static DateTime ToDateTimeReq(this string s)
        {
            try
            {
                DateTime num = Convert.ToDateTime(s);
                return num;
            }
            catch (FormatException ex)
            {
                throw new Exception(ex.Message);
            }
        }
        #endregion

        #region 字符串转换为bool
        /// <summary>
        /// 将字符串转换为bool?类型
        /// </summary>
        public static bool? ToBool(this string s)
        {
            bool? num;
            try
            {
                num = Convert.ToBoolean(s);
            }
            catch (FormatException formatException)
            {
                num = null;
            }
            return num;
        }

        /// <summary>
        /// 将字符串转换为bool类型,无法转换抛出异常
        /// </summary>
        public static bool ToBoolReq(this string s)
        {
            try
            {
                bool num = Convert.ToBoolean(s);
                return num;
            }
            catch (FormatException ex)
            {
                throw new Exception(ex.Message);
            }
        }
        #endregion

        #region 根据Text转换为Enum
        /// <summary>
        /// 根据Text转换为Enum?类型
        /// </summary>
        public static T? ToEnumByText<T>(this string s) where T:struct 
        {
            T? t;
            try
            {
                t = (T) Enum.Parse(typeof (T), s);
            }
            catch (Exception ex)
            {
                t = null;
            }
            return t;
        }

        /// <summary>
        ///根据Text转换为Enum类型,无法转换抛出异常
        /// </summary>
        public static T ToEnumReqByText<T>(this string s) where T : struct 
        {

            try
            {
                T t= (T)Enum.Parse(typeof (T), s);
                return t;
            }
            catch (ArgumentNullException argumentNullException)
            {
                throw new Exception(argumentNullException.Message);
            }
            catch (ArgumentException argumentException)
            {
                throw new Exception(argumentException.Message);
            }
            catch (OverflowException overflowException)
            {
                throw new Exception(overflowException.Message);
            }
        }
        #endregion

        #region 根据Value转换为Enum
        /// <summary>
        /// 根据Value转换为Enum?类型
        /// </summary>
        public static T? ToEnumByValue<T>(this int s) where T : struct
        {
            T? t;
            try
            {
                t = (T)Enum.Parse(typeof(T), s.ToString());
            }
            catch (Exception ex)
            {
                t = null;
            }
            return t;
        }

        /// <summary>
        ///根据Value转换为Enum类型,无法转换抛出异常
        /// </summary>
        public static T ToEnumByValueReq<T>(this int s) where T : struct
        {

            try
            {
                T t = (T)Enum.Parse(typeof(T), s.ToString());
                return t;
            }
            catch (ArgumentNullException argumentNullException)
            {
                throw new Exception(argumentNullException.Message);
            }
            catch (ArgumentException argumentException)
            {
                throw new Exception(argumentException.Message);
            }
            catch (OverflowException overflowException)
            {
                throw new Exception(overflowException.Message);
            }
        }
        #endregion

        
    }
}

分页控件

我用得是PagedList，Nuget里搜索安装PagedList.MVC即可，然后自己封装了一下，封装得在DaoBase里SelectPageList()

为了让这个控件扩展性更强，写了一个分部试图_PageList,定义了一个分页Model,

为什么要自己写个而不是用它自己封装好的，因为后期页码可能需要跳转“首页”，”末页“等

using PagedList;

namespace MyFrame.Web.Models
{
    public class PageListModel<T> where T:class 
    {
        public IPagedList<T> PageList { get; set; }

        public string Action { get; set; }

        public string Controller { get; set; }
    }
}

<div class="page-box">
    @if (Model.PageList.HasPreviousPage)
    {
        <a href="@Url.Action(Model.Action, Model.Controller, new { pageIndex = (Model.PageList.PageNumber - 1) })">上一页</a>
    }
    @for (int i = 1; i <= Model.PageList.PageCount; i++)
    {
        <a class="@(i == Model.PageList.PageNumber ? "currentpage" : "")" href="@Url.Action(Model.Action, Model.Controller, new { pageIndex = i })">@i</a>
    }
    @if (Model.PageList.HasNextPage)
    {
        <a href="@Url.Action(Model.Action, Model.Controller, new { pageIndex = (Model.PageList.PageNumber + 1) })">下一页</a>
    }
</div>

分页css

/*分页*/
.page-box{ width:770px; height:40px; background:#FFF; padding-top:15px; text-align:right; padding-right:20px;}
.page-box a{text-decoration: none; padding:3px 7px; display:inline-block; text-align:center; border:1px solid #CFCFCF; color:#666; font-size:12px;}
.page-box a:hover{ background:#A4A4A4; color:#fff;}
.page-box .currentpage{ background:#CCC;}

怎么调用呢？跟调用分部试图方法一样，只是需要传进一个PageListModel

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using MyFrame.Common;
using MyFrame.Domain;
using MyFrame.Dao;
using MyFrame.IDao;
using PagedList;

namespace MyFrame.Web.Controllers
{
    public class HomeController : Controller
    {
        private readonly IUserDao _userDao;
        private readonly IDriverDao _driverDao;
        public HomeController(IUserDao userDao,IDriverDao driverDao)
        {
            _userDao = userDao;
            _driverDao = driverDao;
        }

        public ActionResult Index(int? pageIndex=1)
        {
            IPagedList<Driver> drivers = _driverDao.SelectPageList(pageIndex,2);
            return View(drivers);
        }

    }
}

@using MyFrame.Domain
@using MyFrame.Web.Models
@model PagedList.IPagedList<MyFrame.Domain.Driver>
@{
    ViewBag.Title = "Index";
    Layout = "~/Views/Shared/_Layout.cshtml";
}

@foreach (var driver in Model)
{
    <p>@driver.Id</p>
    <p>@driver.DriverName</p>
    <p>@driver.Phone</p>

}

@Html.Partial("_PageList", new PageListModel<Driver> { PageList = Model, Action = "Index", Controller = "Home" })

Autofac组件

控制反转，类似于Ioc容器的组件，通过配置接口对应具体的实现类

然后调用我们只需要调接口就行了，降低耦合性。

组件Nuget里有自己下载安装就行

在Globl.asax里配置

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Web;
using System.Web.Http;
using System.Web.Mvc;
using System.Web.Optimization;
using System.Web.Routing;
using Autofac;
using Autofac.Integration.Mvc;
using MyFrame.Common;
using MyFrame.Dao;
using MyFrame.IDao;
using MyFrame.IService;
using MyFrame.Service;

namespace MyFrame.Web
{
    // 注意: 有关启用 IIS6 或 IIS7 经典模式的说明，
    // 请访问 http://go.microsoft.com/?LinkId=9394801

    public class MvcApplication : System.Web.HttpApplication
    {

        private void SetupResolveRules(ContainerBuilder builder)
        {
            //Components are wired to services using the As() methods on ContainerBuilder
            builder.RegisterType<UserDao>().As<IUserDao>();
            builder.RegisterType<UserService>().As<IUserService>();
            builder.RegisterType<DriverDao>().As<IDriverDao>();
        }
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();

            // 依赖注入
            var builder = new ContainerBuilder();
            SetupResolveRules(builder);
            builder.RegisterControllers(Assembly.GetExecutingAssembly());
            var container = builder.Build();
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
        }
    }
}

通过控制器里的构造方法，调用即可

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using MyFrame.Common;
using MyFrame.Domain;
using MyFrame.Dao;
using MyFrame.IDao;
using PagedList;

namespace MyFrame.Web.Controllers
{
    public class HomeController : Controller
    {
        private readonly IUserDao _userDao;
        private readonly IDriverDao _driverDao;
        public HomeController(IUserDao userDao,IDriverDao driverDao)
        {
            _userDao = userDao;
            _driverDao = driverDao;
        }

        public ActionResult Index(int? pageIndex=1)
        {
            IPagedList<Driver> drivers = _driverDao.SelectPageList(pageIndex,2);
            return View(drivers);
        }

    }
}

其实配置接口对应哪个具体实体的关系，应该放到config文件比较好，这个后期再慢慢优化把。

结尾

这是一个初级版本，后期肯定要再好好完善，比如加入Transaction事务管理，排序，条件查询等等。

大家如果有什么好的建议，尽管提，互相促进互相学习。

转载请注明出处，谢谢！

源代码下载地址：http://yun.baidu.com/share/link?shareid=2761504180&uk=2820969304