自定义表并实现Identity登录（一）

注意，Microsoft.AspNet.Identity.Core.1.0.0和Microsoft.AspNet.Identity.Core.2.2.1差别太大，需考虑实际项目中用的是哪种，本文是基于2.2.1来写的！！

两个概念：1、OWIN的英文全称是Open Web Interface for .NET。2、Microsoft.AspNet.Identity是微软在MVC 5.0中新引入的一种membership框架，和之前ASP.NET传统的membership以及WebPage所带来的SimpleMembership（在MVC 4中使用）都有所不同。本文以自定义数据库表来实现用户的登录授权。不依赖MemberShip和EF框架。

要实现自定义，有三处需重写：UserStore、PasswordHasher、IUser

自定义UserStore：

　　继承微软的UserStore并重新实现它的FindByIdAsync、FindByNameAsync等方法。

　　为什么要这么做？

　　1、替换EF并换成我们自己的底层ORM（我在另一篇文章中用EF写了一套）

　　2、多个Area可以自定义多个UserStore，不同的Area可以访问不同的UserStore，当然多个Area访问同一个UserStore也是可以。

　　它是如何工作的？

    public class UserManager<TUser> : IDisposable where TUser: IUser
    {
        private ClaimsIdentityFactory<TUser> _claimsFactory;
        private bool _disposed;
        private IPasswordHasher _passwordHasher;
        private IIdentityValidator<string> _passwordValidator;
        private IIdentityValidator<TUser> _userValidator;

        public UserManager(IUserStore<TUser> store)
        {
            if (store == null)
            {
                throw new ArgumentNullException("store");
            }
            this.Store = store;
            this.UserValidator = new UserValidator<TUser>((UserManager<TUser>) this);
            this.PasswordValidator = new MinimumLengthValidator();
            this.PasswordHasher = new Microsoft.AspNet.Identity.PasswordHasher();
            this.ClaimsIdentityFactory = new ClaimsIdentityFactory<TUser>();
        }

UserManager代码

　　通过UserManager的源代码可以看到，UserManager运用了桥接模式，查找用户的方法来自UserStore，返回的是泛型

自定义IUserIdentity：

　　1、需注意，此处可不是继承IUserIdentity，IUserIdentity需和IdentityDbContext配合，我们既然用自己的ORM，就等于放弃IdentityDbContext。

namespace Biz.Framework.AspNet.Identity
{
    /// <summary>
    /// IdentityLoginUser,重写Identity.IUser,这个跟数据库中的用户表是两码事，专门做登录、权限判断用的
    /// 但是，我们可以把它跟数据库的用户表结合起来用，上面部分为数据的用户表，下面为继承成IUserIdentity（可做公司产品）
    /// </summary>
    [Serializable]
    public class IdentityLoginUser : ISerializable, IUserIdentity, Microsoft.AspNet.Identity.IUser
    {
        #region 数据库字段
        public int UserId { get; set; }
        public string UserName { get; set; }
        public string Password { get; set; }
        #endregion

        #region 公司自己的产品IUserIdentity接口
        bool? IUserIdentity.IsRootAdmin
        {
            get { return null; }
        }
        #endregion

        #region 微软IUser接口
        string Microsoft.AspNet.Identity.IUser<string>.Id
        {
            get { return null; }
        }
        #endregion

        #region 必须实现，否则无法使用
        [SecurityPermissionAttribute(SecurityAction.Demand, SerializationFormatter = true)]
        void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
        {
            info.AddValue("UserId", this.UserId);
            info.AddValue("Password", string.Empty);
        }

        /// <summary>
        /// 反序列化的构造函数
        /// </summary>
        /// <param name="info"></param>
        /// <param name="context"></param>
        public IdentityLoginUser(SerializationInfo info, StreamingContext context)
        {
            this.UserId = info.GetInt32("UserId");
            this.Password = info.GetString("Password");
        }
        #endregion

        public string ToJson() { return JsonConvert.SerializeObject(this); }
    }
}

自定义IUserIdentity

　　2、微软自带的User字段肯定是不符合实际环境的字段

自定义UserStore，整体代码如下

using Biz.DBUtility;//这个是自己的底层ORM，可以是EF的edmx或者其他
using Microsoft.AspNet.Identity;
using System;
using System.Data.Entity;
using System.Threading.Tasks;

namespace Biz.Framework.AspNet.Identity
{
    /// <summary>
    /// 针对不同的Area，可以定义多个UserStore。
    /// TODO：可以支持多种形式的用户读取吗？比如AD，接口验证等？待研究
    /// </summary>
    public class BizUserStore : IUserPasswordStore<IdentityLoginUser>, IUserStore<IdentityLoginUser>, IDisposable
    {
        public Task CreateAsync(IdentityLoginUser user)
        {
            throw new NotImplementedException("不支持新增用户");
        }

        public Task DeleteAsync(IdentityLoginUser user)
        {
            throw new NotImplementedException("不支持删除用户");
        }

        public Task<IdentityLoginUser> FindByIdAsync(int userId)
        {
            //BizEntities b = new BizEntities();
            return null;//b.Sys_User.FindAsync(new object[] { userId });
        }

        public Task<IdentityLoginUser> FindByNameAsync(string userName)
        {
            if (string.IsNullOrEmpty(userName))
                return null;

            BizEntities dbContext = new BizEntities();
            Sys_User user = dbContext.Sys_User.FirstOrDefaultAsync(q => q.UserName == userName).Result;

            IdentityLoginUser identityLoginUser = new IdentityLoginUser
            {
                UserId = user.UserId,
                UserName = user.UserName,
                Password = user.Password
            };

            return Task.FromResult<IdentityLoginUser>(identityLoginUser);
        }

        public Task UpdateAsync(IdentityLoginUser user)
        {
            throw new NotImplementedException("不支持删除用户");
        }

        public Task<IdentityLoginUser> FindByIdAsync(string userId)
        {
            if (string.IsNullOrEmpty(userId))
                return null;

            return this.FindByIdAsync(int.Parse(userId));
        }

        public void Dispose() { }

        #region IUserPasswordStore接口
        /// <summary>
　　　　 /// 这个方法用不到！！！
        /// 虽然对于普通系统的明文方式这些用不到。
        /// 但是！！！MVC5之后的Identity2.0后数据库保存的密码是加密盐加密过的，这里也需要一并处理，然而1.0并不需要处理，需注意！！！
        /// </summary>
        /// <param name="user"></param>
        /// <returns></returns>
        public Task<string> GetPasswordHashAsync(IdentityLoginUser user)
        {
            return Task.FromResult<string>(user.Password);
        }

        public Task<bool> HasPasswordAsync(IdentityLoginUser user)
        {
            return Task.FromResult<bool>(!string.IsNullOrWhiteSpace(user.Password));
        }

        public Task SetPasswordHashAsync(IdentityLoginUser user, string passwordHash)
        {
            user.Password = passwordHash;
            return Task.FromResult<int>();
        }

        #endregion
    }
}

自定义UserStore

但是，此时运行代码会报错：Base-64 字符数组或字符串的长度无效。这个是由于微软的UserManager下的IPasswordHasher是通过MD5+随机盐加密出来的。所以，我们还要将密码加密，对比这一套换成我们自己的！你也可以自己去研究一下加密盐，我看微软的源代码是没看懂啦，我以为盐既然是随机生成的，应该是放在数据库里啊，但是数据库里没有，不懂！

自定义PasswordHasher，用自己的密码

using Microsoft.AspNet.Identity;

namespace Biz.Framework.AspNet.Identity
{
    public class BizPasswordHasher : PasswordHasher
    {
        /// <summary>
        /// 加密密码，可以采用简单的MD5加密，也可以通过MD5+随机盐加密
        /// </summary>
        /// <param name="password"></param>
        /// <returns></returns>
        public override string HashPassword(string password)
        {
            return password;
        }

        public override PasswordVerificationResult VerifyHashedPassword(string hashedPassword, string providedPassword)
        {
            //此处什么加密都不做！
            if (hashedPassword == providedPassword)
            //if (Crypto.VerifyHashedPassword(hashedPassword, providedPassword))
            {
                return PasswordVerificationResult.Success;
            }
            return PasswordVerificationResult.Failed;
        }
    }
}

自定义PasswordHasher

namespace Biz.Web.Controllers
{
    [Authorize]
    public class AccountController : Controller
    {
        public AccountController()
            : this(new UserManager<IdentityLoginUser>(new BizUserStore()))
        {
        }

        public AccountController(UserManager<IdentityLoginUser> userManager)
        {
            UserManager = userManager;
            userManager.PasswordHasher = new BizPasswordHasher();
        }

UserManager中的PasswordHasher也要一并重赋

但是，判断用户通过后，登录代码又报错：System.ArgumentNullException: 值不能为 null。重写ClaimsIdentityFactory后发现是User.Id为null，有次IdentityLogin中继承自IUser的Id必须赋值，可以用用户表中的UserId。

using Microsoft.AspNet.Identity;
using System;
using System.Collections.Generic;
using System.Security.Claims;
using System.Threading.Tasks;

namespace Biz.Framework.AspNet.Identity
{
    //public class BizClaimsIdentityFactory<TUser> : IClaimsIdentityFactory<TUser> where TUser : class, IUser
    public class BizClaimsIdentityFactory<TUser> : ClaimsIdentityFactory<TUser, string> where TUser : class, IUser<string>
    {
        internal const string DefaultIdentityProviderClaimValue = "ASP.NET Identity";
        internal const string IdentityProviderClaimType = "http://schemas.microsoft.com/accesscontrolservice/2010/07/claims/identityprovider";

        public string RoleClaimType { get; set; }

        public string UserIdClaimType { get; set; }

        public string UserNameClaimType { get; set; }

        public BizClaimsIdentityFactory()
        {
            this.RoleClaimType = "http://schemas.microsoft.com/ws/2008/06/identity/claims/role";
            this.UserIdClaimType = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier";
            this.UserNameClaimType = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name";
        }

        public async override Task<ClaimsIdentity> CreateAsync(UserManager<TUser, string> manager, TUser user, string authenticationType)
        {
            if (manager == null)
            {
                throw new ArgumentNullException("manager");
            }
            if (user == null)
            {
                throw new ArgumentNullException("user");
            }
            ClaimsIdentity id = new ClaimsIdentity(authenticationType, ((BizClaimsIdentityFactory<TUser>)this).UserNameClaimType, ((BizClaimsIdentityFactory<TUser>)this).RoleClaimType);
            id.AddClaim(new Claim(((BizClaimsIdentityFactory<TUser>)this).UserIdClaimType, user.Id, "http://www.w3.org/2001/XMLSchema#string"));
            id.AddClaim(new Claim(((BizClaimsIdentityFactory<TUser>)this).UserNameClaimType, user.UserName, "http://www.w3.org/2001/XMLSchema#string"));
            id.AddClaim(new Claim("http://schemas.microsoft.com/accesscontrolservice/2010/07/claims/identityprovider", "ASP.NET Identity", "http://www.w3.org/2001/XMLSchema#string"));
            if (manager.SupportsUserRole)
            {
                IList<string> roles = await manager.GetRolesAsync(user.Id);
                using (IEnumerator<string> enumerator = roles.GetEnumerator())
                {
                    while (enumerator.MoveNext())
                    {
                        string current = enumerator.Current;
                        id.AddClaim(new Claim(((BizClaimsIdentityFactory<TUser>)this).RoleClaimType, current, "http://www.w3.org/2001/XMLSchema#string"));
                    }
                }
            }
            if (manager.SupportsUserClaim)
            {
                //ClaimsIdentity identity3;
                //ClaimsIdentity identity2 = id;
                //IList<Claim> claims = await manager.GetClaimsAsync(user.Id);
                //identity3.AddClaims(claims);
            }
            return id;
        }

        //public async override Task<ClaimsIdentity> CreateAsync(UserManager<TUser> manager, TUser user, string authenticationType)
        //{
        //    if (manager == null)
        //    {
        //        throw new ArgumentNullException("manager");
        //    }
        //    if (user == null)
        //    {
        //        throw new ArgumentNullException("user");
        //    }
        //    ClaimsIdentity id = new ClaimsIdentity(authenticationType, ((BizClaimsIdentityFactory<TUser>)this).UserNameClaimType, ((BizClaimsIdentityFactory<TUser>)this).RoleClaimType);
        //    id.AddClaim(new Claim(((BizClaimsIdentityFactory<TUser>)this).UserIdClaimType, user.Id, "http://www.w3.org/2001/XMLSchema#string"));
        //    id.AddClaim(new Claim(((BizClaimsIdentityFactory<TUser>)this).UserNameClaimType, user.UserName, "http://www.w3.org/2001/XMLSchema#string"));
        //    id.AddClaim(new Claim("http://schemas.microsoft.com/accesscontrolservice/2010/07/claims/identityprovider", "ASP.NET Identity", "http://www.w3.org/2001/XMLSchema#string"));
        //    if (manager.SupportsUserRole)
        //    {
        //        IList<string> roles = await manager.GetRolesAsync(user.Id);
        //        using (IEnumerator<string> enumerator = roles.GetEnumerator())
        //        {
        //            while (enumerator.MoveNext())
        //            {
        //                string current = enumerator.Current;
        //                id.AddClaim(new Claim(((BizClaimsIdentityFactory<TUser>)this).RoleClaimType, current, "http://www.w3.org/2001/XMLSchema#string"));
        //            }
        //        }
        //    }
        //    if (manager.SupportsUserClaim)
        //    {
        //        //ClaimsIdentity identity3;
        //        //ClaimsIdentity identity2 = id;
        //        //IList<Claim> claims = await manager.GetClaimsAsync(user.Id);
        //        //identity3.AddClaims(claims);
        //    }
        //    return id;
        //}
    }
}

重写ClaimsIdentityFactory，注意可以不重写，此处是为了验证问题

自此，本文结束！需要代码的可留言

其他的一些可借鉴的文章：

重写UserManager

加密盐