6

ASP.Netコア機能new support for localizationASP.Netコアローカライゼーション

私のプロジェクトでは、1つの言語しか必要ありません。ほとんどのテキストと注釈では、自分の言葉で指定することができますが、ASP.Net Core自体から来るテキストの言語は英語です。

例:

  • パスワードは、少なくとも一つの大文字( 'A' - 'Z')を有していなければなりません。
  • パスワードには少なくとも1桁( '0' - '9')が必要です。
  • ユーザー名「[email protected]」は既に使用されています。
  • E-postフィールドは、有効な電子メールアドレスではありません。
  • 値 ''は無効です。

私は文化を手動で設定しようとしましたが、言語はまだ英語です。

app.UseRequestLocalization(new RequestLocalizationOptions 
{ 
    DefaultRequestCulture = new RequestCulture("nb-NO"), 
    SupportedCultures = new List<CultureInfo> { new CultureInfo("nb-NO") }, 
    SupportedUICultures = new List<CultureInfo> { new CultureInfo("nb-NO") } 
}); 

どのように私はASP.Netコアの言語を変更するか、そのデフォルトのテキストを上書きすることができますか?

+0

あなたの問題はhttp://stackoverflow.com/questions/38967433/を参照してください、それを変更するには、ASPNETアイデンティティのエラーメッセージについてのようですhow-to-change-default-error-messages-of-mvc-core-validationationsummary/38968910#38968910 –

答えて

10

上記のエラーメッセージは、ASP.NET Core Identityで定義されており、IdentityErrorDescriberによって提供されています。これまで翻訳されたリソースファイルが見つかりませんでした。ローカライズされていないと思います。私のシステム(ドイツ語ロケール)では、CultureInfoは正しく設定されていますが、翻訳されません。

カスタムIdentityErrorDescriberをコンフィグレーションして、独自のメッセージとその翻訳を返すことができます。例えば、 Startup.csあなたは自分のアクセサ関数を提供することができますあなたのエラー表現部クラスが(無効な番号のような)他のデフォルトモデルのエラーメッセージについては

services.AddIdentity<ApplicationUser, IdentityRole>() 
     .AddErrorDescriber<TranslatedIdentityErrorDescriber>(); 

ようIdentityErrorDescriberから継承されたアップ配線することができのConfigure方法で How to change default error messages of MVC Core ValidationSummary?

ModelBindingMessageProviderにあります。このプロバイダはASP.NET Core MVCで使用されており、Startup.csでも設定できます。

services.AddMvc(
      options => 
      options.ModelBindingMessageProvider.ValueIsInvalidAccessor = s => $"My not valid text for {s}"); 
+0

ありがとうございました。それがIdentity部分を解決しましたが、翻訳されていないエラーが増えています。たとえば、数値フィールドが入力されていない場合は、「値 ''が無効です」と表示されます。 –

+0

@TeddHansen - 私はlitteのリサーチを行い、答えにModelBindingMessageProvider情報を追加しました。 –

2

誰かが必要な場合に備えて、ノルウェーのアイデンティティエラーデコーダ。 rboe年代とTEDDハンセンの優れた回答に基づいて

public class NorwegianIdentityErrorDescriber : IdentityErrorDescriber 
{ 

    public override IdentityError DefaultError() 
    { 
     return new IdentityError() 
     { 
      Code = "DefaultError", 
      Description = "En ukjent feil har oppstått." 
     }; 
    } 

    public override IdentityError ConcurrencyFailure() 
    { 
     return new IdentityError() 
     { 
      Code = "ConcurrencyFailure", 
      Description = "Optimistisk samtidighet feilet, objektet har blitt endret." 
     }; 
    } 

    public override IdentityError PasswordMismatch() 
    { 
     return new IdentityError() 
     { 
      Code = "PasswordMismatch", 
      Description = "Feil passord." 
     }; 
    } 

    public override IdentityError InvalidToken() 
    { 
     return new IdentityError() 
     { 
      Code = "InvalidToken", 
      Description = "Feil token." 
     }; 
    } 

