Konfigurieren Sie Microsoft.AspNet.Identity so, dass die E-Mail-Adresse als Benutzername zugelassen wird

Ich bin gerade dabei, eine neue Anwendung zu erstellen, und habe mit EF6-rc1, Microsoft.AspNet.Identity.Core 1.0.0-rc1, Microsoft.AspNet.Identity.EntityFramework 1.0.0-rc1, Microsoft.AspNet.Identity begonnen .Owin 1.0.0-rc1 usw. und mit den gestrigen RTM-Releases habe ich sie heute Abend über NuGet auf RTM aktualisiert.

Abgesehen von ein paar Codeänderungen an der Arbeit, die ich bisher geleistet hatte, schien alles gut zu laufen, bis ich versuchte, ein lokales Benutzerkonto für die App zu erstellen.

Ich habe daran gearbeitet, dass E-Mail-Adressen das Benutzernamenformat sind, das mit dem Release Candidate hervorragend funktioniert hat. Beim Erstellen eines Benutzers mit einer E-Mail-Adresse für einen Benutzernamen wird jedoch der folgende Validierungsfehler ausgegeben:

Der Benutzername xxxxx@xxxx.com ist ungültig und darf nur Buchstaben oder Ziffern enthalten.

Ich habe die letzte Stunde damit verbracht, nach einer Lösung oder Dokumentation zu Konfigurationsoptionen zu suchen, aber ohne Erfolg.

Gibt es eine Möglichkeit, es so zu konfigurieren, dass E-Mail-Adressen für Benutzernamen zugelassen werden?

Sie können dies zulassen, indem Sie Ihren eigenen UserValidator in den UserManager einstecken oder ihn einfach in der Standardimplementierung deaktivieren:

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

Die C # -Version davon (in App_Code \ IdentityModels.cs) ist

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

In meinem Fall bestand die Lösung in VS 2013 C #, MVC 5.2.2, unter Verwendung von ASP.NET Identity 2.0 darin, den ApplicationUserManager-Konstruktor in App_Start \ IdentityConfig.cs wie folgt zu aktualisieren:

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

Ich hatte das gleiche Problem, als ich versuchte, den Code zu ändern, damit der Benutzername der tatsächliche Name der Person und nicht die E-Mail war. Das System zeigt mir die gleiche Fehlermeldung "Benutzername ABC DEF ist ungültig, kann nur Buchstaben oder Ziffern enthalten . " Ich habe das Problem gelöst, indem ich das Leerzeichen (in meinem Fall am Ende) zu AllowedUserNameCharacters hinzugefügt habe.

Ich benutze Asp.Net Core 2.2 und VS2017

Das ist mein Code

Gehen Sie zu Startup.cs und bearbeiten oder fügen Sie die Zeile unter "// Benutzereinstellungen" hinzu:

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

Wenn Sie ASP.Net-Webformulare verwenden und dies versuchen, öffnen Sie einfach Ihre Datei IdentityModels.vb / cs und lassen Sie sie unter Public Class UserManager folgendermaßen aussehen:

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

Für Benutzer von AspNet.Identity.Core 2.1 und höher sind diese Validatoren im UserManager schreibgeschützt. E-Mail-Adressen als Benutzernamen sind standardmäßig zulässig. Wenn Sie jedoch die Zeichen in Ihren Benutzernamen weiter anpassen müssen, können Sie dies in Startup.cs wie folgt tun:

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

    // ... etc
}

(Ich brauchte ein '/' aus alten Gründen.)

Da das Codieren meiner eigenen ApplicationUserManager: UserManager-Klasse für mich nicht funktioniert hat (möglicherweise weil ich Razor Pages und nicht MVC verwende), können Sie in Startup.cs in CofigureServices () beispielsweise Identitätsoptionen konfigurieren:

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

Weitere Informationen zu diesem Thema finden Sie in den Microsoft-Dokumenten: https://docs.microsoft.com/de-de/aspnet/core/security/authentication/identity-configuration?view=aspnetcore-2.2

Wenn Sie IdentityConfig.cs nicht finden können, ersetzen Sie Ihren AccountController-Konstruktor durch diesen Code.

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

In meinem Fall hatte ich eine Repository-Klasse, die mit Authentifizierung arbeitete, sodass ich in Benutzernamen kein "-" verwenden konnte. Der Fix befand sich hier im Konstruktor:

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

Ich war auch damit beschäftigt, weil Benutzernamen heutzutage meistens E-Mails sind. Ich kann jedoch die Gründe für ein separates E-Mail-Feld verstehen. Dies sind nur meine Gedanken / Erfahrungen, da ich auch nicht das Wort von Microsoft dazu finden konnte.

Denken Sie daran, Asp Identity dient lediglich dazu, jemanden zu identifizieren. Sie müssen keine E-Mail haben, um identifiziert zu werden, aber wir können sie speichern, da sie Teil einer Identität ist. Wenn Sie in Visual Studio ein neues Webprojekt erstellen, erhalten Sie die Option für Authentifizierungsoptionen.

Wenn Sie einen nicht leeren Projekttyp wie MVC auswählen und die Authentifizierung auf "Einzelkonten" setzen, erhalten Sie die grundlegenden Grundlagen für die Benutzerverwaltung. Eine davon enthält eine Unterklasse, die in App_Start \ IdentityConfig.cs wie folgt aussieht:

 // 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
}

Dies sagt uns, dass Microsoft beabsichtigt, komplexere Benutzernamen zu speichern (siehe AllowOnlyAlphaNumericUserNames = false), sodass wir wirklich gemischte Signale haben.

Die Tatsache, dass dies aus einem Standard-Webprojekt generiert wird, gibt uns einen guten Hinweis / eine gute Anleitung von Microsoft (und einen sauberen Weg), damit wir E-Mails für das Feld Benutzername eingeben können. Es ist sauber, da die statische Erstellungsmethode in App_Start \ Startup.Auth.cs verwendet wird, wenn die Anwendung mit dem Microsoft.OWIN-Kontext gebootet wird.

Der einzige Nachteil dieses Ansatzes ist, dass Sie die E-Mail am Ende zweimal speichern ... Was nicht gut ist!

Wie Sie wahrscheinlich herausgefunden haben (und zu erwarten waren), fügt ASP.NET Identity 2.0.0, veröffentlicht im März 2014, diese Funktionalität dem Framework hinzu.

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

Vollständiges Beispiel und Tutorial, einschließlich Kontobestätigung: http://www.asp.net/identity/overview/features-api/account-confirmation-and-password-recovery-with-aspnet-identity

Wenn Sie in Ihrem Account Controller eine Art IOC verwenden (ich verwende StructureMap), müssen Sie den oben von Hao Kung erwähnten Fix anwenden, wenn der Usermanager übergeben wird: (Ich musste). Es kann eine Möglichkeit geben, dies im IOC-Setup zu tun, aber ich weiß nicht wie.

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

Ich habe das gleiche Problem konfrontiert. Aber schließlich habe ich das Problem gelöst, indem ich meiner Methode einen Teil hinzugefügt habe, nicht den Konstruktor.

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

                    };         

}