Comment localiser ASP.NET Identité nom d'utilisateur et le Mot de passe des messages d'erreur?

Pas encore, nous avons un suivi de bogues de cet élément de travail pour permettre la spécification d'où viendront les ressources.

ASP NET de Base d'une solution (25.11.2016)

Vous pouvez injecter IStringLocalizer dans des IdentityErrorDescriber

1) Créer des IdentityErrorDescriber (voir Gerardo Grignoli réponse)

public class MultilanguageIdentityErrorDescriber : IdentityErrorDescriber
{
    private readonly IStringLocalizer<SharedResource> _localizer;

    public MultilanguageIdentityErrorDescriber(IStringLocalizer<SharedResource> localizer)
    {
        _localizer = localizer;
    }

    public override IdentityError DuplicateEmail(string email)
    {
        return new IdentityError()
        {
            Code = nameof(DuplicateEmail),
            Description = string.Format(_localizer["Email {0} is already taken."], email)
        };
    }

    //DuplicateUserName, InvalidEmail, DuplicateUserName etc
}

2) Inscrivez-vous MultilanguageIdentityErrorDescriber en Démarrage.cs

services.AddIdentity<IdentityUser, IdentityRole>()
            .AddErrorDescriber<MultilanguageIdentityErrorDescriber>()
            .AddDefaultTokenProviders();

3) Ajouter des messages d'erreur à SharedResource.de langue.resx.

Version allemande pour la Solution de @GerardoGrignoli

public class CustomIdentityErrorDescriber : IdentityErrorDescriber
{
    public override IdentityError DefaultError() { return new IdentityError { Code = nameof(DefaultError), Description = $"Ein unbekannter Fehler ist aufgetreten." }; }
    public override IdentityError ConcurrencyFailure() { return new IdentityError { Code = nameof(ConcurrencyFailure), Description = "Fehler bzgl. der Optimistischen Nebenläufigkeit, das Objekt wurde verändert." }; }
    public override IdentityError PasswordMismatch() { return new IdentityError { Code = nameof(PasswordMismatch), Description = "Ungültiges Passwort." }; }
    public override IdentityError InvalidToken() { return new IdentityError { Code = nameof(InvalidToken), Description = "Ungültiger Token." }; }
    public override IdentityError LoginAlreadyAssociated() { return new IdentityError { Code = nameof(LoginAlreadyAssociated), Description = "Es ist bereits ein Nutzer mit diesem Login vorhanden." }; }
    public override IdentityError InvalidUserName(string userName) { return new IdentityError { Code = nameof(InvalidUserName), Description = $"Nutzername '{userName}' ist ungültig. Erlaubt sind nur Buchstaben und Zahlen." }; }
    public override IdentityError InvalidEmail(string email) { return new IdentityError { Code = nameof(InvalidEmail), Description = $"E-Mail '{email}' ist ungültig." }; }
    public override IdentityError DuplicateUserName(string userName) { return new IdentityError { Code = nameof(DuplicateUserName), Description = $"Nutzername '{userName}' ist bereits vergeben." }; }
    public override IdentityError DuplicateEmail(string email) { return new IdentityError { Code = nameof(DuplicateEmail), Description = $"E-Mail '{email}' ist bereits vergeben." }; }
    public override IdentityError InvalidRoleName(string role) { return new IdentityError { Code = nameof(InvalidRoleName), Description = $"Rollen-Name '{role}' ist ungültig." }; }
    public override IdentityError DuplicateRoleName(string role) { return new IdentityError { Code = nameof(DuplicateRoleName), Description = $"Rollen-Name '{role}' ist bereits vergeben." }; }
    public override IdentityError UserAlreadyHasPassword() { return new IdentityError { Code = nameof(UserAlreadyHasPassword), Description = "Nutzer hat bereits ein Passwort gesetzt." }; }
    public override IdentityError UserLockoutNotEnabled() { return new IdentityError { Code = nameof(UserLockoutNotEnabled), Description = "Aussperrung ist für diesen Nutzer nicht aktiviert." }; }
    public override IdentityError UserAlreadyInRole(string role) { return new IdentityError { Code = nameof(UserAlreadyInRole), Description = $"Nutzer ist bereits in Rolle '{role}'." }; }
    public override IdentityError UserNotInRole(string role) { return new IdentityError { Code = nameof(UserNotInRole), Description = $"Nutzer ist nicht in Rolle '{role}'." }; }
    public override IdentityError PasswordTooShort(int length) { return new IdentityError { Code = nameof(PasswordTooShort), Description = $"Passwörter müssen mindestens {length} Zeichen lang sein." }; }
    public override IdentityError PasswordRequiresNonAlphanumeric() { return new IdentityError { Code = nameof(PasswordRequiresNonAlphanumeric), Description = "Passwörter müssen mindestens ein Sonderzeichen enthalten." }; }
    public override IdentityError PasswordRequiresDigit() { return new IdentityError { Code = nameof(PasswordRequiresDigit), Description = "Passwörter müssen mindestens eine Ziffer enthalten ('0'-'9')." }; }
    public override IdentityError PasswordRequiresLower() { return new IdentityError { Code = nameof(PasswordRequiresLower), Description = "Passwörter müssen mindestens einen Kleinbuchstaben enthalten ('a'-'z')." }; }
    public override IdentityError PasswordRequiresUpper() { return new IdentityError { Code = nameof(PasswordRequiresUpper), Description = "Passwörter müssen mindestens einen Großbuchstaben enthalten ('A'-'Z')." }; }
}