    public override IdentityError LoginAlreadyAssociated() 
    { 
     return new IdentityError() 
     { 
      Code = "LoginAlreadyAssociated", 
      Description = "En bruker med dette brukernavnet finnes allerede." 
     }; 
    } 

    public override IdentityError InvalidUserName(string userName) 
    { 
     IdentityError identityError = new IdentityError(); 
     identityError.Code = "InvalidUserName"; 
     string str = $"Brkernavnet '{userName}' er ikke gyldig. Det kan kun inneholde bokstaver og tall."; 
     identityError.Description = str; 
     return identityError; 
    } 

    public override IdentityError InvalidEmail(string email) 
    { 
     IdentityError identityError = new IdentityError(); 
     identityError.Code = "InvalidEmail"; 
     string str = $"E-post '{email}' er ugyldig."; 
     identityError.Description = str; 
     return identityError; 
    } 

    public override IdentityError DuplicateUserName(string userName) 
    { 
     IdentityError identityError = new IdentityError(); 
     identityError.Code = "DuplicateUserName"; 
     string str = $"Brukernavn '{userName}' er allerede tatt."; 
     identityError.Description = str; 
     return identityError; 
    } 

    public override IdentityError DuplicateEmail(string email) 
    { 
     IdentityError identityError = new IdentityError(); 
     identityError.Code = "DuplicateEmail"; 
     string str = $"E-post '{email}' er allerede tatt."; 
     identityError.Description = str; 
     return identityError; 
    } 

    public override IdentityError InvalidRoleName(string role) 
    { 
     IdentityError identityError = new IdentityError(); 
     identityError.Code = "InvalidRoleName"; 
     string str = $"Rollenavn '{role}' er ugyldig."; 
     identityError.Description = str; 
     return identityError; 
    } 

    public override IdentityError DuplicateRoleName(string role) 
    { 
     IdentityError identityError = new IdentityError(); 
     identityError.Code = "DuplicateRoleName"; 
     string str = $"Rollenavn '{role}' er allerede tatt."; 
     identityError.Description = str; 
     return identityError; 
    } 

    public virtual IdentityError UserAlreadyHasPassword() 
    { 
     return new IdentityError() 
     { 
      Code = "UserAlreadyHasPassword", 
      Description = "Bruker har allerede passord satt." 
     }; 
    } 

    public override IdentityError UserLockoutNotEnabled() 
    { 
     return new IdentityError() 
     { 
      Code = "UserLockoutNotEnabled", 
      Description = "Utestenging er ikke slått på for denne brukeren." 
     }; 
    } 

    public override IdentityError UserAlreadyInRole(string role) 
    { 
     IdentityError identityError = new IdentityError(); 
     identityError.Code = "UserAlreadyInRole"; 
     string str = $"Brukeren er allerede i rolle '{role}'."; 
     identityError.Description = str; 
     return identityError; 
    } 

    public override IdentityError UserNotInRole(string role) 
    { 
     IdentityError identityError = new IdentityError(); 
     identityError.Code = "UserNotInRole"; 
     string str = $"Bruker er ikke i rolle '{role}'."; 
     identityError.Description = str; 
     return identityError; 
    } 

    public override IdentityError PasswordTooShort(int length) 
    { 
     IdentityError identityError = new IdentityError(); 
     identityError.Code = "PasswordTooShort"; 
     string str = $"Passordet må være på minimum {length} tegn."; 
     identityError.Description = str; 
     return identityError; 
    } 

    public override IdentityError PasswordRequiresNonAlphanumeric() 
    { 
     return new IdentityError() 
     { 
      Code = "PasswordRequiresNonAlphanumeric", 
      Description = "Passordet må inneholde minst ett spesialtegn." 
     }; 
    } 

    public override IdentityError PasswordRequiresDigit() 
    { 
     return new IdentityError() 
     { 
      Code = "PasswordRequiresDigit", 
      Description = "Passordet må inneholde minst ett tall." 
     }; 
    } 

    public override IdentityError PasswordRequiresLower() 
    { 
     return new IdentityError() 
     { 
      Code = "PasswordRequiresLower", 
      Description = "Passordet må inneholde minst en liten bokstav (a-z)." 
     }; 
    } 

