Configurer Microsoft.AspNet.Identity pour autoriser l'adresse e-mail comme nom d'utilisateur

Je suis en train de créer une nouvelle application et j'ai commencé à utiliser 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. et avec les versions RTM d'hier, je les ai mises à jour via NuGet ce soir vers RTM.

Mis à part quelques changements de code dans le travail que j'avais effectué jusqu'à présent, tout semblait bien se passer, jusqu'à ce que j'essaie de créer un compte d'utilisateur local pour l'application.

J'avais travaillé sur des adresses e-mail au format de nom d'utilisateur qui avec la release candidate fonctionnait très bien, mais maintenant, lors de la création d'un utilisateur avec une adresse e-mail pour un nom d'utilisateur, cela génère l'erreur de validation suivante:

Le nom d'utilisateur [email protected] n'est pas valide, ne peut contenir que des lettres ou des chiffres.

J'ai passé la dernière heure à chercher une solution ou une documentation sur les options de configuration, mais en vain.

Existe-t-il un moyen de le configurer pour autoriser les adresses e-mail pour les noms d'utilisateur?

Vous pouvez autoriser cela en branchant votre propre UserValidator sur le UserManager, ou simplement en le désactivant sur l'implémentation par défaut:

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

La version C # de this (dans App_Code \ IdentityModels.cs) est

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

Dans mon cas, en cours d'exécution dans VS 2013 C #, MVC 5.2.2, en utilisant ASP.NET Identity 2.0, la solution était de mettre à jour le constructeur ApplicationUserManager dans App_Start \ IdentityConfig.cs comme ceci:

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

J'ai eu le même problème, lorsque j'ai essayé de changer le code pour que le nom d'utilisateur soit le vrai nom de la personne et non l'e-mail, le système m'affiche le même message d'erreur "Le nom d'utilisateur ABC DEF est invalide, ne peut contenir que des lettres ou des chiffres . " J'ai résolu le problème en ajoutant le caractère d'espace (dans mon cas à la fin) à AllowedUserNameCharacters.

Im utilisant Asp.Net Core 2.2 et VS2017

C'est mon code

Accédez à Startup.cs et modifiez ou ajoutez la ligne sous "// paramètres utilisateur":

        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 vous utilisez des formulaires Web ASP.Net et que vous essayez d'accomplir cela, ouvrez simplement votre fichier IdentityModels.vb / cs et sous Public Class UserManager, faites-le ressembler à ceci:

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

Pour les personnes sur AspNet.Identity.Core 2.1 et versions ultérieures, ces validateurs dans UserManager sont en lecture seule. Les adresses e-mail en tant que noms d'utilisateur sont autorisées par défaut, mais si vous avez besoin d'une personnalisation supplémentaire des caractères de vos noms d'utilisateur, vous pouvez le faire dans Startup.cs comme ceci:

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

    // ... etc
}

(J'avais besoin d'un '/' pour des raisons d'héritage.)

Depuis le codage de ma propre classe ApplicationUserManager: UserManager ne fonctionnait pas pour moi (peut-être que j'utilise Razor Pages, pas MVC), voici une autre solution: dans Startup.cs dans CofigureServices (), vous pouvez configurer les options d'identité, par exemple:

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

Plus d'informations sur ce sujet dans la documentation Microsoft: https://docs.microsoft.com/de-de/aspnet/core/security/authentication/identity-configuration?view=aspnetcore-2.2

Si vous ne trouvez pas IdentityConfig.cs, remplacez votre constructeur AccountController par ce code.

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

Dans mon cas, j'avais une classe de référentiel fonctionnant avec l'authentification, qui ne me permettait pas d'utiliser un "-" à l'intérieur des noms d'utilisateur. Le correctif était à l'intérieur du constructeur ici:

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

J'étais également coincé avec cela parce que la plupart du temps, les noms d'utilisateur sont des e-mails de nos jours, je peux comprendre le raisonnement d'un champ E-mail séparé. Ce ne sont que mes pensées / expériences car je n'ai pas non plus trouvé le mot de Microsoft à ce sujet.

Rappelez-vous, Asp Identity sert uniquement à identifier quelqu'un, vous n'avez pas besoin d'avoir un e-mail pour être identifié mais ils nous permettent de le stocker car il fait partie d'une identité. Lorsque vous créez un nouveau projet Web dans Visual Studio, vous avez la possibilité d'utiliser des options d'authentification.

Si vous sélectionnez un type de projet non vide tel que MVC et que vous définissez l'authentification sur "Comptes individuels", les bases de la gestion des utilisateurs vous sont fournies. L'une d'elles inclut une sous-classe ressemblant à ceci dans 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
}

Ce que cela nous dit, c'est que Microsoft a l'intention de stocker des noms d'utilisateurs plus complexes (reportez-vous à AllowOnlyAlphaNumericUserNames = false), donc nous avons vraiment des signaux mixtes.

Le fait que cela soit généré à partir d'un projet Web par défaut nous donne une bonne indication / direction de Microsoft (et une manière propre) pour nous permettre de saisir des e-mails dans le champ nom d'utilisateur. Il est propre car la méthode de création statique est utilisée dans App_Start \ Startup.Auth.cs lors du démarrage de l'application avec le contexte Microsoft.OWIN.

Le seul inconvénient de cette approche est que vous finissez par stocker le courrier électronique deux fois ... Ce qui n'est pas bon!

Comme vous l'aurez probablement découvert (et il fallait s'y attendre), ASP.NET Identity 2.0.0, sorti en mars 2014, ajoute cette fonctionnalité dans le framework.

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

Exemple complet et tutoriel, y compris la confirmation de compte: http://www.asp.net/identity/overview/features-api/account-confirmation-and-password-recovery-with-aspnet-identity

Si vous utilisez une sorte d'IOC (j'utilise StructureMap) dans votre contrôleur de compte, vous devrez appliquer le correctif mentionné ci-dessus par Hao Kung lorsque l'Usermanager est passé: (je devais). Il y a peut-être un moyen de le faire dans la configuration IOC, mais je ne sais pas comment.

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

J'ai été confronté au même problème. mais finalement j'ai résolu le problème en ajoutant la partie ci-dessous à ma méthode, pas au constructeur.

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

                    };         

}