Je ne veux pas remplacer la logique (c'est à dire, de ré-inventer la roue), je ne veux pour passer en ASP NET de Base. Tout ce que je veux faire est de remplacer les messages d'erreur et d'utiliser plusieurs fichiers de ressources (par langue) afin de personnaliser l'expérience de l'utilisateur de la langue de leur choix.

Voici ma solution:

1. J'ai créé un " IdentityErrors.resx' fichier de ressources avec les éléments suivants:

   <data name="DefaultError" xml:space="preserve">
       <value>An unknown failure has occured.</value>
   </data>
   <data name="DuplicateEmail" xml:space="preserve">
       <value>Email '{0}' is already taken.</value>
   </data>
   <data name="DuplicateName" xml:space="preserve">
       <value>Name {0} is already taken.</value>
   </data>
   <data name="ExternalLoginExists" xml:space="preserve">
       <value>A user with that external login already exists.</value>
   </data>
   <data name="InvalidEmail" xml:space="preserve">
       <value>Email '{0}' is invalid.</value>
   </data>
   <data name="InvalidToken" xml:space="preserve">
       <value>Invalid token.</value>
   </data>
   <data name="InvalidUserName" xml:space="preserve">
       <value>User name {0} is invalid, can only contain letters or digits.</value>
   </data>
   <data name="LockoutNotEnabled" xml:space="preserve">
       <value>Lockout is not enabled for this user.</value>
   </data>
   <data name="NoTokenProvider" xml:space="preserve">
       <value>No IUserTokenProvider is registered.</value>
   </data>
   <data name="NoTwoFactorProvider" xml:space="preserve">
       <value>No IUserTwoFactorProvider for '{0}' is registered.</value>
   </data>
   <data name="PasswordMismatch" xml:space="preserve">
       <value>Incorrect password.</value>
   </data>
   <data name="PasswordRequireDigit" xml:space="preserve">
       <value>Passwords must have at least one digit ('0'-'9').</value>
   </data>
   <data name="PasswordRequireLower" xml:space="preserve">
       <value>Passwords must have at least one lowercase ('a'-'z').</value>
   </data>
   <data name="PasswordRequireNonLetterOrDigit" xml:space="preserve">
       <value>Passwords must have at least one non letter or digit character.</value>
   </data>
   <data name="PasswordRequireUpper" xml:space="preserve">
       <value>Passwords must have at least one uppercase ('A'-'Z').</value>
   </data>
   <data name="PasswordTooShort" xml:space="preserve">
       <value>Passwords must be at least {0} characters.</value>
   </data>
   <data name="PropertyTooShort" xml:space="preserve">
       <value>{0} cannot be null or empty.</value>
   </data>
   <data name="RoleNotFound" xml:space="preserve">
       <value>Role {0} does not exist.</value>
   </data>
   <data name="StoreNotIQueryableRoleStore" xml:space="preserve">
       <value>Store does not implement IQueryableRoleStore&amp;lt;TRole&amp;gt;.</value>
   </data>
   <data name="StoreNotIQueryableUserStore" xml:space="preserve">
       <value>Store does not implement IQueryableUserStore&amp;lt;TUser&amp;gt;.</value>
   </data>
   <data name="StoreNotIUserClaimStore" xml:space="preserve">
       <value>Store does not implement IUserClaimStore&amp;lt;TUser&amp;gt;.</value>
   </data>
   <data name="StoreNotIUserConfirmationStore" xml:space="preserve">
       <value>Store does not implement IUserConfirmationStore&amp;lt;TUser&amp;gt;.</value>
   </data>
   <data name="StoreNotIUserEmailStore" xml:space="preserve">
       <value>Store does not implement IUserEmailStore&amp;lt;TUser&amp;gt;.</value>
   </data>
   <data name="StoreNotIUserLockoutStore" xml:space="preserve">
       <value>Store does not implement IUserLockoutStore&amp;lt;TUser&amp;gt;.</value>
   </data>
   <data name="StoreNotIUserLoginStore" xml:space="preserve">
       <value>Store does not implement IUserLoginStore&amp;lt;TUser&amp;gt;.</value>
   </data>
   <data name="StoreNotIUserPasswordStore" xml:space="preserve">
       <value>Store does not implement IUserPasswordStore&amp;lt;TUser&amp;gt;.</value>
   </data>
   <data name="StoreNotIUserPhoneNumberStore" xml:space="preserve">
       <value>Store does not implement IUserPhoneNumberStore&amp;lt;TUser&amp;gt;.</value>
   </data>
   <data name="StoreNotIUserRoleStore" xml:space="preserve">
       <value>Store does not implement IUserRoleStore&amp;lt;TUser&amp;gt;.</value>
   </data>
   <data name="StoreNotIUserSecurityStampStore" xml:space="preserve">
       <value>Store does not implement IUserSecurityStampStore&amp;lt;TUser&amp;gt;.</value>
   </data>
   <data name="StoreNotIUserTwoFactorStore" xml:space="preserve">
       <value>Store does not implement IUserTwoFactorStore&amp;lt;TUser&amp;gt;.</value>
   </data>
   <data name="UserAlreadyHasPassword" xml:space="preserve">
       <value>User already has a password set.</value>
   </data>
   <data name="UserAlreadyInRole" xml:space="preserve">
       <value>User already in role.</value>
   </data>
   <data name="UserIdNotFound" xml:space="preserve">
       <value>UserId not found.</value>
   </data>
   <data name="UserNameNotFound" xml:space="preserve">
       <value>User {0} does not exist.</value>
   </data>
   <data name="UserNotInRole" xml:space="preserve">
       <value>User is not in role.</value>
   </data>
   

2. J'ai créé un IdentityResultErrorMessages.cs' classe:

   public class IdentityResultErrorMessages
   {
     public static List<String> GetResourceEquivalent(IEnumerable<string> errors)
     {
       List<String> errorList = new List<String>();
       if (errors != null)
       {
         foreach (String error in errors)
         {
           if (error.StartsWith("An unknown failure has occured."))
           {
             errorList.Add(IdentityErrors.DefaultError);
           }
           else if (error.StartsWith("Email '") && error.EndsWith("' is already taken."))
           {
             errorList.Add(String.Format(IdentityErrors.DuplicateEmail, error.Replace("Email '", "").Replace("' is already taken.", "")));
           }
           else if (error.StartsWith("Name ") && error.EndsWith(" is already taken."))
           {
             errorList.Add(String.Format(IdentityErrors.DuplicateName, error.Replace("Name ", "").Replace(" is already taken.", "")));
           }
           else if (error.StartsWith("A user with that external login already exists."))
           {
             errorList.Add(IdentityErrors.ExternalLoginExists);
           }
           else if (error.StartsWith("Email '") && error.EndsWith("' is invalid."))
           {
             errorList.Add(String.Format(IdentityErrors.InvalidEmail, error.Replace("Email '", "").Replace("' is invalid.", "")));
           }
           else if (error.StartsWith("Invalid token."))
           {
             errorList.Add(IdentityErrors.InvalidToken);
           }
           else if (error.StartsWith("User name ") && error.EndsWith(" is invalid, can only contain letters or digits."))
           {
             errorList.Add(String.Format(IdentityErrors.InvalidUserName, error.Replace("User name ", "").Replace(" is invalid, can only contain letters or digits.", "")));
           }
           else if (error.StartsWith("Lockout is not enabled for this user."))
           {
             errorList.Add(IdentityErrors.LockoutNotEnabled);
           }
           else if (error.StartsWith("No IUserTokenProvider is registered."))
           {
             errorList.Add(IdentityErrors.NoTokenProvider);
           }
           else if (error.StartsWith("No IUserTwoFactorProvider for '") && error.EndsWith("' is registered."))
           {
             errorList.Add(String.Format(IdentityErrors.NoTwoFactorProvider, error.Replace("No IUserTwoFactorProvider for '", "").Replace("' is registered.", "")));
           }
           else if (error.StartsWith("Incorrect password."))
           {
             errorList.Add(IdentityErrors.PasswordMismatch);
           }
           else if (error.StartsWith("Passwords must have at least one digit ('0'-'9')."))
           {
             errorList.Add(IdentityErrors.PasswordRequireDigit);
           }
           else if (error.StartsWith("Passwords must have at least one lowercase ('a'-'z')."))
           {
             errorList.Add(IdentityErrors.PasswordRequireLower);
           }
           else if (error.StartsWith("Passwords must have at least one non letter or digit character."))
           {
             errorList.Add(IdentityErrors.PasswordRequireNonLetterOrDigit);
           }
           else if (error.StartsWith("Passwords must have at least one uppercase ('A'-'Z')."))
           {
             errorList.Add(IdentityErrors.PasswordRequireUpper);
           }
           else if (error.StartsWith("Passwords must be at least ") && error.EndsWith(" characters."))
           {
             errorList.Add(String.Format(IdentityErrors.PasswordTooShort, error.Replace("Passwords must be at least ", "").Replace(" characters.", "")));
           }
           else if (error.EndsWith(" cannot be null or empty."))
           {
             errorList.Add(String.Format(IdentityErrors.PropertyTooShort, error.Replace(" cannot be null or empty.", "")));
           }
           else if (error.StartsWith("Role ") && error.EndsWith(" does not exist."))
           {
             errorList.Add(String.Format(IdentityErrors.RoleNotFound, error.Replace("Role ", "").Replace(" does not exist.", "")));
           }
           else if (error.StartsWith("Store does not implement IQueryableRoleStore"))
           {
             errorList.Add(IdentityErrors.StoreNotIQueryableRoleStore);
           }
           else if (error.StartsWith("Store does not implement IQueryableUserStore"))
           {
             errorList.Add(IdentityErrors.StoreNotIQueryableUserStore);
           }
           else if (error.StartsWith("Store does not implement IUserClaimStore"))
           {
             errorList.Add(IdentityErrors.StoreNotIUserClaimStore);
           }
           else if (error.StartsWith("Store does not implement IUserConfirmationStore"))
           {
             errorList.Add(IdentityErrors.StoreNotIUserConfirmationStore);
           }
           else if (error.StartsWith("Store does not implement IUserEmailStore"))
           {
             errorList.Add(IdentityErrors.StoreNotIUserEmailStore);
           }
           else if (error.StartsWith("Store does not implement IUserLockoutStore"))
           {
             errorList.Add(IdentityErrors.StoreNotIUserLockoutStore);
           }
           else if (error.StartsWith("Store does not implement IUserLoginStore"))
           {
             errorList.Add(IdentityErrors.StoreNotIUserLoginStore);
           }
           else if (error.StartsWith("Store does not implement IUserPasswordStore"))
           {
             errorList.Add(IdentityErrors.StoreNotIUserPasswordStore);
           }
           else if (error.StartsWith("Store does not implement IUserPhoneNumberStore"))
           {
             errorList.Add(IdentityErrors.StoreNotIUserPhoneNumberStore);
           }
           else if (error.StartsWith("Store does not implement IUserRoleStore"))
           {
             errorList.Add(IdentityErrors.StoreNotIUserRoleStore);
           }
           else if (error.StartsWith("Store does not implement IUserSecurityStampStore"))
           {
             errorList.Add(IdentityErrors.StoreNotIUserSecurityStampStore);
           }
           else if (error.StartsWith("Store does not implement IUserTwoFactorStore"))
           {
             errorList.Add(IdentityErrors.StoreNotIUserTwoFactorStore);
           }
           else if (error.StartsWith("User already has a password set."))
           {
             errorList.Add(IdentityErrors.UserAlreadyHasPassword);
           }
           else if (error.StartsWith("User already in role."))
           {
             errorList.Add(IdentityErrors.UserAlreadyInRole);
           }
           else if (error.StartsWith("UserId not found."))
           {
             errorList.Add(IdentityErrors.UserIdNotFound);
           }
           else if (error.StartsWith("User ") && error.EndsWith(" does not exist."))
           {
             errorList.Add(String.Format(IdentityErrors.UserNameNotFound, error.Replace("User ", "").Replace(" does not exist.", "")));
           }
           else if (error.StartsWith("User is not in role."))
           {
             errorList.Add(IdentityErrors.UserNotInRole);
           }
         }
       }
       return errorList;
     }
   }
   

3. J'ai changé le Contrôleur de AddErrors méthode à la suivante:

   private void AddErrors(IdentityResult result)
   {
     foreach (var error in IdentityResultErrorMessages.GetResourceEquivalent(result.Errors))
     {
       ModelState.AddModelError("", error);
     }
   }
   

Maintenant, je peux créer des fichiers de ressources pour les autres contenus de langue je veux le servir sur mon site web.

Ici est Gerardo Grignoli réponse avec traduction en français

///<inheritdoc />
///<summary>
///Service to enable localization (french) for application facing identity errors.
///</summary>
public class FrenchIdentityErrorDescriber : IdentityErrorDescriber
{
    ///<inheritdoc />
    public override IdentityError DefaultError() => new IdentityError { Code = nameof(DefaultError), Description = "Une erreur inconnue est survenue." };

    ///<inheritdoc />
    public override IdentityError ConcurrencyFailure() => new IdentityError { Code = nameof(ConcurrencyFailure), Description = "Erreur de concurrence simultanée optimiste, l'objet a été modifié." };

    ///<inheritdoc />
    public override IdentityError PasswordMismatch() => new IdentityError { Code = nameof(PasswordMismatch), Description = "Mot de passe incorrect." };

    ///<inheritdoc />
    public override IdentityError InvalidToken() => new IdentityError { Code = nameof(InvalidToken), Description = "Jeton invalide." };

    ///<inheritdoc />
    public override IdentityError LoginAlreadyAssociated() => new IdentityError { Code = nameof(LoginAlreadyAssociated), Description = "Un utilisateur avec ce nom de compte existe déjà." };

    ///<inheritdoc />
    public override IdentityError InvalidUserName(string userName) => new IdentityError { Code = nameof(InvalidUserName), Description = $"Le nom de compte '{userName}' est invalide. Seuls les lettres et chiffres sont autorisés." };

    ///<inheritdoc />
    public override IdentityError InvalidEmail(string email) => new IdentityError { Code = nameof(InvalidEmail), Description = $"L'email '{email}' est invalide." };

    ///<inheritdoc />
    public override IdentityError DuplicateUserName(string userName) => new IdentityError { Code = nameof(DuplicateUserName), Description = $"Le nom de compte '{userName}' est déjà utilisé." };

    ///<inheritdoc />
    public override IdentityError DuplicateEmail(string email) => new IdentityError { Code = nameof(DuplicateEmail), Description = $"L'email '{email} est déjà utilisée." };

    ///<inheritdoc />
    public override IdentityError InvalidRoleName(string role) => new IdentityError { Code = nameof(InvalidRoleName), Description = $"Le nom du rôle '{role}' est invalide." };

    ///<inheritdoc />
    public override IdentityError DuplicateRoleName(string role) => new IdentityError { Code = nameof(DuplicateRoleName), Description = $"Le nom du rôle '{role}' est déjà utilisé." };

    ///<inheritdoc />
    public override IdentityError UserAlreadyHasPassword() => new IdentityError { Code = nameof(UserAlreadyHasPassword), Description = "L'utilisateur a déjà un mot de passe." };

    ///<inheritdoc />
    public override IdentityError UserLockoutNotEnabled() => new IdentityError { Code = nameof(UserLockoutNotEnabled), Description = "Le verouillage n'est pas activé pour cet utilisateur." };

    ///<inheritdoc />
    public override IdentityError UserAlreadyInRole(string role) => new IdentityError { Code = nameof(UserAlreadyInRole), Description = $"L'utilisateur a déjà le rôle '{role}'." };

    ///<inheritdoc />
    public override IdentityError UserNotInRole(string role) => new IdentityError { Code = nameof(UserNotInRole), Description = $"L'utilisateur n'a pas le rôle '{role}'." };

    ///<inheritdoc />
    public override IdentityError PasswordTooShort(int length) => new IdentityError { Code = nameof(PasswordTooShort), Description = $"Le mot de passe doit contenir au moins {length} caractères." };

    ///<inheritdoc />
    public override IdentityError PasswordRequiresNonAlphanumeric() => new IdentityError { Code = nameof(PasswordRequiresNonAlphanumeric), Description = "Le mot de passe doit contenir au moins un caractère non alpha-numérique." };

    ///<inheritdoc />
    public override IdentityError PasswordRequiresDigit() => new IdentityError { Code = nameof(PasswordRequiresDigit), Description = "Le mot de passe doit contenir au moins un chiffre ('0'-'9')." };

    ///<inheritdoc />
    public override IdentityError PasswordRequiresLower() => new IdentityError { Code = nameof(PasswordRequiresLower), Description = "Le mot de passe doit contenir au moins un charactère minuscule ('a'-'z')." };

    ///<inheritdoc />
    public override IdentityError PasswordRequiresUpper() => new IdentityError { Code = nameof(PasswordRequiresUpper), Description = "Le mot de passe doit contenir au moins un charactère majuscule ('A'-'Z')." };
}

Salut Voici Ma Solution pour traduire l'identité des erreurs:

 public string TranslateIdentityResult(string massage)
    {

        var list = new List<KeyValuePair<string, string>>() {
            new KeyValuePair<string, string>("An unknown failure has occured.", "حدث خطأ غير معروف"),
            new KeyValuePair<string, string>("Email '{0}' is already taken.", "هذا البريد '{0}' موجود بالفعل"),
            new KeyValuePair<string, string>("Name {0} is already taken.", "الاسم {0} مأخوذ بالفعل."),
            new KeyValuePair<string, string>("A user with that external login already exists.", "يوجد بالفعل مستخدم له معلومات تسجيل الدخول الخارجية."),
            new KeyValuePair<string, string>("Email '{0}' is invalid.", "البريد الإلكتروني '{0}' غير صحيح."),
            new KeyValuePair<string, string>("Invalid token.", "المفتاح غير صالح"),
            new KeyValuePair<string, string>("User name {0} is invalid, can only contain letters or digits.", "اسم المستخدم {0} غير صالح ، يمكن أن يحتوي فقط على أحرف أو أرقام."),
            new KeyValuePair<string, string>("Lockout is not enabled for this user.", "تأمين المستخدم غير متاح لهذا المستخدم"),
            new KeyValuePair<string, string>("Incorrect password.", "الرقم السري غير صحيح"),
            new KeyValuePair<string, string>("Passwords must have at least one digit ('0'-'9').", "الرقم السري يجب أ،ن يحتوي على الأقل رقم واحد (0-9)"),
            new KeyValuePair<string, string>("Passwords must have at least one lowercase ('a'-'z').", "يجب أن تحتوي كلمات المرور على حرف صغير واحد على الأقل ('a' - 'z')."),
            new KeyValuePair<string, string>("Passwords must have at least one non letter or digit character.", "يجب أن يكون لكلمة مرور حرف واحد على الأقل غير الحرف أو الرقم."),
            new KeyValuePair<string, string>("Passwords must have at least one uppercase ('A'-'Z').", "يجب أن تحتوي كلمات المرور على حرف كبير واحد على الأقل ('A' - 'Z')."),
            new KeyValuePair<string, string>("Passwords must be at least {0} characters.", "يجب أن تكون كلمات المرور على الأقل {0} حرفًا."),
            new KeyValuePair<string, string>("{0} cannot be null or empty.", "لا يمكن أن يكون {0} خاليًا أو فارغًا."),
            new KeyValuePair<string, string>("Role {0} does not exist.", "صلاحية {0} غير موجود."),
            new KeyValuePair<string, string>("User already has a password set.", "المستخدم لديه بالفعل كلمة مرور محددة."),
            new KeyValuePair<string, string>("User already in role.", "المستخدم بالفعل لديه هذي الصلاحية."),
            new KeyValuePair<string, string>("UserId not found.", "لم يتم العثور على هوية المستخدم."),
            new KeyValuePair<string, string>("User {0} does not exist.", "المستخدم {0} غير موجود."),
            new KeyValuePair<string, string>("User is not in role.", "المستخدم ليس لديه صلاحية.")
        };

        return list.Find(x => x.Key.Equals(massage)).Value;
    }

 private void AddErrors(IdentityResult result)
    {
        foreach (var error in result.Errors)
        {
            //if my function is not found error it will print it as it's
            foreach(var msg in error.Split('.'))
            {
                ModelState.AddModelError("", accBClass.TranslateIdentityResult(msg.TrimStart(' ')) ?? msg);
            }
        }
    }

Exemple

Version polonaise

public class CustomErrorDescriber : IdentityErrorDescriber
{
    public override IdentityError DefaultError() {      return new IdentityError { Code = nameof(DefaultError), Description = $"Wystąpił nieanany błąd." }; }
    public override IdentityError ConcurrencyFailure() { return new IdentityError { Code = nameof(ConcurrencyFailure), Description = "Błąd współbieżności, obiekt został zmodyfikowany." }; }
    public override IdentityError PasswordMismatch() { return new IdentityError { Code = nameof(PasswordMismatch), Description = "Nieprawidłowe hasło." }; }
    public override IdentityError InvalidToken() { return new IdentityError { Code = nameof(InvalidToken), Description = "Nieprawidłowy token." }; }
    public override IdentityError LoginAlreadyAssociated() { return new IdentityError { Code = nameof(LoginAlreadyAssociated), Description = "Użytkownik o takiej nazwie już istnieje." }; }
    public override IdentityError InvalidUserName(string userName) { return new IdentityError { Code = nameof(InvalidUserName), Description = $"Nazwa użytkownika \"'{userName}'\" jest nieprawidłowa, może posiadać tylko znaki i cyfry." }; }
    public override IdentityError InvalidEmail(string email) { return new IdentityError { Code = nameof(InvalidEmail), Description = $"Email \"'{email}'\" jest nieprawidłowy." }; }
    public override IdentityError DuplicateUserName(string userName) { return new IdentityError { Code = nameof(DuplicateUserName), Description = $"Nazwa użytkownika \"'{userName}'\" jest zajęta." }; }
    public override IdentityError DuplicateEmail(string email) { return new IdentityError { Code = nameof(DuplicateEmail), Description = $"Adres \"'{email}'\" jest zajęty." }; }
    public override IdentityError InvalidRoleName(string role) { return new IdentityError { Code = nameof(InvalidRoleName), Description = $"Grupa \"'{role}'\" jest nieprawidłowa." }; }
    public override IdentityError DuplicateRoleName(string role) { return new IdentityError { Code = nameof(DuplicateRoleName), Description = $"Nazwa grupy \"'{role}'\" jest zajęta." }; }
    public override IdentityError UserAlreadyHasPassword() { return new IdentityError { Code = nameof(UserAlreadyHasPassword), Description = "Hasło użytkownika jest już ustawione." }; }
    public override IdentityError UserLockoutNotEnabled() { return new IdentityError { Code = nameof(UserLockoutNotEnabled), Description = "Blokada nie jest ustawiona dla tego użytkownika." }; }
    public override IdentityError UserAlreadyInRole(string role) { return new IdentityError { Code = nameof(UserAlreadyInRole), Description = $"Użytkownik ma już przypisaną grupę \"'{role}'\"." }; }
    public override IdentityError UserNotInRole(string role) { return new IdentityError { Code = nameof(UserNotInRole), Description = $"Użytkownik nie należy do grupy \"'{role}'\"." }; }
    public override IdentityError PasswordTooShort(int length) { return new IdentityError { Code = nameof(PasswordTooShort), Description = $"Hasło musi posiadać conajmniej {length} znaków." }; }
    public override IdentityError PasswordRequiresNonAlphanumeric() { return new IdentityError { Code = nameof(PasswordRequiresNonAlphanumeric), Description = "Hasło musi posiadać przynajmniej jeden znak alfanumeryczny." }; }
    public override IdentityError PasswordRequiresDigit() { return new IdentityError { Code = nameof(PasswordRequiresDigit), Description = "Hasło musi posiadać przynajmniej jedną cyfrę ('0'-'9')." }; }
    public override IdentityError PasswordRequiresLower() { return new IdentityError { Code = nameof(PasswordRequiresLower), Description = "Hasło musi posiadać przynajmniej jedną małą literę ('a'-'z')." }; }
    public override IdentityError PasswordRequiresUpper() { return new IdentityError { Code = nameof(PasswordRequiresUpper), Description = "Hasło musi posiadać przynajmniej jedną wielką literę ('A'-'Z')." }; }
    public override IdentityError PasswordRequiresUniqueChars(int uniqueChars) { return new IdentityError { Code = nameof(PasswordRequiresNonAlphanumeric), Description = "Hasło musi posiadać przynajmniej jeden znak specjalny." }; }
}

Ma solution était un peu sale, mais Il fonctionne comme prévu. L'idée est d'attribuer toutes les erreurs que le IdentityResult objet résultat apporte lors de l'enregistrement d'un nouvel utilisateur:

var result = await UserManager.CreateAsync(user, model.Password);

À une nouvelle que nous allons créer. Tout d'abord, nous avons besoin de créer une Liste qui contiendra nos erreurs personnalisées:

var erroresEspanol = new List<string>();

Ensuite, nous avons besoin d'itérer à travers les erreurs à l'intérieur résultat et ajouter une nouvelle erreur personnalisé pour chacun d'eux en fonction de ce qui fut la cause de celui-ci (en Double de l'utilisateur, e-mail, etc.):

