ASP.NET Core 2.0中多注册表单适配单登录表单的实现难题

Hey there, let's break this down for you since you're stuck with your ASP.NET Core 2.0 registration and login setup. I’ve worked through similar multi-field registration flows before, so here’s a step-by-step approach to get you up and running.

First, let's make sure your user data model and registration flow are set up to handle all 12 custom properties properly.

Step 1: Extend the Identity User Class #

If you're using ASP.NET Core Identity (the most common approach for auth), extend IdentityUser to include your 12 custom fields. Example:

public class ApplicationUser : IdentityUser
{
    // Add your 12 custom properties here
    public string FullName { get; set; }
    public DateTime DateOfBirth { get; set; }
    public string PhoneNumberSecondary { get; set; }
    public bool IsAgreedToTerms { get; set; }
    // ... add the remaining 8 properties based on your requirements
}

Step 2: Update Your DbContext #

Make sure your database context inherits from IdentityDbContext<ApplicationUser> to include your custom user fields:

public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }
}

Step 3: Create a Registration ViewModel #

Build a ViewModel that mirrors all fields your registration form needs (including the 12 custom properties + standard auth fields):

public class RegisterViewModel
{
    [Required]
    [EmailAddress]
    public string Email { get; set; }

    [Required]
    [DataType(DataType.Password)]
    public string Password { get; set; }

    [DataType(DataType.Password)]
    [Compare("Password", ErrorMessage = "Passwords don't match.")]
    public string ConfirmPassword { get; set; }

    // Map your 12 custom properties here
    [Required]
    public string FullName { get; set; }
    [Required]
    public DateTime DateOfBirth { get; set; }
    [Required]
    public bool IsAgreedToTerms { get; set; }
    // ... add remaining properties with appropriate data annotations
}

Step 4: Wire Up the Registration Controller Action #

In your AccountController, map the ViewModel data to your ApplicationUser and save it to the database:

[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Register(RegisterViewModel model)
{
    if (ModelState.IsValid)
    {
        var user = new ApplicationUser
        {
            UserName = model.Email,
            Email = model.Email,
            FullName = model.FullName,
            DateOfBirth = model.DateOfBirth,
            IsAgreedToTerms = model.IsAgreedToTerms
            // Assign all remaining custom properties here
        };

        var result = await _userManager.CreateAsync(user, model.Password);
        if (result.Succeeded)
        {
            // Optional: Auto-login the user after registration
            await _signInManager.SignInAsync(user, isPersistent: false);
            return RedirectToAction(nameof(HomeController.Index), "Home");
        }

        // Add any Identity errors to the model state
        foreach (var error in result.Errors)
        {
            ModelState.AddModelError(string.Empty, error.Description);
        }
    }

    // If validation fails, return to the registration form
    return View(model);
}

Step 5: Run Database Migrations #

Don't forget to apply migrations to create the updated user table in your database:

Add-Migration AddCustomUserFields
Update-Database

To validate username/password plus your boolean field (e.g., IsAgreedToTerms or IsAccountActive), adjust your login flow to include this check.

Step 1: Create a Login ViewModel #

Standard setup for login fields:

public class LoginViewModel
{
    [Required]
    [EmailAddress]
    public string Email { get; set; }

    [Required]
    [DataType(DataType.Password)]
    public string Password { get; set; }

    [Display(Name = "Remember me?")]
    public bool RememberMe { get; set; }
}

Step 2: Add Custom Validation to the Login Action #

In your AccountController's Login action, fetch the user first, check the boolean field, then validate credentials:

[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null)
{
    ViewData["ReturnUrl"] = returnUrl;
    if (ModelState.IsValid)
    {
        // Fetch the user by email
        var user = await _userManager.FindByEmailAsync(model.Email);
        if (user == null)
        {
            ModelState.AddModelError(string.Empty, "Invalid login attempt.");
            return View(model);
        }

        // Check your boolean field (example: user must agree to terms)
        if (!user.IsAgreedToTerms)
        {
            ModelState.AddModelError(string.Empty, "You must agree to our terms of service to log in.");
            return View(model);
        }

        // Validate password and sign in
        var result = await _signInManager.PasswordSignInAsync(
            user.UserName, 
            model.Password, 
            model.RememberMe, 
            lockoutOnFailure: false);

        if (result.Succeeded)
        {
            return RedirectToLocal(returnUrl);
        }
        if (result.IsLockedOut)
        {
            return RedirectToAction(nameof(Lockout));
        }
        else
        {
            ModelState.AddModelError(string.Empty, "Invalid login attempt.");
            return View(model);
        }
    }

    // If validation fails, return to login form
    return View(model);
}

Optional: Global User Validation #

If you want to enforce the boolean field check across all auth actions (e.g., registration, login), create a custom user validator:

public class CustomUserValidator : IUserValidator<ApplicationUser>
{
    public Task<IdentityResult> ValidateAsync(UserManager<ApplicationUser> manager, ApplicationUser user)
    {
        var errors = new List<IdentityError>();
        
        if (!user.IsAgreedToTerms)
        {
            errors.Add(new IdentityError
            {
                Code = "TermsNotAccepted",
                Description = "You must accept the terms of service to use this account."
            });
        }

        return Task.FromResult(errors.Any() ? IdentityResult.Failed(errors.ToArray()) : IdentityResult.Success);
    }
}

Register it in Startup.cs:

services.AddIdentity<ApplicationUser, IdentityRole>()
    .AddEntityFrameworkStores<ApplicationDbContext>()
    .AddDefaultTokenProviders()
    .AddUserValidator<CustomUserValidator>();

• Make sure your registration view uses asp-for tag helpers to bind all 12 properties correctly (e.g., <input asp-for="FullName" />, <input asp-for="IsAgreedToTerms" type="checkbox" />).
• Double-check data annotations (like [Required], [DataType]) on your ViewModel to ensure client-side validation works.
• Test edge cases: empty fields, invalid dates, boolean fields left unchecked.

内容的提问来源于stack exchange，提问作者Mwemezijr