Asp.Net MVC+BootStrap+EF6.0实现简单的用户角色权限管理2

首先我们来写个类进行获取当前线程内唯一的DbContext

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Runtime.Remoting.Messaging;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.DAL {
    /// <summary>
    /// 当前线程内的数据上下文
    /// </summary>
    public class DbContextFactory {
        /// <summary>
        /// 获取当前线程内的数据上下文，如果当前线程内没有上下文，那么创建一个上下文，
        /// </summary>
        /// <returns>当前线程内的数据上下文</returns>
        public static DbContext GetCurrentDbContext() {
            DbContext currentContext = CallContext.GetData("CurrentDbContext") as DbContext;
            if (currentContext == null) {
                currentContext = new AuthorDesignContext();
                CallContext.SetData("CurrentDbContext", currentContext);
            }
            return currentContext;
        }
    }
}

CallContext 这个类是用来获取当前线程内唯一的数据，可以避免一次性创建出多个数据库上下文。

接下来是对基础的仓储进行编写（DAL）：BaseRepository类

对数据的增删改查操作

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.DAL {
    public class BaseRepository<T> where T : class,new() {

        public DbContext db = DbContextFactory.GetCurrentDbContext();

        /// <summary>
        /// 添加一条记录
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public T AddEntity(T entity) {
            db.Entry<T>(entity).State = EntityState.Added;
            db.SaveChanges();
            return entity;
        }
        /// <summary>
        /// 修改一条记录
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="property">需要修改的字段名称</param>
        /// <returns></returns>
        public bool EditEntity(T entity, string[] property) {
            DbEntityEntry<T> entry = db.Entry<T>(entity);
            entry.State = EntityState.Unchanged;
            foreach (var item in property) {
                entry.Property(item).IsModified = true;
            }
            return db.SaveChanges() > 0;
            //return true;
        }
        /// <summary>
        /// 删除一条记录
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public bool DeleteEntity(T entity) {
            DbEntityEntry<T> entry = db.Entry<T>(entity);
            entry.State = EntityState.Deleted;
            return db.SaveChanges() > 0;
            // return true;
        }
        /// <summary>
        /// 查询列表
        /// </summary>
        /// <returns></returns>
        public IQueryable<T> LoadEntities() {
            return db.Set<T>();
        }
        /// <summary>
        /// 查询
        /// </summary>
        /// <param name="whereLamda">查询条件</param>
        /// <returns></returns>
        public IQueryable<T> LoadEntities(Expression<Func<T, bool>> whereLamda) {
            return db.Set<T>().Where<T>(whereLamda);
        }
        /// <summary>
        /// 对查询结果进行升序排序
        /// </summary>
        /// <typeparam name="S">排序字段类型</typeparam>
        /// <param name="queryable">查询结果</param>
        /// <param name="orderLamda">排序表达式</param>
        /// <returns>根据排序条件排序好之后的排序结果</returns>
        public IOrderedQueryable<T> Order<S>(IQueryable<T> queryable, Expression<Func<T, S>> orderLamda) {
            return queryable.OrderBy(orderLamda);
        }
        /// <summary>
        /// 对排序结果再次进行升序排序
        /// </summary>
        /// <typeparam name="S">排序字段类型</typeparam>
        /// <param name="queryable">根据排序条件排序好之后的排序结果</param>
        /// <param name="orderLamda">排序表达式</param>
        /// <returns>根据排序条件排序好之后的排序结果</returns>
        public IOrderedQueryable<T> ThenOrder<S>(IOrderedQueryable<T> queryable, Expression<Func<T, S>> orderLamda) {
            return queryable.ThenBy(orderLamda);
        }
        /// <summary>
        /// 对查询结果进行降序排序
        /// </summary>
        /// <typeparam name="S">排序字段类型</typeparam>
        /// <param name="queryable">查询结果</param>
        /// <param name="orderLamda">排序表达式</param>
        /// <returns>根据排序条件排序好之后的排序结果</returns>
        public IOrderedQueryable<T> OrderDesc<S>(IQueryable<T> queryable, Expression<Func<T, S>> orderLamda) {
            return queryable.OrderByDescending(orderLamda);
        }
        /// <summary>
        /// 对排序结果再次进行降序排序
        /// </summary>
        /// <typeparam name="S">排序字段类型</typeparam>
        /// <param name="queryable">根据排序条件排序好之后的排序结果</param>
        /// <param name="orderLamda">排序表达式</param>
        /// <returns>根据排序条件排序好之后的排序结果</returns>
        public IOrderedQueryable<T> ThenOrderDesc<S>(IOrderedQueryable<T> queryable, Expression<Func<T, S>> orderLamda) {
            return queryable.ThenByDescending(orderLamda);
        }
        /// <summary>
        /// 对排序结果进行分页操作
        /// </summary>
        /// <param name="queryable">根据排序条件排序好之后的排序结果</param>
        /// <param name="nowNum">跳过序列中指定数量的元素</param>
        /// <param name="pageSize">从序列的开头返回指定数量的连续元素</param>
        /// <returns>指定长度的列表</returns>
        public IQueryable<T> LoadPageEnties(IOrderedQueryable<T> queryable, int nowNum, int pageSize) {
            return queryable.Skip<T>(nowNum + 1).Take<T>(pageSize);
        }
        /// <summary>
        /// 分页查询
        /// </summary>
        /// <typeparam name="S">排序类型</typeparam>
        /// <param name="whereLamda">查询条件</param>
        /// <param name="orderLamda">排序条件</param>
        /// <param name="isDesc">是否倒序</param>
        /// <param name="pageIndex">第几页</param>
        /// <param name="pageSize">页长</param>
        /// <param name="rowCount"></param>
        /// <returns></returns>
        public IQueryable<T> LoadEntities<S>(Expression<Func<T, bool>> whereLamda, Expression<Func<T, S>> orderLamda, bool isDesc, int pageIndex, int pageSize, out int rowCount) {
            var temp = db.Set<T>().Where<T>(whereLamda);
            rowCount = temp.Count();
            if (isDesc)
                temp = temp.OrderByDescending<T, S>(orderLamda).Skip<T>(pageSize * (pageIndex - 1) + 1).Take<T>(pageSize);
            else
                temp = temp.OrderBy<T, S>(orderLamda).Skip<T>(pageSize * (pageIndex - 1) + 1).Take<T>(pageSize);
            return temp;
        }
    }
}