foreach (var error in result.Errors)
            {
                if (error == ("Name " + model.Usuario + " is already taken."))
                {
                    erroresEspanol.Add("El Usuario " + model.Usuario + " ya existe.");
                }
                if (error.Substring(0, error.IndexOf(" ")) == "Email")
                {
                    erroresEspanol.Add("El Email " + model.Email + " ya fue ingresado.");
                }
                if (error.Substring(0, error.IndexOf(" ")) == "Passwords")
                {
                    erroresEspanol.Add("La contraseña debe contener mayúscula, minúscula y al menos 6 caracteres de longitud.");
                }
            }

Donc, après ce que nous venons de créer un nouveau IdentityResult objet:

var resultado = new IdentityResult(erroresEspanol);

Et le passer à la AddErrors méthode à la fin de notre Registre d'action:

AddErrors(resultado);

J'ai réussi à trouver une solution pour créer la version localisée de AspNet.D'identité pour les cultures qui n'prêt-à-utiliser le package est disponible pour. Les étapes sont les suivantes:

1. Télécharger le code source de GitHub et ouvrir la src/Microsoft.AspNet.L'identité.Projet de base dans visual studio.
2. Ajouter un nouvel élément (fichier de Ressources) pour le projet. Nom il Resources.aa-BB.resx qui aa-BB est la culture, il faut localiser l'assemblée. ex.: Resources.fa-IR.resx.
3. Ouvrez le nouveau fichier créé et copie des ressources de Resources.resx à elle.
4. Localiser les textes que vous le souhaitez.
5. Construire le projet.
6. Aller à la bin dossier et sous la Debug ou Release répertoire vous pouvez voir un dossier nommé aa-BB (la culture que vous avez saisi précédemment). Copiez le dossier de la bin répertoire de votre projet.
7. Faire les changements que @1AmirJalali dit (ce post).
8. Bien fait! La localisation est terminée. Essayez de partager vos localisée package 🙂