    public override IdentityError PasswordRequiresUpper() 
    { 
     return new IdentityError() 
     { 
      Code = "PasswordRequiresUpper", 
      Description = "Passordet må inneholde minst en stor bokstav (A-Z)." 
     }; 
    } 
} 
1

、私は私自身の使用のためにIStringLocalizerベースIdentityErrorDescriberを書かれている、誰もが複数の言語のサポートを必要と私は場合にはここでそれを共有したいと思った:)

基本基本的な言語やその他の言語用のリソースファイルを通常の方法で作成することです。 (https://docs.microsoft.com/en-us/aspnet/core/fundamentals/localization

(あなたは私のクラス名を保持する場合)に位置

/リソース/ yournamespace .LocalizedIdentityErrorDesciber.resx
/リソース/ yournamespace .LocalizedIdentityErrorDesciber.fr。resx
など

これらの中で、エラーコード(例:DefaultError、ConcurrencyError)をキーとして使用します。

その後

LocalizedIdentityErrorDesciber.cs

public class LocalizedIdentityErrorDescriber : IdentityErrorDescriber 
{ 
    /// <summary> 
    /// The <see cref="IStringLocalizer{LocalizedIdentityErrorDescriber}"/> 
    /// used to localize the strings 
    /// </summary> 
    private readonly IStringLocalizer<LocalizedIdentityErrorDescriber> localizer; 

    /// <summary> 
    /// Initializes a new instance of the <see cref="LocalizedIdentityErrorDescriber"/> class. 
    /// </summary> 
    /// <param name="localizer"> 
    /// The <see cref="IStringLocalizer{LocalizedIdentityErrorDescriber}"/> 
    /// that we will use to localize the strings 
    /// </param> 
    public LocalizedIdentityErrorDescriber(IStringLocalizer<LocalizedIdentityErrorDescriber> localizer) 
    { 
     this.localizer = localizer; 
    } 

    /// <summary> 
    /// Returns the default <see cref="IdentityError" />. 
    /// </summary> 
    /// <returns>The default <see cref="IdentityError" /></returns> 
    public override IdentityError DefaultError() 
    { 
     return this.GetErrorByCode("DefaultError"); 
    } 

    /// <summary> 
    /// Returns an <see cref="IdentityError" /> indicating a concurrency failure. 
    /// </summary> 
    /// <returns>An <see cref="IdentityError" /> indicating a concurrency failure.</returns> 
    public override IdentityError ConcurrencyFailure() 
    { 
     return this.GetErrorByCode("ConcurrencyFailure"); 
    } 

    /// <summary> 
    /// Returns an <see cref="IdentityError" /> indicating a password mismatch. 
    /// </summary> 
    /// <returns>An <see cref="IdentityError" /> indicating a password mismatch.</returns> 
    public override IdentityError PasswordMismatch() 
    { 
     return this.GetErrorByCode("PasswordMismatch"); 
    } 

    /// <summary> 
    /// Returns an <see cref="IdentityError" /> indicating an invalid token. 
    /// </summary> 
    /// <returns>An <see cref="IdentityError" /> indicating an invalid token.</returns> 
    public override IdentityError InvalidToken() 
    { 
     return this.GetErrorByCode("InvalidToken"); 
    } 

    /// <summary> 
    /// Returns an <see cref="IdentityError" /> indicating an external login is already associated with an account. 
    /// </summary> 
    /// <returns>An <see cref="IdentityError" /> indicating an external login is already associated with an account.</returns> 
    public override IdentityError LoginAlreadyAssociated() 
    { 
     return this.GetErrorByCode("LoginAlreadyAssociated"); 
    } 

    /// <summary> 
    /// Returns an <see cref="IdentityError" /> indicating the specified user <paramref name="userName" /> is invalid. 
    /// </summary> 
    /// <param name="userName">The user name that is invalid.</param> 
    /// <returns>An <see cref="IdentityError" /> indicating the specified user <paramref name="userName" /> is invalid.</returns> 
    public override IdentityError InvalidUserName(string userName) 
    { 
     return this.FormatErrorByCode("InvalidUserName", (object)userName); 
    } 

    /// <summary> 
    /// Returns an <see cref="IdentityError" /> indicating the specified <paramref name="email" /> is invalid. 
    /// </summary> 
    /// <param name="email">The email that is invalid.</param> 
    /// <returns>An <see cref="IdentityError" /> indicating the specified <paramref name="email" /> is invalid.</returns> 
    public override IdentityError InvalidEmail(string email) 
    { 
     return this.FormatErrorByCode("InvalidEmail", (object)email); 
    } 

    /// <summary> 
    /// Returns an <see cref="IdentityError" /> indicating the specified <paramref name="userName" /> already exists. 
    /// </summary> 
    /// <param name="userName">The user name that already exists.</param> 
    /// <returns>An <see cref="IdentityError" /> indicating the specified <paramref name="userName" /> already exists.</returns> 
    public override IdentityError DuplicateUserName(string userName) 
    { 
     return this.FormatErrorByCode("DuplicateUserName", (object)userName); 
    } 

    /// <summary> 
    /// Returns an <see cref="IdentityError" /> indicating the specified <paramref name="email" /> is already associated with an account. 
    /// </summary> 
    /// <param name="email">The email that is already associated with an account.</param> 
    /// <returns>An <see cref="IdentityError" /> indicating the specified <paramref name="email" /> is already associated with an account.</returns> 
    public override IdentityError DuplicateEmail(string email) 
    { 
     return this.FormatErrorByCode("DuplicateEmail", (object)email); 
    } 

    /// <summary> 
    /// Returns an <see cref="IdentityError" /> indicating the specified <paramref name="role" /> name is invalid. 
    /// </summary> 
    /// <param name="role">The invalid role.</param> 
    /// <returns>An <see cref="IdentityError" /> indicating the specific role <paramref name="role" /> name is invalid.</returns> 
    public override IdentityError InvalidRoleName(string role) 
    { 
     return this.FormatErrorByCode("InvalidRoleName", (object)role); 
    } 

    /// <summary> 
    /// Returns an <see cref="IdentityError" /> indicating the specified <paramref name="role" /> name already exists. 
    /// </summary> 
    /// <param name="role">The duplicate role.</param> 
    /// <returns>An <see cref="IdentityError" /> indicating the specific role <paramref name="role" /> name already exists.</returns> 
    public override IdentityError DuplicateRoleName(string role) 
    { 
     return this.FormatErrorByCode("DuplicateRoleName", (object)role); 
    } 

    /// <summary> 
    /// Returns an <see cref="IdentityError" /> indicating a user already has a password. 
    /// </summary> 
    /// <returns>An <see cref="IdentityError" /> indicating a user already has a password.</returns> 
    public override IdentityError UserAlreadyHasPassword() 
    { 
     return this.GetErrorByCode("UserAlreadyHasPassword"); 
    } 

    /// <summary> 
    /// Returns an <see cref="IdentityError" /> indicating user lockout is not enabled. 
    /// </summary> 
    /// <returns>An <see cref="IdentityError" /> indicating user lockout is not enabled..</returns> 
    public override IdentityError UserLockoutNotEnabled() 
    { 
     return this.GetErrorByCode("UserLockoutNotEnabled"); 
    } 

    /// <summary> 
    /// Returns an <see cref="IdentityError" /> indicating a user is already in the specified <paramref name="role" />. 
    /// </summary> 
    /// <param name="role">The duplicate role.</param> 
    /// <returns>An <see cref="IdentityError" /> indicating a user is already in the specified <paramref name="role" />.</returns> 
    public override IdentityError UserAlreadyInRole(string role) 
    { 
     return this.FormatErrorByCode("UserAlreadyInRole", (object)role); 
    } 

    /// <summary> 
    /// Returns an <see cref="IdentityError" /> indicating a user is not in the specified <paramref name="role" />. 
    /// </summary> 
    /// <param name="role">The duplicate role.</param> 
    /// <returns>An <see cref="IdentityError" /> indicating a user is not in the specified <paramref name="role" />.</returns> 
    public override IdentityError UserNotInRole(string role) 
    { 
     return this.FormatErrorByCode("UserNotInRole", (object)role); 
    } 

    /// <summary> 
    /// Returns an <see cref="IdentityError" /> indicating a password of the specified <paramref name="length" /> does not meet the minimum length requirements. 
    /// </summary> 
    /// <param name="length">The length that is not long enough.</param> 
    /// <returns>An <see cref="IdentityError" /> indicating a password of the specified <paramref name="length" /> does not meet the minimum length requirements.</returns> 
    public override IdentityError PasswordTooShort(int length) 
    { 
     return this.FormatErrorByCode("PasswordTooShort", (object)length); 
    } 

    /// <summary> 
    /// Returns an <see cref="IdentityError" /> indicating a password entered does not contain a non-alphanumeric character, which is required by the password policy. 
    /// </summary> 
    /// <returns>An <see cref="IdentityError" /> indicating a password entered does not contain a non-alphanumeric character.</returns> 
    public override IdentityError PasswordRequiresNonAlphanumeric() 
    { 
     return this.GetErrorByCode("PasswordRequiresNonAlphanumeric"); 
    } 

    /// <summary> 
    /// Returns an <see cref="IdentityError" /> indicating a password entered does not contain a numeric character, which is required by the password policy. 
    /// </summary> 
    /// <returns>An <see cref="IdentityError" /> indicating a password entered does not contain a numeric character.</returns> 
    public override IdentityError PasswordRequiresDigit() 
    { 
     return this.GetErrorByCode("PasswordRequiresDigit"); 
    } 

    /// <summary> 
    /// Returns an <see cref="IdentityError" /> indicating a password entered does not contain a lower case letter, which is required by the password policy. 
    /// </summary> 
    /// <returns>An <see cref="IdentityError" /> indicating a password entered does not contain a lower case letter.</returns> 
    public override IdentityError PasswordRequiresLower() 
    { 
     return this.GetErrorByCode("PasswordRequiresLower"); 
    } 

    /// <summary> 
    /// Returns an <see cref="IdentityError" /> indicating a password entered does not contain an upper case letter, which is required by the password policy. 
    /// </summary> 
    /// <returns>An <see cref="IdentityError" /> indicating a password entered does not contain an upper case letter.</returns> 
    public override IdentityError PasswordRequiresUpper() 
    { 
     return this.GetErrorByCode("PasswordRequiresUpper"); 
    } 

    /// <summary>Returns a localized <see cref="IdentityError"/> for the provided code.</summary> 
    /// <param name="code">The error's code.</param> 
    /// <returns>A localized <see cref="IdentityError"/>.</returns> 
    private IdentityError GetErrorByCode(string code) 
    { 
     return new IdentityError() 
     { 
      Code = code, 
      Description = this.localizer.GetString(code) 
     }; 
    } 

    /// <summary>Formats a localized <see cref="IdentityError"/> for the provided code.</summary> 
    /// <param name="code">The error's code.</param> 
    /// <param name="parameters">The parameters to format the string with.</param> 
    /// <returns>A localized <see cref="IdentityError"/>.</returns> 
    private IdentityError FormatErrorByCode(string code, params object[] parameters) 
    { 
     return new IdentityError 
     { 
      Code = code, 
      Description = string.Format(this.localizer.GetString(code, parameters)) 
     }; 
    } 
} 

下のクラスを追加して、すべてを初期化します。

Startup.cs

[...] 

    public void ConfigureServices(IServiceCollection services) 
    { 
     services.AddIdentity<ApplicationUser, IdentityRole>() 
    .AddErrorDescriber<TranslatedIdentityErrorDescriber>(); 

     services.AddLocalization(options => options.ResourcesPath = "Resources"); 

     // Your service configuration code 

     services.AddMvc() 
      .AddViewLocalization(LanguageViewLocationExpanderFormat.Suffix) 
      .AddDataAnnotationsLocalization(); 

     // Your service configuration code cont. 
    } 
    public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory) 
    { 
     // your configuration code 

     app.UseRequestLocalization(
      new RequestLocalizationOptions() 
       { 
        DefaultRequestCulture = new RequestCulture("fr"), 
        SupportedCultures = SupportedCultures, 
        SupportedUICultures = SupportedCultures 
       }); 

     app.UseStaticFiles(); 

     app.UseIdentity(); 

     // your configuration code 
    } 

    [...] 
