C# ASP.NET标识-使用多提供程序的自定义实现

我目前正在为汽车经销商做一个大项目，我左右为难

我应该使用ASP.NET身份验证还是旧式身份验证？

我需要能够通过2个提供商登录。首先，用户总是在数据库中，但是我们检查它是否是LDAP用户，如果是，则通过LDAP对其进行身份验证（对于具有登录方法的用户，我使用WebService）

以下是我的登录方法：

    [HttpPost]
    [AllowAnonymous]
    [ValidateAntiForgeryToken]
    public async Task<ActionResult> Login(LoginModel model)
    {
        if (ModelState.IsValid)
        {
            var userInDb = this.db.Users.FirstOrDefault(u => u.Username == model.username);

            if (userInDb != null)
            {
                // USER EXISTS
                if (userInDb.IsLdap)
                {
                    try
                    {
                        // IS LDAP POWERED, IGNORE PASSWORD IN DB
                        using (var ws = WebServiceClient.Factory(model.GetDomain()))
                        {
                            // MAKE AUTH
                            var result = await ws.Login(model.GetUsername(), model.password);

                            if (result.Success)
                            {
                                // USER IS LEGAL
                                FormsAuthentication.SetAuthCookie(model.username, model.remember);

                                return RedirectToAction("Init");
                            }
                            else
                            {
                                // USER IS ILLEGAL
                                ModelState.AddModelError("", "Username or password invalid.");
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        // AN ERROR OCCURED IN CREATION OF THE WebService
                        ErrorUtils.Send(ex);

                        ModelState.AddModelError("", ex.Message);
                    }
                }
                else
                {
                    // USER IS DB POWERED, CHECK THE PASSWORDS
                    var currentHash = userInDb.Password;

                    var isPasswordOkay = PasswordUtils.Validate(model.password, currentHash);
                    if (isPasswordOkay)
                    {
                        // USER PASSWORD IS LEGIT
                        FormsAuthentication.SetAuthCookie(model.username, model.remember);

                        return RedirectToAction("Init");
                    }
                    else
                    {
                        // BAD PASSWORD
                        ModelState.AddModelError("", "Username or password invalid.");
                    }
                }
            }
            else
            {
                try
                {
                    // USER DO NOT EXISTS IN DB
                    using (var ws = WebServiceClient.Factory(model.GetDomain()))
                    {
                        // MAKE AUTH
                        var result = await ws.Login(model.GetUsername(), model.password);

                        if (result.Success)
                        {
                            // USER IS LEGAL IN LDAP SO CREATE IT IN DB
                            var ldapUser = (AuthResponse.AuthResponseUser)result.User;

                            var name = ldapUser.DisplayName.Split(' ');
                            var user = new User()
                            {
                                Firstname = name[0],
                                Lastname = name[1],
                                ActivatedAt = DateTime.Now,
                                ModifiedAt = DateTime.Now,
                                Email = model.username,
                                IsLdap = true,
                                Username = model.username,
                                Password = "",
                                Notifications = NotificationType.All
                            };

                            // GET THE DEALER TO ADD IT TO THE USER RIGHT NOW
                            var dealer = this.db.BaseContexts.Find(ws.Dealer.Id);
                            user.BaseContexts.Add(dealer);
                            dealer.Users.Add(user);

                            try
                            {
                                this.db.Users.Add(user);

                                this.db.Entry(user).State = System.Data.Entity.EntityState.Added;
                                this.db.Entry(dealer).State = System.Data.Entity.EntityState.Modified;

                                await this.db.SaveChangesAsync();

                                FormsAuthentication.SetAuthCookie(model.username, model.remember);

                                return RedirectToAction("Init");
                            }
                            catch (Exception ex)
                            {
                                ErrorUtils.Send(ex);

                                ModelState.AddModelError("", "An error occured during user creation.");
                            }
                        }
                        else
                        {
                            // USER IS ILLEGAL
                            ModelState.AddModelError("", "Username or password invalid.");
                        }
                    }
                }
                catch (Exception ex)
                {
                    // AN ERROR OCCURED IN CREATION OF THE WebService
                    ErrorUtils.Send(ex);

                    ModelState.AddModelError("", ex.Message);
                }
            }
        }

        return View(model);
    }

[HttpPost]
[异名]
[ValidateAntiForgeryToken]
公共异步任务登录（LoginModel模型）
{
if（ModelState.IsValid）
{
var userInDb=this.db.Users.FirstOrDefault（u=>u.Username==model.Username）；
if（userInDb！=null）
{
//用户存在
if（userInDb.IsLdap）
{
尝试
{
//LDAP是否受支持，忽略数据库中的密码
使用（var ws=WebServiceClient.Factory（model.GetDomain（）））
{
//授权
var result=wait ws.Login（model.GetUsername（），model.password）；
如果（结果、成功）
{
//用户是合法的
FormsAuthentication.SetAuthCookie（model.username，model.memory）；
返回重定向到操作（“初始化”）；
}
其他的
{
//用户是非法的
AddModelError（“，”用户名或密码无效“）；
}
}
}
捕获（例外情况除外）
{
//创建Web服务时出错
ErrorUtils.Send（ex）；
ModelState.addmodeleror（“，例如Message”）；
}
}
其他的
{
//用户已接通DB电源，请检查密码
var currentHash=userInDb.Password；
var ispasswordok=PasswordUtils.Validate（model.password，currentHash）；
如果（isPasswordOK）
{
//用户密码是合法的
FormsAuthentication.SetAuthCookie（model.username，model.memory）；
返回重定向到操作（“初始化”）；
}
其他的
{
//密码错误
AddModelError（“，”用户名或密码无效“）；
}
}
}
其他的
{
尝试
{
//数据库中不存在用户
使用（var ws=WebServiceClient.Factory（model.GetDomain（）））
{
//授权
var result=wait ws.Login（model.GetUsername（），model.password）；
如果（结果、成功）
{
//用户在LDAP中是合法的，所以在DB中创建它
var ldapUser=（AuthResponse.AuthResponseUser）result.User；
var name=ldapUser.DisplayName.Split（“”）；
var user=新用户（）
{
Firstname=名称[0]，
Lastname=名称[1]，
ActivatedAt=日期时间。现在，
ModifiedAt=DateTime。现在，
Email=model.username，
IsLdap=true，
用户名=model.Username，
密码=”，
通知=NotificationType.All
};
//让经销商立即将其添加到用户中
var-dealer=this.db.BaseContexts.Find（ws.dealer.Id）；
user.BaseContexts.Add（经销商）；
经销商.用户.添加（用户）；
尝试
{
this.db.Users.Add（user）；
this.db.Entry（user.State=System.Data.Entity.EntityState.Added；
this.db.Entry（dealer.State=System.Data.Entity.EntityState.Modified；
等待这个.db.saveChangesSync（）；
FormsAuthentication.SetAuthCookie（model.username，model.memory）；
返回重定向到操作（“初始化”）；
}
捕获（例外情况除外）
{
ErrorUtils.Send（ex）；
AddModelError（“，”用户创建过程中发生错误。“）；
}
}
其他的
{
//用户是非法的
AddModelError（“，”用户名或密码无效“）；
}
}
}
捕获（例外情况除外）
{
//创建Web服务时出错
ErrorUtils.Send（ex）；
ModelState.addmodeleror（“，例如Message”）；
}
}
}
返回视图（模型）；
}

我如何在这种情况下优化它或实现ASP.NET标识？我读过关于多租户的书，但我不确定是什么

我是