.NET 实现自定义ContextUser的Identity和Principal实现自定义用户信息，权限验证。

备用收藏，http://blog.csdn.net/msdnxgh/article/details/6894885

.NET 实现自定义ContextUser的Identity和Principal

在传统的.NET中，我们可以通过

1. User.Identity.Name;//获取用户名
2. User.Identity.IsAuthenticated;//判断用户是否己验证
3. User.IsInRole("Admin");//判断用户是否含有指定角色

但这样的机制，在实际开发中，难以满足开发需要.仅仅通过User.Identity.Name;获取用户名，和User.Identity.IsAuthenticated;判断用户是否验证，是难以满足需要。如何获取用户更多信息，或者进行更详细的权限判断。

我们可以通过自定义Identity和Principal进行实现！

1. /// <summary>
2. /// 自定义当前用户标识对象
3. /// </summary>
4. public class MyIdentity:IIdentity
5. {
6. #region 用户属性(可自定义更多信息)
7. private string _userName;//用户账号
8. private string _departmnet;//用户所在部门
9. private string _phone;//用户联系电话
10. #endregion
11. /// <summary>
12. /// 用户账号
13. /// </summary>
14. public string UserName
15. {
16. get { return _userName; }
17. }
18. /// <summary>
19. /// 用户所在部门
20. /// </summary>
21. public string Departmnet
22. {
23. get { return _departmnet; }
24. }
25. /// <summary>
26. /// 用户电话
27. /// </summary>
28. public string Phone
29. {
30. get { return _phone; }
31. }
32. /// <summary>
33. /// 构造函数，根据用户名
34. /// </summary>
35. /// <param name="UserName"></param>
36. public MyIdentity(string UserName)
37. {
38. //根据UserName查询数据库获得以下数据
39. this._userName = "abc";
40. this._departmnet = "行政部";
41. this._phone = "123456";
42. }
43. /// <summary>
44. /// 构造函数,根据用户ID
45. /// </summary>
46. /// <param name="UserID"></param>
47. public MyIdentity(int UserID)
48. {
49. //根据UserName查询数据库获得以下数据
50. this._userName = "abc";
51. this._departmnet = "行政部";
52. this._phone = "123456";
53. }
54. #region 基本属性
55. /// <summary>
56. /// 返回验证方式
57. /// </summary>
58. public string AuthenticationType
59. {
60. get { return "Form"; }
61. }
62. /// <summary>
63. /// 是否验证
64. /// </summary>
65. public bool IsAuthenticated
66. {
67. get { return true; }
68. }
69. /// <summary>
70. /// 返回用户
71. /// </summary>
72. public string Name
73. {
74. get { return _userName; }
75. }
76. #endregion
77. }

1. /// <summary>
2. /// 当前用户安全上下文信息
3. /// </summary>
4. public class MyPrincipal:IPrincipal
5. {
6. #region 属性
7. private IIdentity _identity;//用户标识
8. private ArrayList _permissionList;//权限列表
9. #endregion
10. /// <summary>
11. /// 返回用户权限列表
12. /// </summary>
13. public ArrayList PermissionList
14. {
15. get { return _permissionList; }
16. }
17. /// <summary>
18. /// 获取当前用户标识
19. /// </summary>
20. public IIdentity Identity
21. {
22. get { return _identity; }
23. }
24. /// <summary>
25. /// 当前用户是否指定角色（采用权限值方式，此处返回false）
26. /// </summary>
27. /// <param name="role"></param>
28. /// <returns></returns>
29. public bool IsInRole(string role)
30. {
31. return false;//返回false
32. }
33. /// <summary>
34. /// 构造函数，用户名构造
35. /// </summary>
36. /// <param name="UserName"></param>
37. public MyPrincipal(string UserName)
38. {
39. _identity = new MyIdentity(UserName);
40. //以下权限根据UserName获取数据库用户拥有的权限值，此次省略
41. _permissionList = new ArrayList();
42. _permissionList.Add(1);
43. _permissionList.Add(2);
44. _permissionList.Add(3);
45. _permissionList.Add(4);
46. _permissionList.Add(5);
47. }
48. /// <summary>
49. /// 构造函数，用户ID构造
50. /// </summary>
51. /// <param name="UserID"></param>
52. public MyPrincipal(int UserID)
53. {
54. _identity = new MyIdentity(UserID);
55. //以下权限根据UserName获取数据库用户拥有的权限值，此次省略
56. _permissionList = new ArrayList();
57. _permissionList.Add(1);
58. _permissionList.Add(2);
59. _permissionList.Add(3);
60. _permissionList.Add(4);
61. _permissionList.Add(5);
62. }
63. /// <summary>
64. /// 判断用户是否拥有某权限
65. /// </summary>
66. /// <param name="permissionid"></param>
67. /// <returns></returns>
68. public bool IsPermissionID(int permissionid)
69. {
70. return _permissionList.Contains(permissionid);
71. }
72. }

好，上面我们己实现了自定义，Identity和Principal。

