Asp.net core Net核心本地化

Net的核心功能

在我的项目中，我只需要一种语言。对于大多数文本和注释，我可以用我的语言指定内容，但是对于来自ASP.Net核心本身的文本，语言是英语

示例：

• 密码必须至少有一个大写（'A'-'Z'）
• 密码必须至少有一位数字（'0'-'9'）
• 用户名'x@x.com”他说
• “电子邮件地址”字段不是有效的电子邮件地址
• 值“”无效

我尝试过手动设置文化，但语言仍然是英语。

app.UseRequestLocalization（新的RequestLocalizationOptions
{
DefaultRequestCulture=新的RequestCulture（“nb编号”），
SupportedCultures=新列表{new CultureInfo（“nb NO”）}，
SupportedCultures=新列表{new CultureInfo（“nb NO”）}
});

---

如何更改ASP.Net Core的语言或覆盖其默认文本？

列出的错误消息在ASP.Net Core标识中定义，并由提供。到目前为止，我还没有找到已翻译的资源文件，我认为它们没有本地化。在我的系统（德语地区）上，虽然

CultureInfo

设置正确，但它们也不会被翻译

您可以配置自定义IdentityErrorDescriber以返回您自己的消息及其翻译。如中所述

在

Startup.cs

的

Configure

方法中，您可以连接从

IdentityErrorDescriber

继承的错误描述符类，如

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

---

挪威身份描述，以防有人需要

公共类NorwegianIdentityErrorDescriber:IdentityErrorDescriber
{
公共覆盖标识错误DefaultError（）
{
返回新的IdentityError（）
{
Code=“DefaultError”，
Description=“En ukjent feil har oppstått。”
};
}
公共重写标识错误并发失败（）
{
返回新的IdentityError（）
{
Code=“并发失败”，
Description=“Optimistisk samtidighet feilet，objektet har blitt endret。”
};
}
公共重写标识错误密码不匹配（）
{
返回新的IdentityError（）
{
Code=“PasswordMismatch”，
Description=“Feil passord。”
};
}
公共覆盖标识错误InvalidToken（）
{
返回新的IdentityError（）
{
Code=“InvalidToken”，
Description=“Feil令牌。”
};
}
公共覆盖标识符Ror LoginAlreadyAssociated（）
{
返回新的IdentityError（）
{
Code=“loginalreadyasociated”，
Description=“En bruker med dette brukenavnet finnes allerede。”
};
}
公共重写标识符错误InvalidUserName（字符串用户名）
{
IdentityError IdentityError=新IdentityError（）；
identityError.Code=“InvalidUserName”；
string str=$“Brkernavnet'{userName}er ike gyldig.Det kan kun inneholde bokstaver og toll.”；
identityError.Description=str；
返回标识符错误；
}
公共覆盖标识或无效邮件（字符串电子邮件）
{
IdentityError IdentityError=新IdentityError（）；
identityError.Code=“InvalidEmail”；
string str=$“E-post'{email}er-ugyldig。”；
identityError.Description=str；
返回标识符错误；
}
公共重写标识错误重复用户名（字符串用户名）
{
IdentityError IdentityError=新IdentityError（）；
identityError.Code=“DuplicateUserName”；
string str=$“Brukernavn'{userName}'er allerede tatt.”；
identityError.Description=str；
返回标识符错误；
}
公共覆盖标识或重复电子邮件（字符串电子邮件）
{
IdentityError IdentityError=新IdentityError（）；
identityError.Code=“DuplicateEmail”；
string str=$“E-post'{email}er allerede tatt.”；
identityError.Description=str；
返回标识符错误；
}
公共重写标识符错误InvalidRoleName（字符串角色）
{
IdentityError IdentityError=新IdentityError（）；
identityError.Code=“InvalidRoleName”；
string str=$“Rollenavn'{role}'er ugyldig。”；
identityError.Description=str；
返回标识符错误；
}
公共重写标识符或重复角色名（字符串角色）
{
IdentityError IdentityError=新IdentityError（）；
identityError.Code=“DuplicateRoleName”；
string str=$“Rollenavn'{role}er allerede tatt。”；
identityError.Description=str；
返回标识符错误；
}
公共虚拟标识错误useralreadyhassword（）
{
返回新的IdentityError（）
{
Code=“UserAlreadyHasPassword”，
Description=“Bruker har allerede passord satt。”
};
}
public override IdentityError UserLockoutNotEnabled（）
{
返回新的IdentityError（）
{
Code=“UserLockoutNotEnabled”，
Description=“为denne brukeren设计的Utestenging er ikke slått på。”
};
}
公共重写标识符错误UserAlreadyInRole（字符串角色）
{
IdentityError IdentityError=新IdentityError（）；
identityError.Code=“UserAlreadyInRole”；
string str=$“Brukeren er allerede i rolle'{role}.”；
identityError.Description=str；
返回标识符错误；
}
公共重写标识错误UserNotInRole（字符串角色）
{
IdentityError IdentityError=新IdentityError（）；
identityError.Code=“UserNotInRole”；
string str=$“Bruker ikke i rolle'{role}.”；
identityError.Description=str；
返回标识符错误；
}
公共覆盖标识或密码太短（整数长度）
{
IdentityError IdentityError=新IdentityError（）；
 services.AddIdentity<ApplicationUser, IdentityRole>()
        .AddErrorDescriber<TranslatedIdentityErrorDescriber>();

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

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)."
                };
            }
        }
