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

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Data.Entity;
  4. using System.Linq;
  5. using System.Runtime.Remoting.Messaging;
  6. using System.Text;
  7. using System.Threading.Tasks;
  8.  
  9. namespace AuthorDesign.DAL {
  10. /// <summary>
  11. /// 当前线程内的数据上下文
  12. /// </summary>
  13. public class DbContextFactory {
  14. /// <summary>
  15. /// 获取当前线程内的数据上下文,如果当前线程内没有上下文,那么创建一个上下文,
  16. /// </summary>
  17. /// <returns>当前线程内的数据上下文</returns>
  18. public static DbContext GetCurrentDbContext() {
  19. DbContext currentContext = CallContext.GetData("CurrentDbContext") as DbContext;
  20. if (currentContext == null) {
  21. currentContext = new AuthorDesignContext();
  22. CallContext.SetData("CurrentDbContext", currentContext);
  23. }
  24. return currentContext;
  25. }
  26. }
  27. }

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

接下来是对基础的仓储进行编写(DAL):BaseRepository类

对数据的增删改查操作

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Data.Entity;
  4. using System.Data.Entity.Infrastructure;
  5. using System.Linq;
  6. using System.Linq.Expressions;
  7. using System.Text;
  8. using System.Threading.Tasks;
  9.  
  10. namespace AuthorDesign.DAL {
  11. public class BaseRepository<T> where T : class,new() {
  12.  
  13. public DbContext db = DbContextFactory.GetCurrentDbContext();
  14.  
  15. /// <summary>
  16. /// 添加一条记录
  17. /// </summary>
  18. /// <param name="entity"></param>
  19. /// <returns></returns>
  20. public T AddEntity(T entity) {
  21. db.Entry<T>(entity).State = EntityState.Added;
  22. db.SaveChanges();
  23. return entity;
  24. }
  25. /// <summary>
  26. /// 修改一条记录
  27. /// </summary>
  28. /// <param name="entity"></param>
  29. /// <param name="property">需要修改的字段名称</param>
  30. /// <returns></returns>
  31. public bool EditEntity(T entity, string[] property) {
  32. DbEntityEntry<T> entry = db.Entry<T>(entity);
  33. entry.State = EntityState.Unchanged;
  34. foreach (var item in property) {
  35. entry.Property(item).IsModified = true;
  36. }
  37. return db.SaveChanges() > ;
  38. //return true;
  39. }
  40. /// <summary>
  41. /// 删除一条记录
  42. /// </summary>
  43. /// <param name="entity"></param>
  44. /// <returns></returns>
  45. public bool DeleteEntity(T entity) {
  46. DbEntityEntry<T> entry = db.Entry<T>(entity);
  47. entry.State = EntityState.Deleted;
  48. return db.SaveChanges() > ;
  49. // return true;
  50. }
  51. /// <summary>
  52. /// 查询列表
  53. /// </summary>
  54. /// <returns></returns>
  55. public IQueryable<T> LoadEntities() {
  56. return db.Set<T>();
  57. }
  58. /// <summary>
  59. /// 查询
  60. /// </summary>
  61. /// <param name="whereLamda">查询条件</param>
  62. /// <returns></returns>
  63. public IQueryable<T> LoadEntities(Expression<Func<T, bool>> whereLamda) {
  64. return db.Set<T>().Where<T>(whereLamda);
  65. }
  66. /// <summary>
  67. /// 对查询结果进行升序排序
  68. /// </summary>
  69. /// <typeparam name="S">排序字段类型</typeparam>
  70. /// <param name="queryable">查询结果</param>
  71. /// <param name="orderLamda">排序表达式</param>
  72. /// <returns>根据排序条件排序好之后的排序结果</returns>
  73. public IOrderedQueryable<T> Order<S>(IQueryable<T> queryable, Expression<Func<T, S>> orderLamda) {
  74. return queryable.OrderBy(orderLamda);
  75. }
  76. /// <summary>
  77. /// 对排序结果再次进行升序排序
  78. /// </summary>
  79. /// <typeparam name="S">排序字段类型</typeparam>
  80. /// <param name="queryable">根据排序条件排序好之后的排序结果</param>
  81. /// <param name="orderLamda">排序表达式</param>
  82. /// <returns>根据排序条件排序好之后的排序结果</returns>
  83. public IOrderedQueryable<T> ThenOrder<S>(IOrderedQueryable<T> queryable, Expression<Func<T, S>> orderLamda) {
  84. return queryable.ThenBy(orderLamda);
  85. }
  86. /// <summary>
  87. /// 对查询结果进行降序排序
  88. /// </summary>
  89. /// <typeparam name="S">排序字段类型</typeparam>
  90. /// <param name="queryable">查询结果</param>
  91. /// <param name="orderLamda">排序表达式</param>
  92. /// <returns>根据排序条件排序好之后的排序结果</returns>
  93. public IOrderedQueryable<T> OrderDesc<S>(IQueryable<T> queryable, Expression<Func<T, S>> orderLamda) {
  94. return queryable.OrderByDescending(orderLamda);
  95. }
  96. /// <summary>
  97. /// 对排序结果再次进行降序排序
  98. /// </summary>
  99. /// <typeparam name="S">排序字段类型</typeparam>
  100. /// <param name="queryable">根据排序条件排序好之后的排序结果</param>
  101. /// <param name="orderLamda">排序表达式</param>
  102. /// <returns>根据排序条件排序好之后的排序结果</returns>
  103. public IOrderedQueryable<T> ThenOrderDesc<S>(IOrderedQueryable<T> queryable, Expression<Func<T, S>> orderLamda) {
  104. return queryable.ThenByDescending(orderLamda);
  105. }
  106. /// <summary>
  107. /// 对排序结果进行分页操作
  108. /// </summary>
  109. /// <param name="queryable">根据排序条件排序好之后的排序结果</param>
  110. /// <param name="nowNum">跳过序列中指定数量的元素</param>
  111. /// <param name="pageSize">从序列的开头返回指定数量的连续元素</param>
  112. /// <returns>指定长度的列表</returns>
  113. public IQueryable<T> LoadPageEnties(IOrderedQueryable<T> queryable, int nowNum, int pageSize) {
  114. return queryable.Skip<T>(nowNum + ).Take<T>(pageSize);
  115. }
  116. /// <summary>
  117. /// 分页查询
  118. /// </summary>
  119. /// <typeparam name="S">排序类型</typeparam>
  120. /// <param name="whereLamda">查询条件</param>
  121. /// <param name="orderLamda">排序条件</param>
  122. /// <param name="isDesc">是否倒序</param>
  123. /// <param name="pageIndex">第几页</param>
  124. /// <param name="pageSize">页长</param>
  125. /// <param name="rowCount"></param>
  126. /// <returns></returns>
  127. public IQueryable<T> LoadEntities<S>(Expression<Func<T, bool>> whereLamda, Expression<Func<T, S>> orderLamda, bool isDesc, int pageIndex, int pageSize, out int rowCount) {
  128. var temp = db.Set<T>().Where<T>(whereLamda);
  129. rowCount = temp.Count();
  130. if (isDesc)
  131. temp = temp.OrderByDescending<T, S>(orderLamda).Skip<T>(pageSize * (pageIndex - ) + ).Take<T>(pageSize);
  132. else
  133. temp = temp.OrderBy<T, S>(orderLamda).Skip<T>(pageSize * (pageIndex - ) + ).Take<T>(pageSize);
  134. return temp;
  135. }
  136. }
  137. }

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

  1. using AuthorDesign.IDAL;
  2. using AuthorDesign.Model;
  3. using System;
  4. using System.Collections.Generic;
  5. using System.Linq;
  6. using System.Text;
  7. using System.Threading.Tasks;
  8.  
  9. namespace AuthorDesign.DAL {
  10. public class AdminRepository : BaseRepository<Admin>{
  11. }
  12. }

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