然后管理员类AdminRepository的DAL编写，继承BaseRepository类

using AuthorDesign.IDAL;
using AuthorDesign.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.DAL {
    public class AdminRepository : BaseRepository<Admin>{
    }
}

我要做的是面向接口的（虽然没有BLL这层）那么接下来就对IDAL着层来进行编写，

首先也是IBaseRepository接口

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.IDAL {

    public interface IBaseRepository<T> where T : class,new() {
        /// <summary>
        /// 添加一条记录
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        T AddEntity(T entity);
        /// <summary>
        /// 修改一条记录
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="property">需要修改的字段名称</param>
        /// <returns></returns>
        bool EditEntity(T entity, string[] property);
        /// <summary>
        /// 删除一条记录
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        bool DeleteEntity(T entity);
        /// <summary>
        /// 查询
        /// </summary>
        IQueryable<T> LoadEntities();
        /// <summary>
        /// 查询
        /// </summary>
        /// <param name="whereLamda">查询条件</param>
        /// <returns></returns>
        IQueryable<T> LoadEntities(Expression<Func<T, bool>> whereLamda);
        /// <summary>
        /// 对查询结果进行升序排序
        /// </summary>
        /// <typeparam name="S">排序字段类型</typeparam>
        /// <param name="queryable">查询结果</param>
        /// <param name="orderLamda">排序表达式</param>
        /// <returns>根据排序条件排序好之后的排序结果</returns>
        IOrderedQueryable<T> Order<S>(IQueryable<T> queryable, Expression<Func<T, S>> orderLamda);
        /// <summary>
        /// 对排序结果再次进行升序排序
        /// </summary>
        /// <typeparam name="S">排序字段类型</typeparam>
        /// <param name="queryable">根据排序条件排序好之后的排序结果</param>
        /// <param name="orderLamda">排序表达式</param>
        /// <returns>根据排序条件排序好之后的排序结果</returns>
        IOrderedQueryable<T> ThenOrder<S>(IOrderedQueryable<T> queryable, Expression<Func<T, S>> orderLamda);
        /// <summary>
        /// 对查询结果进行降序排序
        /// </summary>
        /// <typeparam name="S">排序字段类型</typeparam>
        /// <param name="queryable">查询结果</param>
        /// <param name="orderLamda">排序表达式</param>
        /// <returns>根据排序条件排序好之后的排序结果</returns>
        IOrderedQueryable<T> OrderDesc<S>(IQueryable<T> queryable, Expression<Func<T, S>> orderLamda);
        /// <summary>
        /// 对排序结果再次进行降序排序
        /// </summary>
        /// <typeparam name="S">排序字段类型</typeparam>
        /// <param name="queryable">根据排序条件排序好之后的排序结果</param>
        /// <param name="orderLamda">排序表达式</param>
        /// <returns>根据排序条件排序好之后的排序结果</returns>
        IOrderedQueryable<T> ThenOrderDesc<S>(IOrderedQueryable<T> queryable, Expression<Func<T, S>> orderLamda);
        /// <summary>
        /// 对排序结果进行分页操作
        /// </summary>
        /// <param name="queryable">根据排序条件排序好之后的排序结果</param>
        /// <param name="nowNum">跳过序列中指定数量的元素</param>
        /// <param name="pageSize">从序列的开头返回指定数量的连续元素</param>
        /// <returns>指定长度的列表</returns>
        IQueryable<T> LoadPageEnties(IOrderedQueryable<T> queryable, int nowNum, int pageSize);
        /// <summary>
        /// 分页查询
        /// </summary>
        /// <typeparam name="S">排序类型</typeparam>
        /// <param name="whereLamda">查询条件</param>
        /// <param name="orderLamda">排序条件</param>
        /// <param name="isDesc">是否倒序</param>
        /// <param name="pageIndex">第几页</param>
        /// <param name="pageSize">页长</param>
        /// <param name="rowCount"></param>
        /// <returns></returns>
        IQueryable<T> LoadEntities<S>(Expression<Func<T, bool>> whereLamda, Expression<Func<T, S>> orderLamda, bool isDesc, int pageIndex, int pageSize, out int rowCount);
    }
}