2

とロシア語のIdentityErrorDescriberが必要です。

public class RussianIdentityErrorDescriber : IdentityErrorDescriber 
{ 

    public override IdentityError ConcurrencyFailure() 
    { 
     return new IdentityError 
     { 
      Code = "ConcurrencyFailure", 
      Description = "Сбой в параллельных запросах. Возможно объект был изменен." 
     }; 
    } 
    public override IdentityError DefaultError() 
    { 
    return new IdentityError 
     { 
      Code = "DefaultError", 
      Description = "Произошла неизвестная ошибка при авторизации." 
     }; 
    } 
    public override IdentityError DuplicateEmail(string email) 
    { 
     return new IdentityError 
     { 
      Code = "DuplicateEmail", 
      Description = $"E-mail '{email}' уже используется." 
     }; 
    } 
    public override IdentityError DuplicateRoleName(string role) 
    { 
     return new IdentityError 
     { 
      Code = "DuplicateRoleName", 
      Description = $"Роль с именем '{role}' уже существует." 
     }; 
    } 
    public override IdentityError DuplicateUserName(string userName) 
    { 
     return new IdentityError 
     { 
      Code = "DuplicateUserName", 
      Description = $"Пользователь '{userName}' уже зарегистрирован." 
     }; 
    } 
    public override IdentityError InvalidEmail(string email) 
    { 
     return new IdentityError 
     { 
      Code = "InvalidEmail", 
      Description = $"E-mail '{email}' содержит неверный формат." 
     }; 
    } 
    public override IdentityError InvalidRoleName(string role) 
    { 
     return new IdentityError 
     { 
      Code = "InvalidRoleName", 
      Description = $"Имя роли '{role}' задано не верно (содержит не допустимые символы либо длину)." 
     }; 
    } 
    public override IdentityError InvalidToken() 
    { 
     return new IdentityError 
     { 
      Code = "InvalidToken", 
      Description = "Неправильно указан код подтверждения (token)." 
     }; 
    } 
    public override IdentityError InvalidUserName(string userName) 
    { 
     return new IdentityError 
     { 
      Code = "InvalidUserName", 
      Description = $"Имя пользователя '{userName}' указано не верно (содержит не допустимые символы либо длину)." 
     }; 
    } 
    public override IdentityError LoginAlreadyAssociated() 
    { 
     return new IdentityError 
     { 
      Code = "LoginAlreadyAssociated", 
      Description = "Данный пользователь уже привязан к аккаунту." 
     }; 
    } 
    public override IdentityError PasswordMismatch() 
    { 
     return new IdentityError 
     { 
      Code = "PasswordMismatch", 
      Description = "Пароли не совпадают." 
     }; 
    } 
    public override IdentityError PasswordRequiresDigit() 
    { 
     return new IdentityError 
     { 
      Code = "PasswordRequiresDigit", 
      Description = "Пароль должен содержать минимум одну цифру." 
     }; 
    } 
    public override IdentityError PasswordRequiresLower() 
    { 
     return new IdentityError 
     { 
      Code = "PasswordRequiresLower", 
      Description = "Пароль должен содержать минимум одну строчную букву." 
     }; 
    } 
    public override IdentityError PasswordRequiresNonAlphanumeric() 
    { 
     return new IdentityError 
     { 
      Code = "PasswordRequiresNonAlphanumeric", 
      Description = "Пароль должен содержать минимум один специальный символ (не буквенно-цифровой)." 
     }; 
    } 
    public override IdentityError PasswordRequiresUniqueChars(int uniqueChars) 
    { 
     return new IdentityError 
     { 
      Code = "PasswordRequiresUniqueChars", 
      Description = $"Пароль должен содержать минимум '{uniqueChars}' не повторяющихся символов." 
     }; 
    } 
    public override IdentityError PasswordRequiresUpper() 
    { 
     return new IdentityError 
     { 
      Code = "PasswordRequiresUpper", 
      Description = "Пароль должен содержать минимум одну заглавную букву." 
     }; 
    } 
    public override IdentityError PasswordTooShort(int length) 
    { 
     return new IdentityError 
     { 
      Code = "PasswordTooShort", 
      Description = $"Пароль слишком короткий. Минимальное количество символов: '{length}'." 
     }; 
    } 
    public override IdentityError RecoveryCodeRedemptionFailed() 
    { 
     return new IdentityError 
     { 
      Code = "RecoveryCodeRedemptionFailed", 
      Description = "Не удалось использовать код восстановления." 
     }; 
    } 
    public override IdentityError UserAlreadyHasPassword() 
    { 
     return new IdentityError 
     { 
      Code = "UserAlreadyHasPassword", 
      Description = "Пароль для пользователя уже задан." 
     }; 
    } 
    public override IdentityError UserAlreadyInRole(string role) 
    { 
     return new IdentityError 
     { 
      Code = "UserAlreadyInRole", 
      Description = $"Роль '{role}' уже привязана к пользователю." 
     }; 
    } 
    public override IdentityError UserLockoutNotEnabled() 
    { 
     return new IdentityError 
     { 
      Code = "UserLockoutNotEnabled", 
      Description = "Блокировка входа пользователя не выключена." 
     }; 
    } 
    public override IdentityError UserNotInRole(string role) 
    { 
     return new IdentityError 
     { 
      Code = "UserNotInRole", 
      Description = $"Пользователь должен иметь роль: '{role}'" 
     }; 
    } 
} 