首先也是IBaseRepository接口

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Linq.Expressions;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7.  
  8. namespace AuthorDesign.IDAL {
  9.  
  10. public interface IBaseRepository<T> where T : class,new() {
  11. /// <summary>
  12. /// 添加一条记录
  13. /// </summary>
  14. /// <param name="entity"></param>
  15. /// <returns></returns>
  16. T AddEntity(T entity);
  17. /// <summary>
  18. /// 修改一条记录
  19. /// </summary>
  20. /// <param name="entity"></param>
  21. /// <param name="property">需要修改的字段名称</param>
  22. /// <returns></returns>
  23. bool EditEntity(T entity, string[] property);
  24. /// <summary>
  25. /// 删除一条记录
  26. /// </summary>
  27. /// <param name="entity"></param>
  28. /// <returns></returns>
  29. bool DeleteEntity(T entity);
  30. /// <summary>
  31. /// 查询
  32. /// </summary>
  33. IQueryable<T> LoadEntities();
  34. /// <summary>
  35. /// 查询
  36. /// </summary>
  37. /// <param name="whereLamda">查询条件</param>
  38. /// <returns></returns>
  39. IQueryable<T> LoadEntities(Expression<Func<T, bool>> whereLamda);
  40. /// <summary>
  41. /// 对查询结果进行升序排序
  42. /// </summary>
  43. /// <typeparam name="S">排序字段类型</typeparam>
  44. /// <param name="queryable">查询结果</param>
  45. /// <param name="orderLamda">排序表达式</param>
  46. /// <returns>根据排序条件排序好之后的排序结果</returns>
  47. IOrderedQueryable<T> Order<S>(IQueryable<T> queryable, Expression<Func<T, S>> orderLamda);
  48. /// <summary>
  49. /// 对排序结果再次进行升序排序
  50. /// </summary>
  51. /// <typeparam name="S">排序字段类型</typeparam>
  52. /// <param name="queryable">根据排序条件排序好之后的排序结果</param>
  53. /// <param name="orderLamda">排序表达式</param>
  54. /// <returns>根据排序条件排序好之后的排序结果</returns>
  55. IOrderedQueryable<T> ThenOrder<S>(IOrderedQueryable<T> queryable, Expression<Func<T, S>> orderLamda);
  56. /// <summary>
  57. /// 对查询结果进行降序排序
  58. /// </summary>
  59. /// <typeparam name="S">排序字段类型</typeparam>
  60. /// <param name="queryable">查询结果</param>
  61. /// <param name="orderLamda">排序表达式</param>
  62. /// <returns>根据排序条件排序好之后的排序结果</returns>
  63. IOrderedQueryable<T> OrderDesc<S>(IQueryable<T> queryable, Expression<Func<T, S>> orderLamda);
  64. /// <summary>
  65. /// 对排序结果再次进行降序排序
  66. /// </summary>
  67. /// <typeparam name="S">排序字段类型</typeparam>
  68. /// <param name="queryable">根据排序条件排序好之后的排序结果</param>
  69. /// <param name="orderLamda">排序表达式</param>
  70. /// <returns>根据排序条件排序好之后的排序结果</returns>
  71. IOrderedQueryable<T> ThenOrderDesc<S>(IOrderedQueryable<T> queryable, Expression<Func<T, S>> orderLamda);
  72. /// <summary>
  73. /// 对排序结果进行分页操作
  74. /// </summary>
  75. /// <param name="queryable">根据排序条件排序好之后的排序结果</param>
  76. /// <param name="nowNum">跳过序列中指定数量的元素</param>
  77. /// <param name="pageSize">从序列的开头返回指定数量的连续元素</param>
  78. /// <returns>指定长度的列表</returns>
  79. IQueryable<T> LoadPageEnties(IOrderedQueryable<T> queryable, int nowNum, int pageSize);
  80. /// <summary>
  81. /// 分页查询
  82. /// </summary>
  83. /// <typeparam name="S">排序类型</typeparam>
  84. /// <param name="whereLamda">查询条件</param>
  85. /// <param name="orderLamda">排序条件</param>
  86. /// <param name="isDesc">是否倒序</param>
  87. /// <param name="pageIndex">第几页</param>
  88. /// <param name="pageSize">页长</param>
  89. /// <param name="rowCount"></param>
  90. /// <returns></returns>
  91. IQueryable<T> LoadEntities<S>(Expression<Func<T, bool>> whereLamda, Expression<Func<T, S>> orderLamda, bool isDesc, int pageIndex, int pageSize, out int rowCount);
  92. }
  93. }