然后管理员接口IAdminRepository 继承IBaseRepository

using AuthorDesign.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.IDAL {
    public interface IAdminRepository:IBaseRepository<Admin> {
    }
}

接下来我们更改下原来的 管理员类AdminRepository的DAL编写，引用了IAdminRepository 的接口

using AuthorDesign.IDAL;
using AuthorDesign.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.DAL {
    public class AdminRepository : BaseRepository<Admin>, IAdminRepository {
    }
}

然后对其他Model也进行相同的编写。下面附上代码：

首先是IDAL，接口这里。

using AuthorDesign.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.IDAL {
    public interface IActionToPageRepository : IBaseRepository<ActionToPage> {
    }
}
using AuthorDesign.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.IDAL {
    public interface IAdminLoginLogRepository : IBaseRepository<AdminLoginLog> {
    }
}
using AuthorDesign.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.IDAL {
    public interface IAdminOperationRepository : IBaseRepository<AdminOperation> {
    }
}
using AuthorDesign.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.IDAL {
    public interface IAdminToPageRepository : IBaseRepository<AdminToPage> {
    }
}
using AuthorDesign.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.IDAL {
    public interface IAuthoryRepository : IBaseRepository<Authory> {
    }
}
using AuthorDesign.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.IDAL {
    public interface IAuthoryToPageRepository : IBaseRepository<AuthoryToPage> {
    }
}
using AuthorDesign.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.IDAL {
    public interface IPageActionRepository : IBaseRepository<PageAction> {
    }
}
using AuthorDesign.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.IDAL {
    public interface IPageMenuRepository : IBaseRepository<PageMenu> {
    }
}

其次是DAL。

using AuthorDesign.IDAL;
using AuthorDesign.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.DAL {
    public class ActionToPageRepository : BaseRepository<ActionToPage> ,IActionToPageRepository{
    }
}
using AuthorDesign.IDAL;
using AuthorDesign.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.DAL {
    public class AdminLoginLogRepository : BaseRepository<AdminLoginLog>, IAdminLoginLogRepository {
    }
}
using AuthorDesign.IDAL;
using AuthorDesign.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.DAL {
    public class AdminOperationRepository : BaseRepository<AdminOperation>, IAdminOperationRepository {
    }
}
using AuthorDesign.IDAL;
using AuthorDesign.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.DAL {
    public class AdminToPageRepository : BaseRepository<AdminToPage>, IAdminToPageRepository {
    }
}
using AuthorDesign.IDAL;
using AuthorDesign.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.DAL {
    public class AuthoryRepository : BaseRepository<Authory>, IAuthoryRepository {
    }
}
using AuthorDesign.IDAL;
using AuthorDesign.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.DAL {
    public class AuthoryToPageRepository : BaseRepository<AuthoryToPage>, IAuthoryToPageRepository {
    }
}
using AuthorDesign.IDAL;
using AuthorDesign.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.DAL {
    public class PageActionRepository : BaseRepository<PageAction>, IPageActionRepository {
    }
}
using AuthorDesign.IDAL;
using AuthorDesign.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.DAL {
    public class PageMenuRepository : BaseRepository<PageMenu>,IPageMenuRepository{
    }
}

