Configure Microsoft.AspNet.Identity para permitir la dirección de correo electrónico como nombre de usuario

Estoy en el proceso de crear una nueva aplicación y comencé a usar EF6-rc1, Microsoft.AspNet.Identity.Core 1.0.0-rc1, Microsoft.AspNet.Identity.EntityFramework 1.0.0-rc1, Microsoft.AspNet.Identity .Owin 1.0.0-rc1, etc. y con las versiones de RTM de ayer, las actualicé a través de NuGet esta noche a RTM.

Aparte de un par de cambios en el código del trabajo que había hecho hasta ahora, todo parecía ir bien, hasta que intenté crear una cuenta de usuario local para la aplicación.

Había estado trabajando en que las direcciones de correo electrónico fueran el formato de nombre de usuario que con el candidato de lanzamiento funcionó muy bien, pero ahora, al crear un usuario con una dirección de correo electrónico para un nombre de usuario, arroja el siguiente error de validación:

El nombre de usuario [email protected] no es válido, solo puede contener letras o dígitos.

Pasé la última hora más o menos buscando una solución o documentación sobre las opciones de configuración, pero fue en vano.

¿Hay alguna forma de configurarlo para permitir direcciones de correo electrónico para nombres de usuario?

Puede permitir esto conectando su propio UserValidator en el UserManager, o simplemente desactivándolo en la implementación predeterminada:

UserManager.UserValidator = new UserValidator<TUser>(UserManager) { AllowOnlyAlphanumericUserNames = false }

La versión C # de esto (en App_Code \ IdentityModels.cs) es

public UserManager()
        : base(new UserStore<ApplicationUser>(new ApplicationDbContext()))
    {
        UserValidator = new UserValidator<ApplicationUser>(this) { AllowOnlyAlphanumericUserNames = false };
    }

En mi caso, ejecutándome en VS 2013 C #, MVC 5.2.2, usando ASP.NET Identity 2.0, la solución fue actualizar el constructor ApplicationUserManager dentro de App_Start \ IdentityConfig.cs así:

public ApplicationUserManager(IUserStore<ApplicationUser> store)
        : base(store)
    {
        this.UserValidator = new UserValidator<ApplicationUser>(this) { AllowOnlyAlphanumericUserNames = false };
    }

Tuve el mismo problema, cuando intenté cambiar el código para que el nombre de usuario fuera el nombre real de la persona y no el correo electrónico, el sistema me mostró el mismo mensaje de error "El nombre de usuario ABC DEF no es válido, solo puede contener letras o dígitos . " Resolví el problema agregando el carácter de espacio (en mi caso al final) a los caracteres de nombre de usuario permitido.

Estoy usando Asp.Net Core 2.2 y VS2017

Este es mi codigo

Vaya a Startup.cs y edite o agregue la línea debajo de "// configuración de usuario":

        services.AddDbContext<ApplicationDbContext>(options =>
            options.UseMySql(Configuration.GetConnectionString("DefaultConnection")));

        services.AddIdentity<ApplicationUser, ApplicationRole>()
            .AddEntityFrameworkStores<ApplicationDbContext>()
            .AddDefaultTokenProviders();

        services.Configure<IdentityOptions>(options =>
        {
            // Password settings.
            options.Password.RequireDigit = true;
            options.Password.RequireLowercase = true;
            options.Password.RequireNonAlphanumeric = true;
            options.Password.RequireUppercase = true;
            options.Password.RequiredLength = 6;
            options.Password.RequiredUniqueChars = 1;

            // Lockout settings.
            options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5);
            options.Lockout.MaxFailedAccessAttempts = 5;
            options.Lockout.AllowedForNewUsers = true;


            // User settings.
            options.User.AllowedUserNameCharacters =
                "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@+ ";
            options.User.RequireUniqueEmail = false;
        });

        services.ConfigureApplicationCookie(options =>

Si está utilizando formularios web ASP.Net y está tratando de lograr esto, simplemente abra su archivo IdentityModels.vb / cs y en Public Class UserManager, haga que se vea así:

Public Class UserManager
Inherits UserManager(Of ApplicationUser)

Public Sub New()
    MyBase.New(New UserStore(Of ApplicationUser)(New ApplicationDbContext()))
    Users = store
    UserValidator = New UserValidator(Of ApplicationUser)(Me) With {.AllowOnlyAlphanumericUserNames = False}
End Sub

Public Property Users() As IUserStore(Of ApplicationUser)
    Get
        Return m_Users
    End Get
    Private Set(value As IUserStore(Of ApplicationUser))
        m_Users = value
    End Set
End Property
Private m_Users As IUserStore(Of ApplicationUser)

End Class

Para las personas en AspNet.Identity.Core 2.1 y versiones posteriores, estos validadores en UserManager son de solo lectura. Las direcciones de correo electrónico como nombres de usuario están permitidas de forma predeterminada, pero si necesita más personalización de los caracteres en sus nombres de usuario, puede hacerlo en Startup.cs de esta manera:

public void ConfigureServices(IServiceCollection services)
{
    services.AddIdentity<ApplicationUser, IdentityRole>(options => {
        options.User.AllowedUserNameCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@+/";
    });

    // ... etc
}

(Necesitaba una '/' por motivos heredados).

Desde que codifiqué mi propia clase ApplicationUserManager: UserManager no funcionó para mí (tal vez porque uso Razor Pages, no MVC), aquí hay otra solución: En Startup.cs en CofigureServices () puede configurar las Opciones de identidad, por ejemplo:

services.Configure<IdentityOptions>(options =>
{
  options.User.AllowedUserNameCharacters = 
  "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ@";
  options.User.RequireUniqueEmail = true;
});

Más sobre este tema en Microsoft docs: https://docs.microsoft.com/de-de/aspnet/core/security/authentication/identity-configuration?view=aspnetcore-2.2

Si no puede encontrar IdentityConfig.cs, reemplace su constructor AccountController con este código.

public AccountController(UserManager<ApplicationUser> userManager)
{
UserManager = userManager;
UserManager.UserValidator = new UserValidator<ApplicationUser>(UserManager) 
  {
      AllowOnlyAlphanumericUserNames = false  
  };
}

En mi caso, tenía una clase de repositorio que trabajaba con autenticación, que no me permitió usar un "-" dentro de los nombres de usuario. La solución estaba dentro del constructor aquí:

//-------------------------------------------------------
public AuthRepository()
//-------------------------------------------------------
{
    _ctx = new AuthContext();
    _userManager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(_ctx));
    _userManager.UserValidator = new UserValidator<IdentityUser>(_userManager)
    {
        AllowOnlyAlphanumericUserNames = false
    };
}