然后管理员接口IAdminRepository 继承IBaseRepository

  1. using AuthorDesign.Model;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7.  
  8. namespace AuthorDesign.IDAL {
  9. public interface IAdminRepository:IBaseRepository<Admin> {
  10. }
  11. }

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

  1. using AuthorDesign.IDAL;
  2. using AuthorDesign.Model;
  3. using System;
  4. using System.Collections.Generic;
  5. using System.Linq;
  6. using System.Text;
  7. using System.Threading.Tasks;
  8.  
  9. namespace AuthorDesign.DAL {
  10. public class AdminRepository : BaseRepository<Admin>, IAdminRepository {
  11. }
  12. }

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

首先是IDAL,接口这里。

  1. using AuthorDesign.Model;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7.  
  8. namespace AuthorDesign.IDAL {
  9. public interface IActionToPageRepository : IBaseRepository<ActionToPage> {
  10. }
  11. }
  12. using AuthorDesign.Model;
  13. using System;
  14. using System.Collections.Generic;
  15. using System.Linq;
  16. using System.Text;
  17. using System.Threading.Tasks;
  18.  
  19. namespace AuthorDesign.IDAL {
  20. public interface IAdminLoginLogRepository : IBaseRepository<AdminLoginLog> {
  21. }
  22. }
  23. using AuthorDesign.Model;
  24. using System;
  25. using System.Collections.Generic;
  26. using System.Linq;
  27. using System.Text;
  28. using System.Threading.Tasks;
  29.  
  30. namespace AuthorDesign.IDAL {
  31. public interface IAdminOperationRepository : IBaseRepository<AdminOperation> {
  32. }
  33. }
  34. using AuthorDesign.Model;
  35. using System;
  36. using System.Collections.Generic;
  37. using System.Linq;
  38. using System.Text;
  39. using System.Threading.Tasks;
  40.  
  41. namespace AuthorDesign.IDAL {
  42. public interface IAdminToPageRepository : IBaseRepository<AdminToPage> {
  43. }
  44. }
  45. using AuthorDesign.Model;
  46. using System;
  47. using System.Collections.Generic;
  48. using System.Linq;
  49. using System.Text;
  50. using System.Threading.Tasks;
  51.  
  52. namespace AuthorDesign.IDAL {
  53. public interface IAuthoryRepository : IBaseRepository<Authory> {
  54. }
  55. }
  56. using AuthorDesign.Model;
  57. using System;
  58. using System.Collections.Generic;
  59. using System.Linq;
  60. using System.Text;
  61. using System.Threading.Tasks;
  62.  
  63. namespace AuthorDesign.IDAL {
  64. public interface IAuthoryToPageRepository : IBaseRepository<AuthoryToPage> {
  65. }
  66. }
  67. using AuthorDesign.Model;
  68. using System;
  69. using System.Collections.Generic;
  70. using System.Linq;
  71. using System.Text;
  72. using System.Threading.Tasks;
  73.  
  74. namespace AuthorDesign.IDAL {
  75. public interface IPageActionRepository : IBaseRepository<PageAction> {
  76. }
  77. }
  78. using AuthorDesign.Model;
  79. using System;
  80. using System.Collections.Generic;
  81. using System.Linq;
  82. using System.Text;
  83. using System.Threading.Tasks;
  84.  
  85. namespace AuthorDesign.IDAL {
  86. public interface IPageMenuRepository : IBaseRepository<PageMenu> {
  87. }
  88. }