然后就是写个专门用来对接WEB层与 DAL与IDAL的类。

RepositoryEnter 仓储入口，与web层的交互都交由这个类，附上代码

using AuthorDesign.IDAL;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.DAL {
        /// <summary>
    /// 仓储入口
    /// </summary>
    public class RepositoryEnter:IRepositoryEnter {
        /// <summary>
        /// 统一SaveChange方法
        /// </summary>
        /// <returns></returns>
        public int SaveChange() {
            return DbContextFactory.GetCurrentDbContext().SaveChanges();

        }
        /// <summary>
        /// 获取页面与页面动作联系仓储
        /// </summary>
        public IDAL.IActionToPageRepository GetActionToPageRepository { get { return new ActionToPageRepository(); } }
        /// <summary>
        /// 获取管理员登录日志仓储
        /// </summary>
        public IDAL.IAdminLoginLogRepository GetAdminLoginLogRepository { get { return new AdminLoginLogRepository(); } }
        /// <summary>
        /// 获取管理员操作仓储
        /// </summary>
        public IDAL.IAdminOperationRepository GetAdminOperationRepository { get { return new AdminOperationRepository(); } }
        /// <summary>
        /// 获取管理员仓储
        /// </summary>
        public IDAL.IAdminRepository GetAdminRepository { get { return new AdminRepository(); } }
        /// <summary>
        /// 获取管理员与页面仓储
        /// </summary>
        public IDAL.IAdminToPageRepository GetAdminToPageRepository { get { return new AdminToPageRepository(); } }
        /// <summary>
        /// 获取角色仓储
        /// </summary>
        public IDAL.IAuthoryRepository GetAuthoryRepository { get { return new AuthoryRepository(); } }
        /// <summary>
        /// 获取角色与页面仓储
        /// </summary>
        public IDAL.IAuthoryToPageRepository GetAuthoryToPageRepository { get { return new AuthoryToPageRepository(); } }
        /// <summary>
        /// 获取页面动作仓储
        /// </summary>
        public IDAL.IPageActionRepository GetPageActionRepository { get { return new PageActionRepository(); } }
        /// <summary>
        /// 获取页面仓储
        /// </summary>
        public IDAL.IPageMenuRepository GetPageMenuRepository { get { return new PageMenuRepository(); } }
    }
}

IRepositoryEnter接口

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AuthorDesign.IDAL {
    /// <summary>
    /// 仓储入口
    /// </summary>
    public interface IRepositoryEnter {
        /// <summary>
        /// 统一SaveChange方法
        /// </summary>
        /// <returns></returns>
        int SaveChange();
        /// <summary>
        /// 获取页面与页面动作联系仓储
        /// </summary>
        IDAL.IActionToPageRepository GetActionToPageRepository { get; }
        /// <summary>
        /// 获取管理员登录日志仓储
        /// </summary>
        IDAL.IAdminLoginLogRepository GetAdminLoginLogRepository { get; }
        /// <summary>
        /// 获取管理员操作仓储
        /// </summary>
        IDAL.IAdminOperationRepository GetAdminOperationRepository { get; }
        /// <summary>
        /// 获取管理员仓储
        /// </summary>
        IDAL.IAdminRepository GetAdminRepository { get; }
        /// <summary>
        /// 获取管理员与页面仓储
        /// </summary>
        IDAL.IAdminToPageRepository GetAdminToPageRepository { get; }
        /// <summary>
        /// 获取角色仓储
        /// </summary>
        IDAL.IAuthoryRepository GetAuthoryRepository { get; }
        /// <summary>
        /// 获取角色与页面仓储
        /// </summary>
        IDAL.IAuthoryToPageRepository GetAuthoryToPageRepository { get; }
        /// <summary>
        /// 获取页面动作仓储
        /// </summary>
        IDAL.IPageActionRepository GetPageActionRepository { get; }
        /// <summary>
        /// 获取页面仓储
        /// </summary>
        IDAL.IPageMenuRepository GetPageMenuRepository { get; }
    }
}

对DAL于IDAL的一些编写就到这里，我感觉自己讲的很乱，好像没有什么主次之分。如果各位又不懂的或者感觉那里错了的，还请告诉我。

这里是源码下载地址：https://github.com/yjqGitHub/AuthorDesign 我会把源码都更新上去的

时间： 2024-10-13 22:27:52

Asp.Net MVC+BootStrap+EF6.0实现简单的用户角色权限管理2的相关文章

Asp.Net MVC+BootStrap+EF6.0实现简单的用户角色权限管理