public class LocalizedIdentityErrorDescriber : IdentityErrorDescriber
{
    /// <summary> 
    /// The <see cref="IStringLocalizer{LocalizedIdentityErrorDescriber}"/>
    /// used to localize the strings
    /// </summary>
    private readonly IStringLocalizer<IdentityResources> 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<IdentityResources> 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(nameof(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(nameof(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(nameof(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(nameof(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(nameof(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(nameof(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(nameof(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(nameof(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(nameof(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(nameof(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(nameof(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(nameof(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(nameof(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(nameof(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(nameof(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(nameof(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(nameof(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(nameof(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(nameof(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(nameof(PasswordRequiresUpper));
    }

    public override IdentityError PasswordRequiresUniqueChars(int uniqueChars)
    {
        return this.FormatErrorByCode(nameof(PasswordRequiresUniqueChars), (object)uniqueChars);
    }

    public override IdentityError RecoveryCodeRedemptionFailed()
    {
        return this.GetErrorByCode(nameof(RecoveryCodeRedemptionFailed));
    }

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

 public void ConfigureServices(IServiceCollection services)
 {
      services.AddLocalization(opts => { opts.ResourcesPath = "Resources"; });
      services.AddIdentity<IdentityUser, IdentityRole>()
           .AddEntityFrameworkStores<nameofyourdbcontext>()
           .AddDefaultTokenProviders()
           .AddErrorDescriber<LocalizedIdentityErrorDescriber>(); // this line is important
       services.Configure<RequestLocalizationOptions>(options =>
       {
            var supportedCultures = new[]
            {
                new CultureInfo("en"), // english
                new CultureInfo("tr"), // turkish
                new CultureInfo("ru")  // russian
            };

            options.DefaultRequestCulture = new RequestCulture(culture: "en", uiCulture: "en");
            options.SupportedCultures = supportedCultures;
            options.SupportedUICultures = supportedCultures;
            options.RequestCultureProviders.Insert(0, new CookieRequestCultureProvider()); // type of CultureProvider you want.
        });
 }
 public void Configure(IApplicationBuilder app, IHostingEnvironment env)
 {
        var localizationOptions = app.ApplicationServices.GetService<IOptions<RequestLocalizationOptions>>();
        // IT IS IMPORTANT TO CALL UseRequestLocalization BEFORE UseMvc
        app.UseRequestLocalization(localizationOptions.Value);
        app.UseMvc(routes =>
        {
            routes.MapRoute(
                name: "default",
                template: "{controller=Home}/{action=Index}/{id?}"
            );
        });
 }