其次是DAL。

  1. using AuthorDesign.IDAL;
  2. using AuthorDesign.Model;
  3. using System;
  4. using System.Collections.Generic;
  5. using System.Linq;
  6. using System.Text;
  7. using System.Threading.Tasks;
  8.  
  9. namespace AuthorDesign.DAL {
  10. public class ActionToPageRepository : BaseRepository<ActionToPage> ,IActionToPageRepository{
  11. }
  12. }
  13. using AuthorDesign.IDAL;
  14. using AuthorDesign.Model;
  15. using System;
  16. using System.Collections.Generic;
  17. using System.Linq;
  18. using System.Text;
  19. using System.Threading.Tasks;
  20.  
  21. namespace AuthorDesign.DAL {
  22. public class AdminLoginLogRepository : BaseRepository<AdminLoginLog>, IAdminLoginLogRepository {
  23. }
  24. }
  25. using AuthorDesign.IDAL;
  26. using AuthorDesign.Model;
  27. using System;
  28. using System.Collections.Generic;
  29. using System.Linq;
  30. using System.Text;
  31. using System.Threading.Tasks;
  32.  
  33. namespace AuthorDesign.DAL {
  34. public class AdminOperationRepository : BaseRepository<AdminOperation>, IAdminOperationRepository {
  35. }
  36. }
  37. using AuthorDesign.IDAL;
  38. using AuthorDesign.Model;
  39. using System;
  40. using System.Collections.Generic;
  41. using System.Linq;
  42. using System.Text;
  43. using System.Threading.Tasks;
  44.  
  45. namespace AuthorDesign.DAL {
  46. public class AdminToPageRepository : BaseRepository<AdminToPage>, IAdminToPageRepository {
  47. }
  48. }
  49. using AuthorDesign.IDAL;
  50. using AuthorDesign.Model;
  51. using System;
  52. using System.Collections.Generic;
  53. using System.Linq;
  54. using System.Text;
  55. using System.Threading.Tasks;
  56.  
  57. namespace AuthorDesign.DAL {
  58. public class AuthoryRepository : BaseRepository<Authory>, IAuthoryRepository {
  59. }
  60. }
  61. using AuthorDesign.IDAL;
  62. using AuthorDesign.Model;
  63. using System;
  64. using System.Collections.Generic;
  65. using System.Linq;
  66. using System.Text;
  67. using System.Threading.Tasks;
  68.  
  69. namespace AuthorDesign.DAL {
  70. public class AuthoryToPageRepository : BaseRepository<AuthoryToPage>, IAuthoryToPageRepository {
  71. }
  72. }
  73. using AuthorDesign.IDAL;
  74. using AuthorDesign.Model;
  75. using System;
  76. using System.Collections.Generic;
  77. using System.Linq;
  78. using System.Text;
  79. using System.Threading.Tasks;
  80.  
  81. namespace AuthorDesign.DAL {
  82. public class PageActionRepository : BaseRepository<PageAction>, IPageActionRepository {
  83. }
  84. }
  85. using AuthorDesign.IDAL;
  86. using AuthorDesign.Model;
  87. using System;
  88. using System.Collections.Generic;
  89. using System.Linq;
  90. using System.Text;
  91. using System.Threading.Tasks;
  92.  
  93. namespace AuthorDesign.DAL {
  94. public class PageMenuRepository : BaseRepository<PageMenu>,IPageMenuRepository{
  95. }
  96. }

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

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

  1. using AuthorDesign.IDAL;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7.  
  8. namespace AuthorDesign.DAL {
  9. /// <summary>
  10. /// 仓储入口
  11. /// </summary>
  12. public class RepositoryEnter:IRepositoryEnter {
  13. /// <summary>
  14. /// 统一SaveChange方法
  15. /// </summary>
  16. /// <returns></returns>
  17. public int SaveChange() {
  18. return DbContextFactory.GetCurrentDbContext().SaveChanges();
  19.  
  20. }
  21. /// <summary>
  22. /// 获取页面与页面动作联系仓储
  23. /// </summary>
  24. public IDAL.IActionToPageRepository GetActionToPageRepository { get { return new ActionToPageRepository(); } }
  25. /// <summary>
  26. /// 获取管理员登录日志仓储
  27. /// </summary>
  28. public IDAL.IAdminLoginLogRepository GetAdminLoginLogRepository { get { return new AdminLoginLogRepository(); } }
  29. /// <summary>
  30. /// 获取管理员操作仓储
  31. /// </summary>
  32. public IDAL.IAdminOperationRepository GetAdminOperationRepository { get { return new AdminOperationRepository(); } }
  33. /// <summary>
  34. /// 获取管理员仓储
  35. /// </summary>
  36. public IDAL.IAdminRepository GetAdminRepository { get { return new AdminRepository(); } }
  37. /// <summary>
  38. /// 获取管理员与页面仓储
  39. /// </summary>
  40. public IDAL.IAdminToPageRepository GetAdminToPageRepository { get { return new AdminToPageRepository(); } }
  41. /// <summary>
  42. /// 获取角色仓储
  43. /// </summary>
  44. public IDAL.IAuthoryRepository GetAuthoryRepository { get { return new AuthoryRepository(); } }
  45. /// <summary>
  46. /// 获取角色与页面仓储
  47. /// </summary>
  48. public IDAL.IAuthoryToPageRepository GetAuthoryToPageRepository { get { return new AuthoryToPageRepository(); } }
  49. /// <summary>
  50. /// 获取页面动作仓储
  51. /// </summary>
  52. public IDAL.IPageActionRepository GetPageActionRepository { get { return new PageActionRepository(); } }
  53. /// <summary>
  54. /// 获取页面仓储
  55. /// </summary>
  56. public IDAL.IPageMenuRepository GetPageMenuRepository { get { return new PageMenuRepository(); } }
  57. }
  58. }