这是本人第一次写,写的不好的地方还忘包含.写这个的主要原因是翔通过这个来学习下EF的CodeFirst模式,本来也想用AngularJs来玩玩的,但是自己只会普通的绑定,对指令这些不是很熟悉,所以就基本不用了.还有最主要的原因就是锻炼下自己的能力.好了其他就不多说了,下面来看下我对这个项目的整体概述吧: 目录: 目录我以后会在这边添加上去的 一.Asp.Net MVC+BootStrap+EF6.0实现简单的用户角色权限管理 基本设计 项目中使用到的工具: Visual Studio 2013,

Asp.Net MVC+BootStrap+EF6.0实现简单的用户角色权限管理10

今天把用户的菜单显示和页面的按钮显示都做好了,下面先来个效果图 接下来说下我实现的方法: 首先我在每个方法前面都加了这个属性, /// <summary> /// 表示当前Action请求为一个具体的功能页面 /// </summary> public class AdminActionMethod : Attribute { /// <summary> /// 页面请求路径 /// </summary> public string ActionUrl {

Asp.Net MVC+BootStrap+EF6.0实现简单的用户角色权限管理9

前两天因有事就没来得及写.今天刚刚好空了.这次写的是对角色和管理员对页面按钮之间的控制.先看页面效果 说明:先根据角色设置好角色的权限,然后管理员在对应的角色下的权限去设置其权限. 在设置角色权限的时候 当某个角色对应某个页面的按钮都是未选中的时候,则设置它的IsShow为0,反之则为1,这样有利于设置管理员的时候方便查询需要设置的页面. 当isshow为0的时候删除管理员表对应的该页面Id的记录. 角色和管理员页面按钮显示这块到这里就结束了. 百度网盘源码下载地址

Asp.Net MVC+BootStrap+EF6.0实现简单的用户角色权限管理6

接下来先做角色这一板块的(增删改查),首先要新建一个Role控制器,在添加一个RoleList的视图.表格打算采用的是bootstrap的表格. using System; using System.Collections.Generic; using System.Linq; using System.Web; using System.Web.Mvc; namespace AuthorDesign.Web.Areas.Admin.Controllers { public class Role

Asp.Net MVC+BootStrap+EF6.0实现简单的用户角色权限管理7

做完角色之后接下来做先做页面按钮的增加.删除.修改.这里用到的功能和角色那边是一样的.就不多说了.直接上代码. 后台控制器代码 using AuthorDesign.Web.App_Start.Common; using System; using System.Collections.Generic; using System.Linq; using System.Web; using System.Web.Mvc; namespace AuthorDesign.Web.Areas.Admin

Asp.Net MVC+BootStrap+EF6.0实现简单的用户角色权限管理1

首先给上项目的整体框架图:,这里我没有使用BLL,因为感觉太烦了就没有去使用. 那么接下来我们首先先去Model层中添加Model. 管理员类: using System; using System.Collections.Generic; using System.ComponentModel.DataAnnotations; using System.ComponentModel.DataAnnotations.Schema; using System.Linq; using System.

Asp.Net MVC+BootStrap+EF6.0实现简单的用户角色权限管理3

首先在webconfig中加入下面这句代码,这个主要是用来生成数据库的连接字符串 <connectionStrings> <add name="AuthorDesignContext" providerName="System.Data.SqlClient" connectionString="Data Source=.;Initial Catalog=AuthorDesign;Integrated Security=False;User

ASP.NET MVC使用Bootstrap系列（5）——创建ASP.NET MVC Bootstrap Helpers

序言 ASP.NET MVC允许开发者创建自定义的HTML Helpers,不管是使用静态方法还是扩展方法.一个HTML Helper本质上其实是输出一段HTML字符串. HTML Helpers能让我们在多个页面上公用同一段HTML标记,这样不仅提高了稳定性也便于开发者去维护.当然对于这些可重用的代码,开发者也方便对他们进行单元测试.所以,创建ASP.NET MVC Bootstrap Helpers是及其有必要的. 内置的HTML Helpers ASP.NET MVC内置了若干标准HTML

ASP.NET MVC Bootstrap极速开发框架

前言 每次新开发项目都要从头开始设计?有木有一个通用的快速开发框架?并且得是ASP.NET MVC  And Bootstrap?数据库不要手工创建?框架对未来业务支持的扩展性好?这么简单的功能还需要一天搭建基础环境?能不能只关心我所需要的业务? 有这样的一个项目,基于ASP.NET MVC.EntityFramework.Memcached.Bootstrap的快速项目开发框架,只需3秒钟即可创建一个带有简单用户管理的项目. 一键安装 懒人一键安装包下载地址,双击“install.bat”批处