También me quedé atascado con esto porque la mayoría de las veces los nombres de usuario son correos electrónicos en estos días, aunque puedo entender el razonamiento de un campo de correo electrónico separado. Estos son puramente mis pensamientos / experiencia, ya que tampoco pude encontrar la opinión de Microsoft sobre esto.

Recuerde, Asp Identity es puramente para identificar a alguien, no es necesario tener un E-mail para ser identificado pero nos permiten almacenarlo porque forma parte de una identidad. Cuando crea un nuevo proyecto web en Visual Studio, tiene la opción de opciones de autenticación.

Si selecciona un tipo de proyecto que no esté vacío, como MVC, y establece la autenticación en "Cuentas individuales", obtendrá los fundamentos básicos para la gestión de usuarios. Uno de los cuales incluye una subclase con este aspecto dentro de App_Start \ IdentityConfig.cs:

 // Configure the application user manager used in this application. UserManager is defined in ASP.NET Identity and is used by the application.
public class ApplicationUserManager : UserManager<ApplicationUser>
{
    public ApplicationUserManager(IUserStore<ApplicationUser> store)
        : base(store)
    {
    }

    public static ApplicationUserManager Create(IdentityFactoryOptions<ApplicationUserManager> options, IOwinContext context) 
    {
        var manager = new ApplicationUserManager(new UserStore<ApplicationUser>(context.Get<ApplicationDbContext>()));
        // Configure validation logic for usernames
        manager.UserValidator = new UserValidator<ApplicationUser>(manager)
        {
            AllowOnlyAlphanumericUserNames = false,
            RequireUniqueEmail = true
        };
    }
    //N.B rest of code removed
}

Lo que esto nos dice es que Microsoft tiene la intención de que almacenemos nombres de usuario más complejos (consulte AllowOnlyAlphaNumericUserNames = false), por lo que realmente tenemos señales mixtas.

El hecho de que esto se genere a partir de un proyecto web predeterminado nos da una buena indicación / dirección de Microsoft (y una forma limpia) para permitirnos ingresar correos electrónicos para el campo de nombre de usuario. Está limpio porque el método de creación estático se usa dentro de App_Start \ Startup.Auth.cs al arrancar la aplicación con el contexto Microsoft.OWIN.

El único inconveniente de este enfoque es que terminas almacenando el correo electrónico dos veces ... ¡Lo cual no es bueno!

Como probablemente habrá descubierto (y era de esperar), ASP.NET Identity 2.0.0, lanzado en marzo de 2014, agrega esta funcionalidad en el marco.

Anuncio: http://blogs.msdn.com/b/webdev/archive/2014/03/20/test-announcing-rtm-of-asp-net-identity-2-0-0.aspx

Ejemplo completo y tutorial, incluida la confirmación de la cuenta: http://www.asp.net/identity/overview/features-api/account-confirmation-and-password-recovery-with-aspnet-identity

Si está utilizando IOC de algún tipo (estoy usando StructureMap) en su controlador de cuenta, deberá aplicar la corrección mencionada anteriormente por Hao Kung cuando se pase el Usermanager: (tenía que hacerlo). Puede que haya una forma de hacerlo en la configuración de IOC, pero no sé cómo.

public AccountController(ApplicationUserManager userManager)
    {
        _userManager = userManager;
        _userManager.UserValidator = new UserValidator<ApplicationUser>(_userManager)
        {
            AllowOnlyAlphanumericUserNames = false,
            RequireUniqueEmail = true
        };

Me he enfrentado al mismo problema. pero finalmente resolví el problema agregando la parte inferior a mi método, no al constructor.

public void MyMethod(){

     UserManager<ApplicationUser> manager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new ApplicationDbContext()));


                    // Configure validation logic for usernames  
                    manager.UserValidator = new UserValidator<ApplicationUser>(manager)
                    {
                        AllowOnlyAlphanumericUserNames = false,
                        RequireUniqueEmail = true

                    };         

}