IRepositoryEnter接口

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7. namespace AuthorDesign.IDAL {
  8. /// <summary>
  9. /// 仓储入口
  10. /// </summary>
  11. public interface IRepositoryEnter {
  12. /// <summary>
  13. /// 统一SaveChange方法
  14. /// </summary>
  15. /// <returns></returns>
  16. int SaveChange();
  17. /// <summary>
  18. /// 获取页面与页面动作联系仓储
  19. /// </summary>
  20. IDAL.IActionToPageRepository GetActionToPageRepository { get; }
  21. /// <summary>
  22. /// 获取管理员登录日志仓储
  23. /// </summary>
  24. IDAL.IAdminLoginLogRepository GetAdminLoginLogRepository { get; }
  25. /// <summary>
  26. /// 获取管理员操作仓储
  27. /// </summary>
  28. IDAL.IAdminOperationRepository GetAdminOperationRepository { get; }
  29. /// <summary>
  30. /// 获取管理员仓储
  31. /// </summary>
  32. IDAL.IAdminRepository GetAdminRepository { get; }
  33. /// <summary>
  34. /// 获取管理员与页面仓储
  35. /// </summary>
  36. IDAL.IAdminToPageRepository GetAdminToPageRepository { get; }
  37. /// <summary>
  38. /// 获取角色仓储
  39. /// </summary>
  40. IDAL.IAuthoryRepository GetAuthoryRepository { get; }
  41. /// <summary>
  42. /// 获取角色与页面仓储
  43. /// </summary>
  44. IDAL.IAuthoryToPageRepository GetAuthoryToPageRepository { get; }
  45. /// <summary>
  46. /// 获取页面动作仓储
  47. /// </summary>
  48. IDAL.IPageActionRepository GetPageActionRepository { get; }
  49. /// <summary>
  50. /// 获取页面仓储
  51. /// </summary>
  52. IDAL.IPageMenuRepository GetPageMenuRepository { get; }
  53. }
  54. }

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