我们可以在页面这样使用Identity。

1. //页面中输出自定义用户信息
2. <%=(User.Identity as ContextUser.MyIdentity).Name %>//用户账号
3. <%=(User.Identity as ContextUser.MyIdentity).Phone %>//用户电话
4. <%=(User.Identity as ContextUser.MyIdentity).Departmnet %>//用户所在部门

自定义显示用户信息后，我们接着利用Principal进行权限验证和控制

在Asp.net Web模式下，使用方式：

首先，我们先做一个权限验证基类！

1. /// <summary>
2. ///权限验证基类
3. /// </summary>
4. public class BasePaper:System.Web.UI.Page
5. {
6. public BasePaper()
7. {
8. //
9. //TODO: 在此处添加构造函数逻辑
10. //
11. }
12. protected override void OnInit(EventArgs e)
13. {
14. BasePage_Load();
15. }
16. /// <summary>
17. /// 设置权限，默认值为0
18. /// </summary>
19. public virtual int PermissionID
20. {
21. get { return 0; }
22. }
23. /// <summary>
24. /// 验证方法
25. /// </summary>
26. /// <param name="sender"></param>
27. /// <param name="e"></param>
28. private void BasePage_Load()
29. {
30. //权限检查
31. #region 权限检查
32. bool Permission = true;//初始值为没有权限
33. //这一步很重要，要代替.NET的自身的User.
34. ContextUser.MyPrincipal MyPrincipal = new ContextUser.MyPrincipal(HttpContext.Current.User.Identity.Name);
35. HttpContext.Current.User = MyPrincipal;
36. if ((User as account.ContextUser.MyPrincipal).PermissionList.Contains(PermissionID))
37. {
38. Permission = false;//验证通过
39. }
40. if (Permission)//权限验证不通过
41. {
42. Response.Clear();
43. Response.Write("<script language=\"javascript\">alert(\"对不起，你没有权限进入\");history.go(-1);</script>");
44. Response.End();
45. }
46. #endregion
47. }
48. }

OK,到了验证页的时候了。

1. public partial class ascx_Add :BasePage
2. {
3. public override int PermissionID
4. {
5. get
6. {
7. return 13;//返回要验证权限值
8. }
9. }
10. protected void Page_Load(object sender, EventArgs e)
11. {
12. //
13. }
14. }

事实上，在Asp.net MVC模式，更容易对权限进行控制，可以进行更多的细化，对每个动作进行控制。

MVC模式下：

首先，先实现一个权限验证基类：

1. /// <summary>
2. /// 权限验证基类
3. /// 2011.7.3
4. /// </summary>
5. public class BasePage : AuthorizeAttribute
6. {
7. /// <summary>
8. /// 权限值
9. /// </summary>
10. private int _permissionID = 0;
11. /// <summary
12. /// 权限值
13. /// </summary>
14. public int PermissionID
15. {
16. get { return _permissionID; }
17. set { _permissionID = value; }
18. }
19. /// <summary>
20. /// 在过程请求授权时调用。
21. /// </summary>
22. /// <param name="filterContext">对象包括控制器、HTTP 上下文、请求上下文、操作结果和路由数据。</param>
23. public override void OnAuthorization(AuthorizationContext filterContext)
24. {
25. if (HttpContext.Current.User.Identity.IsAuthenticated)
26. {
27. //这一步很重要，要代替.NET的自身的User.
28. ContextUser.MyPrincipal MyPrincipal = new ContextUser.MyPrincipal(HttpContext.Current.User.Identity.Name);
29. HttpContext.Current.User = MyPrincipal;
30. if ((!MyPrincipal.ISPermissionID(_permissionID)) && (_permissionID != 0))
31. {
32. HttpContext.Current.Response.Clear();
33. HttpContext.Current.Response.Write("<script defer>window.alert('无权操作！');history.back();</script>");
34. HttpContext.Current.Response.End();
35. filterContext.Result = new EmptyResult();
36. }
37. }
38. else
39. {
40. FormsAuthentication.SignOut();
41. HttpContext.Current.Response.Clear();
42. HttpContext.Current.Response.Write("<script defer>window.alert('无权操作！或当前登录用户已过期！\\n请重新登录或与管理员联系！');</script>");
43. HttpContext.Current.Response.End();
44. filterContext.Result = new EmptyResult();
45. }
46. }
47. }

回到控制器，进行权限验证

1. [BasePage(PermissionID = 13)]//返回要验证权限值
2. public ActionResult Index()
3. {
4. //
5. }

无论对Asp.net Form或者Aap.net MVC,都在一个按钮级的权限控制，

那对于，按钮级的权限如何进行控制昵？

看下面代码

1. //控制删除按扭的显示
2. <% if((User as account.ContextUser.MyPrincipal).PermissionList.Contains(13) {%>
3. <input type="submit" name="button" id="button" value="删除" />
4. <%} %>

至此，如何实现自定义Identity和Principal，进行整合更多用户信息，和权限验证。己经介绍完了。