In `Startup.cs` set `RussianIdentityErrorDescriber ` 

public void ConfigureServices(IServiceCollection services) 
{ 
// ... 
    services.AddIdentity<ApplicationUser, IdentityRole>() 
      .AddErrorDescriber<RussianIdentityErrorDescriber>(); 
    // ... 
} 
+0

文法エラーを取り除くためにあなたの答えを編集してください。最初のエラーは 'InvalidEmail'メソッドにあります:"содержить " - >"содержит "。 'InvalidToken'メソッドの次のもの:"Неправильно " - >"Неправильно " –

+0

修正されました。ご意見ありがとうございます。私は明らかに出版物で急いだ! ( –

0

あなたはポリッシュ1を探している場合は、ここにある:

 

    public class PolishLocalizedIdentityErrorDescriber : IdentityErrorDescriber 
     { 
      public override IdentityError DefaultError() 
      { 
       return new IdentityError 
       { 
        Code = nameof(DefaultError), 
        Description = "Wystąpił nieznany błąd." 
       }; 
      } 

      public override IdentityError ConcurrencyFailure() 
      { 
       return new IdentityError 
       { 
        Code = nameof(ConcurrencyFailure), 
        Description = "Błąd współbieżności, obiekt został już zmodyfikowany." 
       }; 
      } 

      public override IdentityError PasswordMismatch() 
      { 
       return new IdentityError 
       { 
        Code = nameof(PasswordMismatch), 
        Description = "Niepoprawne hasło." 
       }; 
      } 

      public override IdentityError InvalidToken() 
      { 
       return new IdentityError 
       { 
        Code = nameof(InvalidToken), 
        Description = "Nieprawidłowy token." 
       }; 
      } 

      public override IdentityError RecoveryCodeRedemptionFailed() 
      { 
       return new IdentityError 
       { 
        Code = nameof(RecoveryCodeRedemptionFailed), 
        Description = "Pobranie kodu odzyskiwania nie powiodło się." 
       }; 
      } 

      public override IdentityError LoginAlreadyAssociated() 
      { 
       return new IdentityError 
       { 
        Code = nameof(LoginAlreadyAssociated), 
        Description = "Użytkownik o tym loginie już istnieje." 
       }; 
      } 

      public override IdentityError InvalidUserName(string userName) 
      { 
       return new IdentityError 
       { 
        Code = nameof(InvalidUserName), 
        Description = 
         $"Nazwa użytkownika '{userName}' jest nieprawidłowa, może zawierać tylko litery lub cyfry." 
       }; 
      } 

      public override IdentityError InvalidEmail(string email) 
      { 
       return new IdentityError 
       { 
        Code = nameof(InvalidEmail), 
        Description = $"Adres e-mail '{email}' jest nieprawidłowy." 
       }; 
      } 

      public override IdentityError DuplicateUserName(string userName) 
      { 
       return new IdentityError 
       { 
        Code = nameof(DuplicateUserName), 
        Description = $"Nazwa '{userName}' jest już zajęta." 
       }; 
      } 

      public override IdentityError DuplicateEmail(string email) 
      { 
       return new IdentityError 
       { 
        Code = nameof(DuplicateEmail), 
        Description = $"Adres e-mail '{email}' jest już zajęty." 
       }; 
      } 

      public override IdentityError InvalidRoleName(string role) 
      { 
       return new IdentityError 
       { 
        Code = nameof(InvalidRoleName), 
        Description = $"Nazwa roli '{role}' już niepoprawna." 
       }; 
      } 

      public override IdentityError DuplicateRoleName(string role) 
      { 
       return new IdentityError 
       { 
        Code = nameof(DuplicateRoleName), 
        Description = $"Rola '{role}' już istnieje." 
       }; 
      } 

      public override IdentityError UserAlreadyHasPassword() 
      { 
       return new IdentityError 
       { 
        Code = nameof(UserAlreadyHasPassword), 
        Description = "Użytkownik ma już ustawione hasło." 
       }; 
      } 

      public override IdentityError UserLockoutNotEnabled() 
      { 
       return new IdentityError 
       { 
        Code = nameof(UserLockoutNotEnabled), 
        Description = "Blokada konta nie jest włączona dla tego użytkownika." 
       }; 
      } 

      public override IdentityError UserAlreadyInRole(string role) 
      { 
       return new IdentityError 
       { 
        Code = nameof(UserAlreadyInRole), 
        Description = $"Użytkownik korzysta już z roli '{role}'." 
       }; 
      } 

      public override IdentityError UserNotInRole(string role) 
      { 
       return new IdentityError 
       { 
        Code = nameof(UserNotInRole), 
        Description = $"Użytkownika nie ma w roli '{role}'." 
       }; 
      } 

      public override IdentityError PasswordTooShort(int length) 
      { 
       return new IdentityError 
       { 
        Code = nameof(PasswordTooShort), 
        Description = $"Hasło musi składać się z co najmniej {length} znaków." 
       }; 
      } 

      public override IdentityError PasswordRequiresUniqueChars(int uniqueChars) 
      { 
       return new IdentityError 
       { 
        Code = nameof(PasswordRequiresUniqueChars), 
        Description = $"Hasło musi składać się z co najmniej {uniqueChars} unikalnych znaków." 
       }; 
      } 

      public override IdentityError PasswordRequiresNonAlphanumeric() 
      { 
       return new IdentityError 
       { 
        Code = nameof(PasswordRequiresNonAlphanumeric), 
        Description = "Hasło musi zawierać co najmniej jeden znak niebędący literą lub cyfrą." 
       }; 
      } 

      public override IdentityError PasswordRequiresDigit() 
      { 
       return new IdentityError 
       { 
        Code = nameof(PasswordRequiresDigit), 
        Description = "Hasło musi zawierać co najmniej jedną cyfrę (0-9)." 
       }; 
      } 

      public override IdentityError PasswordRequiresLower() 
      { 
       return new IdentityError 
       { 
        Code = nameof(PasswordRequiresLower), 
        Description = "Hasło musi zawierać co najmniej jedną małą literę (a-z)." 
       }; 
      } 

      public override IdentityError PasswordRequiresUpper() 
      { 
       return new IdentityError 
       { 
        Code = nameof(PasswordRequiresUpper), 
        Description = "Hasło musi zawierać co najmniej jedną wielką literę (A-Z)." 
       }; 
      } 
     }