百度源码下载地址

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

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

    这是本人第一次写,写的不好的地方还忘包含.写这个的主要原因是想通过这个来学习下EF的CodeFirst模式,本来也想用AngularJs来玩玩的,但是自己只会普通的绑定,对指令这些不是很熟悉,所以就基 ...

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

    今天把用户的菜单显示和页面的按钮显示都做好了,下面先来个效果图 接下来说下我实现的方法: 首先我在每个方法前面都加了这个属性, /// <summary> /// 表示当前Action请求 ...

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

    首先先加个区域,名为Admin using System.Web.Mvc; namespace AuthorDesign.Web.Areas.Admin { public class AdminAre ...

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

    前两天因有事就没来得及写.今天刚刚好空了.这次写的是对角色和管理员对页面按钮之间的控制.先看页面效果 说明:先根据角色设置好角色的权限,然后管理员在对应的角色下的权限去设置其权限. 在设置角色权限的时 ...

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

    接下来先做角色这一板块的(增删改查),首先要新建一个Role控制器,在添加一个RoleList的视图.表格打算采用的是bootstrap的表格. using System; using System. ...

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

    我们先直接拷贝下blank.html这个页面的代码,顺带先建立一个Home控制器,并添加Index视图.将代码拷贝进去. <!DOCTYPE html> <html lang=&qu ...

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

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

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

    接下来做的是对页面的增删改查与页面与页面按钮之间的联系.先上代码和页面效果 using AuthorDesign.Web.App_Start.Common; using System; using S ...

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

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

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

    首先在webconfig中加入下面这句代码,这个主要是用来生成数据库的连接字符串 <connectionStrings> <add name="AuthorDesignCo ...

随机推荐

  1. SQL Server里的闩锁耦合(Latch Coupling)

    几年前,我写了篇关于闩锁和为什么SQL Server需要它们的文章.在今天的文章里,我想进一步谈下非缓存区闩锁(Non-Buffer Latches),还有在索引查找操作期间,SQL Server如何 ...

  2. Oracle索引梳理系列(四)- Oracle索引种类之位图索引

    版权声明:本文发布于http://www.cnblogs.com/yumiko/,版权由Yumiko_sunny所有,欢迎转载.转载时,请在文章明显位置注明原文链接.若在未经作者同意的情况下,将本文内 ...

  3. 图片全部加载完成之后再显示页面ui,公司项目里用上,自己写的几行代码

    说明: -----onload事件   这里我并没有考虑ie的兼容性 因为项目是移动端的: -----求大神指正~ -----自己测试正常 页面没加载完之前会有一个提示 /************** ...

  4. Visual Studio 2013 Update 3 RTM 正式发布

    VS2013.3 RTM已发布! 完整安装包:http://download.microsoft.com/download/6/F/0/6F0777D3-3541-465F-8639-A8F9D36B ...

  5. HTML5填充颜色的fillStyle测试

    效果:http://hovertree.com/texiao/html5/canvas/1/ 代码: <html> <head> <meta http-equiv=&qu ...

  6. PHP四个阶段目标以及第一阶段学习内容

    PHP课程体系主要分为四个阶段,第一阶段讲的是网页HTML和数据库MySQL,第一阶段要学会网页制作的基础知识,熟用各种基本标签,对数据库进行操作,各项考核都能够达标,拿出出众的项目展示. 在第二个阶 ...

  7. MyBatis的resultMap

    1.大家学习MyBatis时,可能会碰到实体类属性跟数据库字段不同的情况 如:数据库    ------  实体类 stuname  ---->  name 即: 数据库中的stuname字段对 ...

  8. 使用HBaseShellPro操作Hadoop 2系列发行版CDH4.4

    前言 对于hadoop,hbase由于项目紧张原因好几个月没有时间认真的来总结下了,最近有一些空,就来继续的把项目中用到的一些技术实际的写出来,动动手,好久没有写东西了,都生疏了,说起hadoop,公 ...

  9. css之颜色值、单位

    颜色值 英文命令颜色:p{color:red;} RGB颜色:p{color:rgb(133,45,200);}每一项的值可以是 0~255 之间的整数,也可以是 0%~100% 的百分数.如:p{c ...

  10. Html + Css思维导图

    最近整理的一份Html和Css的思维导图,共享给初学者使用. 各个知识点的详细案例介绍,后期会分阶段依次发布,希望对大家学习html和css有帮助. 如果对文中的知识点有异议,欢迎随时拍砖! 后期也回 ...