Configurare Microsoft.AspNet.Identity per consentire l'indirizzo di posta elettronica come nome utente

Sono in procinto di creare una nuova applicazione e ho iniziato a utilizzare 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, ecc. E con le versioni RTM di ieri, le ho aggiornate questa sera tramite NuGet a RTM.

A parte un paio di modifiche al codice del lavoro svolto fino a quel momento, tutto sembrava andare bene, finché non ho provato a creare un account utente locale per l'app.

Stavo lavorando su indirizzi e-mail come formato nome utente che con la release candidate funzionava benissimo, ma ora quando si crea un utente con un indirizzo e-mail per un nome utente, viene visualizzato il seguente errore di convalida:

Il nome utente xxxxx@xxxx.com non è valido, può contenere solo lettere o cifre.

Ho passato l'ultima ora o giù di lì alla ricerca di una soluzione o documentazione sulle opzioni di configurazione per esso, ma senza alcun risultato.

C'è un modo per configurarlo per consentire gli indirizzi di posta elettronica per i nomi utente?

Puoi consentirlo collegando il tuo UserValidator in UserManager, o semplicemente disattivandolo nell'implementazione predefinita:

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

La versione C # di questo (in App_Code \ IdentityModels.cs) è

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

Nel mio caso, in esecuzione in VS 2013 C #, MVC 5.2.2, utilizzando ASP.NET Identity 2.0, la soluzione era aggiornare il costruttore ApplicationUserManager all'interno di App_Start \ IdentityConfig.cs in questo modo:

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

Ho avuto lo stesso problema, quando ho provato a cambiare il codice per rendere UserName era il vero nome della persona e non l'email il sistema mi ha mostrato lo stesso messaggio di errore "Il nome utente ABC DEF non è valido, può contenere solo lettere o cifre ". Ho risolto il problema aggiungendo il carattere spazio (nel mio caso alla fine) a AllowedUserNameCharacters.

Sto usando Asp.Net Core 2.2 e VS2017

Questo è il mio codice

Vai a Startup.cs e modifica o aggiungi la riga in "// impostazioni utente":

        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 =>

Se stai usando webform ASP.Net e stai cercando di farlo, apri semplicemente il tuo file IdentityModels.vb / cs e sotto Public Class UserManager, fallo apparire così:

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

Per le persone su AspNet.Identity.Core 2.1 e versioni successive, questi validatori in UserManager sono di sola lettura. Gli indirizzi email come nomi utente sono consentiti per impostazione predefinita, ma se hai bisogno di un'ulteriore personalizzazione dei caratteri nei tuoi nomi utente, puoi farlo in Startup.cs in questo modo:

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

    // ... etc
}

(Avevo bisogno di un "/" per motivi precedenti.)

Poiché la codifica della mia classe ApplicationUserManager: UserManager non ha funzionato per me (forse bc uso Razor Pages, non MVC), ecco un'altra soluzione: in Startup.cs in CofigureServices () puoi configurare le opzioni di identità, ad esempio:

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

Ulteriori informazioni su questo argomento in Microsoft docs: https://docs.microsoft.com/de-de/aspnet/core/security/authentication/identity-configuration?view=aspnetcore-2.2

Se non riesci a trovare IdentityConfig.cs, sostituisci il costruttore AccountController con questo codice.

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

Nel mio caso avevo una classe di repository che lavorava con l'autenticazione, che non mi permetteva di usare un "-" all'interno dei nomi utente .. La correzione era all'interno del costruttore qui:

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

Sono stato anche bloccato con questo perché la maggior parte delle volte i nomi utente sono messaggi di posta elettronica in questi giorni, tuttavia posso capire il ragionamento di un campo di posta elettronica separato. Questi sono puramente i miei pensieri / esperienze poiché anche io non sono riuscito a trovare l'opinione di Microsoft su questo.

Ricorda, Asp Identity serve puramente per identificare qualcuno, non devi avere un'e-mail per essere identificato ma ci permettono di memorizzarlo perché fa parte di un'identità. Quando crei un nuovo progetto web in Visual Studio, ti viene offerta l'opzione per le opzioni di autenticazione.

Se si seleziona un tipo di progetto non vuoto come MVC e si imposta l'autenticazione su "Account individuali", vengono fornite le basi per la gestione degli utenti. Uno dei quali include una sottoclasse simile a questa in 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
}

Ciò che questo ci dice è che Microsoft intende che memorizziamo nomi utente più complessi (fare riferimento a AllowOnlyAlphaNumericUserNames = false), quindi in realtà abbiamo segnali contrastanti.

Il fatto che questo sia generato da un progetto web predefinito ci fornisce una buona indicazione / direzione da Microsoft (e un modo pulito) per permetterci di inserire e-mail per il campo del nome utente. È pulito perché il metodo di creazione statica viene utilizzato all'interno di App_Start \ Startup.Auth.cs quando si avvia l'applicazione con il contesto Microsoft.OWIN.

L'unico lato negativo di questo approccio è che si finisce per archiviare due volte l'e-mail ... Il che non va bene!

Come probabilmente avrai scoperto (ed era prevedibile), ASP.NET Identity 2.0.0, rilasciato a marzo 2014, aggiunge questa funzionalità nel framework.

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

Esempio completo e tutorial, inclusa la conferma dell'account: http://www.asp.net/identity/overview/features-api/account-confirmation-and-password-recovery-with-aspnet-identity

Se stai usando IOC di qualche tipo (sto usando StructureMap) nel tuo account controller, dovrai applicare la correzione menzionata sopra da Hao Kung quando l'Usermanager viene passato: (Dovevo). Potrebbe esserci un modo per farlo nella configurazione del CIO, ma non so come.

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

Ho affrontato lo stesso problema. ma alla fine ho risolto il problema aggiungendo la parte qui sotto al mio metodo, non il costruttore.

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

                    };         

}