Click here to Skip to main content
14,331,896 members

Developing Multicultural ASP.NET Core 3, 2, 1 Project Using LazZiya.ExpressLocalization

Rate this:
4.77 (22 votes)
Please Sign up or sign in to vote.
4.77 (22 votes)
3 Oct 2019CPOL
Create multi-cultural ASP.NET Core web application with simple steps

Introduction

Localization ASP.NET Core 3.x or 2.x or 1.x web application requires a lot of infrastructure setup and it consumes time and effort. In this article, we will use LazZiya.ExpressLocalization nuget package for localizing our web application with one step.

Background

Most of the web apps use URL based localization, so we can see the selected culture in the URL, e.g., http://www.example.com/en/Contact. Unfortunately, ASP.NET Core provides only below request culture providers:

  • QueryStringRequestCultureProvider
  • CookieRequestCultureProvider
  • AcceptLanguageHeaderRequestCultureProvider

In order to have route value localization, we need to build custom localization provider and define a global route template, so basically, we need to complete the below localization steps to have fully localized web application:

  • Build route value request culture provider

    For request localization according to {culture} route value

  • Define global route template for culture parameter

    Add {culture} parameter to url, e.g., www.example.com/en-US/

  • Setup DataAnnotations localization

    Localization of data annotations like Display names, Required, StringLength, ...etc.
    DataAnnotations are defined in System.ComponentModel.DataAnnotations namespace.
    In addition to localizing the default DataAnnotations, custom attributes also must be localized using the same logic.

    For more details, see DataAnnotations.

  • Setup ModelBinding error messages localization

    Validation of input types at server side after submit, e.g., ValueMustBeANumberAccessor, AttemptedValueIsInvalidAccessor, etc.

    For more details, see DefaultModelBindingMessageProvider.

  • Setup IdentityDescriber error messages

    Localization of all user and role related messages like "User already in role", "User name already exists", ...etc.

    For more details, see IdentityErroDescriber.

  • Setup OnRedirectTo... Events

    These events are fired automatically when the user is being automatically redirected to Login, Logout or AccessDenied pages. The auto redirection is not handling the culture value so it must be configured manually.

    For more details, see https://github.com/LazZiya/ExpressLocalization/issues/6

  • Setup view localization

    Localize text/html in razor pages.

    For more details, see ViewLocalization.

  • Setup client side validation scripts

    Localizing of client validation messages is essential, forms will be validated before submit. The client side validation scripts must be localized so the user will see localized messages like: The field is required, Passwords must match, etc.

    One more important thing is validating localized decimal numbers, some cultures use period and other cultures use comma in decimal numbers like (1,2) and (1.2), this case should be handled carefully in client side validation.

    What is more: Some cultures may use totally different numbering systems; e.g., Arabic cultures are using numbers like "٠١٢٣٤٥٦٧٨٩" and Latin cultures are using "0123456789". If the numbering system setup is not correct, a validation error will rise. (See this article to learn how to change numbering system for client side validation.)

    For more details, see Client side validation and localization related issue in GitHub.

  • Create localized resource files for each culture

    Views, DataAnnotations, ModelBinding and IdentityErrors all require localized resources. This step consumes a lot of time and effort!

All these steps require a lot of work and consume too much time. So, here comes the benefit of LazZiya.ExpressLocalization nuget package that eliminates the localization setup time and effort with simple lines of code.

Creating the Project

Let's start by creating a basic ASP.NET Core web application (I'm using VS2019):

  1. Create a new project by selecting ASP.NET Core Web Application:

    Image 1

  2. Click Next, give the project a friendly name and click Create:

    Image 2

  3. Select Web Application, set target framework to any of ASP.NET Core versions (3, 2 or 1) and make sure you change the authentication to Individual User Accounts.

    Image 3

  4. Click Create and wait till the solution creates the basic template, once it is done, you can do a test run by selecting the project name in the solution explorer, then pressing (Ctrl + Shift + B) to build the project, then (Ctrl + Shift + W) to run without debugging in the browser.

    Image 4

Installing LazZiya.ExpressLocalization

  1. In the solution explorer under the project name, right click on Dependencies and select "Manage Nuget Packages".

    Image 5

  2. Go to Browse tab and search for "LazZiya", select "LazZiya.ExpressLocalization" and click "Install", select the latest version (updated to v3.0.0 in 25 September 2019):

    Image 6

  3. It will ask to install two packages, click "Ok" and wait till installation is done:
    1. LazZiya.ExpressLocalization (required for all localization setup)
    2. LazZiya.TagHelpers (required for client side localization validation and language dropdown)
    3. Manually install LazZiya.TagHelpers.Localization package, required for easily localizing text/html in razor pages.
  4. Check for any updates to the relevant nuget packages before proceeding.

Creating Localized Resources

I've already prepared localized resources for the project, so you don't have to waste your time on creating localized resources.

Under the project root, create a new folder and name it "LocalizationResources":

Image 7

Under LocalizationResources folder, create new public class and name it "ViewLocalizationResource", this class will be used to group resource files for view localization:

namespace ExpressLocalizationSample.LocalizationResources
{
    public class ViewLocalizationResource
    {
    }
}

Under LocalizationResources folder, create new public class and name it "ExpressLocalizationResource", this class will be used to group resource files for identity, model binding and data annotations.

namespace ExpressLocalizationSample.LocalizationResources
{
    public class ExpressLocalizationResource
    {
    }
}

We will use these two classes to pass resource type to the express localization method.

Notice: In this sample, I will use two resource files for localization strings, but you are free to work with one, two or more localization resource files for all your locailzation strings. Switch between the different variants of AddExpressLocalization to see the available possibilities. Read more in GitHub.

Finally, download relevant cultures resources from this repository folder. Please notice that you need to download two files for each culture, e.g., (ExpressLocalizationResource.tr.resx and ViewLocalizationResource.tr.resx). Copy the downloaded files to "LocalizationResources" folder.

Image 8

Using the Code

Finally, we are ready for the localization setup. :)

Open startup.cs file and add the required namespace:

using LazZiya.ExpressLocalization;

then inside ConfigureServices method, define supported cultures and add localization setup as below:

var cultures = new[]
{
    new CultureInfo("tr"),
    new CultureInfo("ar"),
    new CultureInfo("hi"),
    new CultureInfo("en"),
};

services.AddControllersWithViews()
    .AddExpressLocalization<ExpressLocalizationResource, ViewLocalizationResource>(
    ops =>
    {
        ops.ResourcesPath = "LocalizationResources";
        ops.RequestLocalizationOptions = o =>
        {
            o.SupportedCultures = cultures;
            o.SupportedUICultures = cultures;
            o.DefaultRequestCulture = new RequestCulture("en");
        };
    })
    .SetCompatibilityVersion(CompatibilityVersion.Version_2_2);

Notice: Depending on the project pattern (MVC or Razor pages) and version, the services implementation may be changed to services.AddMvc() or services.AddControllersWithViews() or services.AddRazorPages().

Then under Configure method, configure the app to use request localization:

app.UseRequestLocalization();

Setup in Different .NET Core Versions and Project Types

Different versions of .NET Core (1, 2, 3) may have different services setup steps, ExpressLocalization works with all versions and pattern variants;

services.AddMvc().AddExpressLocalization(...);

services.AddRazorPages().AddExpressLocalization(...);

services.AddControllersWithViews().AddExpressLocalization(...);

If you have routes defined in startup, you need to add the culture parameter to the route table:

app.UseRequestLocalization();

app.UseEndpoints(endpoints =>
{
    endpoints.MapControllerRoute(
        name: "default",
        pattern: "{culture=en}/{controller=Home}/{action=Index}/{id?}");
});

Or if you are using route attributes on controllers, add the culture route parameter to the route attribute:

["{culture}/Home"]
public HomeController : Controller
{
    ...
}

Adding Language Navigation

Under Pages folder, open _ViewImports.cshtml file and add LazZiya.TagHelpers that will help in creating language navigation:

@using LazZiya.TagHelpers
@addTagHelper *, LazZiya.TagHelpers

Then open Pages/Shared/_Layout.cshtml file and add the language navigation tag helper under the _LoginPartial tag as below:

<partial name="_LoginPartial" />
<language-nav></language-nav>

Prior to LazZiya.TagHelprs v3.0.1 the LanguageNavTagHelper has one required parameter "view-context", but starting from v3.0.1 ViewContext is not required to passed manually anymore.

So for older versions of LazZiya.TagHelpers, the implementation of language taghelper would be as below:

<partial name="_LoginPartial" />
<language-nav view-context="ViewContext"></language-nav>

Read more about LanguageNav tag helper.

After adding the LanguageNav tag helper, we are ready for the first run:

Image 9

So good, so far we have our navigation with supported cultures, but we still need to localize view texts to see the localized versions.

Localizing Views

The localized texts for the default project are already provided in "ViewLocalizationResource.xx.resx" in the downloaded files. If you need to add more custom texts for views, add them to the "ViewLocalizationResource.xx.resx" files.

Option 1

Here, we will use LocalizeTagHelper that ships with LazZiya.TagHelpers.Localization, it is offering a simple and clear HTML tag for localizing views.

Open Pages/_ViewImports.cshtml file and add localization tag helper:

@using LazZiya.TagHelpers.Localization
@addTagHelper *, LazZiya.TagHelpers.Localization

Then open Pages/Index.cshtml and use localize tag helper to localize texts/html:

@page
@model IndexModel
@{
    ViewData["Title"] = "Home page";
    var locArgs = new[] { "https://docs.microsoft.com/aspnet/core" };
}

<div class="text-center">
    <h1 class="display-4" localize-content>Welcome</h1>
    <p localize-args="@locArgs">Learn about
    <a href="{0}">building Web apps with ASP.NET Core</a>.</p>
</div>

Use the same process to localize all texts in other views as well.

See more details in live demo page and GitHub.

Option 2

Open Pages/_ViewImports.cshtml file and inject SharedCultureLocalizer that already comes with ExpressLocalization:

@using LazZiya.ExpressLocalization
@inject SharedCultureLocalizer _loc

Then open Pages/Index.cshtml and use localizer function for texts:

@page
@model IndexModel
@{
    ViewData["Title"] = _loc.GetLocalizedString("Home page");
}

<div class="text-center">
    <h1 class="display-4">@_loc.GetLocalizedString("Welcome")</h1>
    <p>@_loc.GetLocalizedHtmlString("Learn about
         <a href='{0}'> building Web apps with ASP.NET Core</a>",
         new[]{"https://docs.microsoft.com/aspnet/core"}).</p>
</div>

Use the same process to localize all texts in other views as well.

Image 10

Localizing URLs

While the page is in any culture other than the default, if you click on Privacy, Login or Register links, you will notice that we are losing the selected culture, that is because we didn't add the culture route value to the link.

Open Pages/_ViewImports.cshtml and add reference to System.Globalization:

@using System.Globalization

Then open Pages/_LoginPartial.cshtml and add to the top of the page a culture parameter as below:

@{
    var culture = CultureInfo.CurrentCulture.Name;
}

Use this parameter to provide culture route value to all links as below:

<a class="nav-link text-dark"

   asp-area="Identity"

   asp-page="/Account/Register"

   asp-route-culture="@culture"

   localize-content>Register</a>

Do this to all views in the project.

Localizing Identity Views

Identity related like login, register and profile needs to be overridden in order to be modified.

Right click on the project name, select Add --> New Scaffolded Item...

Image 11

Select Identity and click Add:

Image 12

Select "Override all files" and select "ApplicationDbContext":

Image 13

When you click Add, a new Areas folder will be created including all identity related views:

Image 14

Identity area has three _ViewImports folders:

  • Areas/Identity/Pages/_ViewImports.cshtml
  • Areas/Identity/Pages/Account/_ViewImports.cshtml
  • Areas/Identity/Pages/Account/Manage/_ViewImports.cshtml

Add the below code to all of them as we did for Pages/_ViewImports.cshtml previously:

@using System.Globalization

@using LazZiya.TagHelpers
@addTagHelper *, LazZiya.TagHelpers

@using LazZiya.TagHelpers.Localization
@addTagHelper *, LazZiya.TagHelpers.Localization

Go over the views and use localization steps as we did before for localizing views and add culture route parameter as well. Below is the Register.cshtml page:

@page
@model RegisterModel
@{
    ViewData["Title"] = "Register";
    var culture = CultureInfo.CurrentCulture.Name;
}

<h1 localize-content>Register</h1>

<div class="row">
    <div class="col-md-4">
        <form asp-route-returnUrl="@Model.ReturnUrl"

        method="post" asp-route-culture="@culture">
            <h4 localize-content>Create a new account.</h4>
            <hr />
            <div asp-validation-summary="All" class="text-danger"></div>
            <div class="form-group">
                <label asp-for="Input.Email"></label>
                <input asp-for="Input.Email" class="form-control" />
                <span asp-validation-for="Input.Email" class="text-danger"></span>
            </div>
            <div class="form-group">
                <label asp-for="Input.Password"></label>
                <input asp-for="Input.Password" class="form-control" />
                <span asp-validation-for="Input.Password"

                class="text-danger"></span>
            </div>
            <div class="form-group">
                <label asp-for="Input.ConfirmPassword"></label>
                <input asp-for="Input.ConfirmPassword" class="form-control" />
                <span asp-validation-for="Input.ConfirmPassword" class="text-danger"></span>
            </div>
            <button type="submit" class="btn btn-primary" localize-content>Register</button>
        </form>
    </div>
</div>

@section Scripts {
    <partial name="_ValidationScriptsPartial" />
}

Configure Redirection Paths

IMPORTANT : LazZiya.ExpressLocalization v3.1.1 dosen't need the below setup, it is already built-in the nuget package. use below steps only if you are using older versions of LazZiya.ExpressLocalization <=3.0.0.

When using default identity for authorization, a cookie setup is required to handle the user redirection to the appropriate pages. By default, there is three main redirect paths we need to configure:

  • LoginPath: "/Identity/Account/Login/"
  • LogoutPath: "/Identity/Account/Logout/"
  • AccessDeniedPath: "/Identity/Account/AccessDenied/"

We need to add {culture} value to these paths so we keep the selected language without changing. But the problem is, the configuration must be done in the startup file, and there we don't have direct access to the current route values so we can't simple say: LoginPath = "{culture}/Identity/Account/Login"! Instead, we need to configure the RedirectContext as below:

// Required only with LazZiya.ExpressLocalization < v3.1.1
services.ConfigureApplicationCookie(ops =>
{
    ops.Events = new CookieAuthenticatinEvents
    {
        OnRedirectToLogin = ctx =>
        {
           // get culture value from the route
           // this is applicable for .NetCore 3.0
           var culture = ctx.Request.RouteValues["culture"];

           // for earlier versions of .NetCore use the below code:
           // add referenece to Microsoft.AspNetCore.Routing;
           // var culture = ctx.HttpContext.GetRoutevalue("culture");

           var requestPath = ctx.Request.Path;

           if(culture == null)
           {
              culture = "en"; // set to default culture
              requestPath = $"{culture}{requestPath}";
           }

          // add the culture value to the RedirectToLogin path
          ctx.Response.Redirect($"/{culture}/Identity/Account/Login/?
              ReturnUrl={requestPath}{ctx.Request.QueryString}");

          return Task.CompletedTask;
       },
       OnRedirectToLogout = ctx =>
       {
          var culture = ctx.Request.RouteValues["culture"];
          ctx.Response.Redirect($"/{culture}/Identity/Account/Logout/");
          return Task.CompletedTask;
       },
       OnRedirectToAccessDenied = ctx =>
       {
          var culture = ctx.Request.RouteValues["culture"];
          ctx.Response.Redirect($"/{culture}/Identity/Account/AccessDenied/");
          return Task.CompletedTask;
       }
    }
});

Localizing DataAnnotations

If you run the page and do some invalid inputs, you will notice that the validation messages are in English, so we will need to localize the data annotations messages, e.g., Required, StringLength, etc.

Image 15

Open Areas/Identity/Pages/Account/Register.cshtml.cs file and add reference to "LazZiya.ExpressLocalization.Messages" at the top of the page; it contains a predefined struct for all DataAnnotations error messages for easy use:

@using LazZiya.ExpressLocalization.Messages;

Then modify the Input model to be like below:

public class InputModel
{
    [Required(ErrorMessage = DataAnnotationsErrorMessages.RequiredAttribute_ValidationError)]
    [EmailAddress(ErrorMessage = DataAnnotationsErrorMessages.EmailAddressAttribute_Invalid)]
    [Display(Name = "Email")]
    public string Email { get; set; }

    [Required(ErrorMessage = DataAnnotationsErrorMessages.RequiredAttribute_ValidationError)]
    [StringLength(100, ErrorMessage =
           DataAnnotationsErrorMessages.StringLengthAttribute_ValidationErrorIncludingMinimum,
           MinimumLength = 6)]
    [DataType(DataType.Password)]
    [Display(Name = "Password")]
    public string Password { get; set; }

    [DataType(DataType.Password)]
    [Display(Name = "Confirm password")]
    [Compare("Password",
     ErrorMessage = DataAnnotationsErrorMessages.CompareAttribute_MustMatch)]
    public string ConfirmPassword { get; set; }
}

Compile and run the project, you will see localized data annotation error messages:

Image 16

Localizing Custom Backend Messages

Any custom messages coming from the backend can be localized using the SharedCultureLocalizer that comes in LazZiya.ExpressLocalization. To locaize any custom backend message injuct the SharedCultureLocalizer and call the localizing method as below (the process is same in MVC and RazorPages):

public IndexModel : PageModel
{
    private readonly SharedCultureLocalizer _loc;

    public IndexModel(SharedCultureLocalizer loc)
    {
        _loc = loc;
    }

    public void OnGet()
    {
        //...

        var msg = _loc.GetLocalizedString("This is a custom backend message.");

        // ...
    }
}

The localized texts for backend messages must be defined in the same resource file that contain the localized texts of the views.

SharedCultureLocalizer has other variants that allows you to specify the target culture and target resource file as well. Browse and test the function to see other possibilities.

Client Side Validation

The server side validation is working well, but we still need to add client side validation as well, so the input fields will be validated on client side before submitting the form.

One major issue with client side validation is validating localized inputs like numbers, dates, etc. For example, if you are using a decimal input, you will see validation error for localized numbers like 1.3 is valid in English culture, but is invalid for Turkish because it should be 1,3 (comma instead of period).

Here, we will use another useful tag helper that comes with LazZiya.TagHelpers.

Open Register.cshtml page and add the tag helper under the default validation scripts partial:

@section Scripts {

    <partial name="_ValidationScriptsPartial" />
    <localization-validation-scripts></localization-validation-scripts>
}

That's all, now the fields will be validated before submitting the form with localized validation messages:

Image 17

Sample Project

You can download a sample project with more than 19 cultures included from GitHub (not yet updated to use LocalizeTagHelper):

References

Read more details about the used nuget packages here:

History

  • 3rd June, 2019
    • Initial version
  • 17th June, 2019
    • Updated version using LazZiya.TagHelpers.Localization
  • 22nd June, 2019
    • Updated sample, hotfix for some issues in localizing ModelBinding and Identity messages (Update LazZiya.ExpressLocalization to v2.0.1)
  • 2nd October, 2019
    • DotNet Core 3.0 support
    • MVC and Razor Pages setup
    • Configuring Authentication cookie redirect paths
    • Added two download samples (.NET Core 3.0 and .NET Core 2.2)
    • Updated nuget packages to latest versions
  • 3rd October, 2019
    • LazZiya.TagHelpers ViewContext update notice

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

computer engineer, asp.net developer, 3Ds designer, regional training expert

http://ziyad.info
http://demo.ziyad.info
http://github.com/lazziya

Comments and Discussions

 
QuestionNot working Pin
ecu9713-Jul-19 1:19
memberecu9713-Jul-19 1:19 
AnswerRe: Not working Pin
Ziya Mollamahmut5-Jul-19 18:32
memberZiya Mollamahmut5-Jul-19 18:32 
AnswerRe: Not working Pin
Ziya Mollamahmut2-Oct-19 18:52
memberZiya Mollamahmut2-Oct-19 18:52 
SuggestionAddExpressLocalization Pin
kenllyspy218-Jun-19 9:58
professionalkenllyspy218-Jun-19 9:58 
GeneralRe: AddExpressLocalization Pin
Ziya Mollamahmut18-Jun-19 18:47
memberZiya Mollamahmut18-Jun-19 18:47 
PraiseNice work Pin
Lucas Vogel18-Jun-19 6:23
professionalLucas Vogel18-Jun-19 6:23 
GeneralRe: Nice work Pin
Ziya Mollamahmut18-Jun-19 18:45
memberZiya Mollamahmut18-Jun-19 18:45 
PraiseI didn't know I needed this till.. Pin
juan_van12-Jun-19 14:57
memberjuan_van12-Jun-19 14:57 
GeneralRe: I didn't know I needed this till.. Pin
Ziya Mollamahmut12-Jun-19 21:13
memberZiya Mollamahmut12-Jun-19 21:13 
GeneralMy vote of 5 Pin
Member 102409367-Jun-19 2:06
memberMember 102409367-Jun-19 2:06 
GeneralRe: My vote of 5 Pin
Ziya Mollamahmut7-Jun-19 5:23
memberZiya Mollamahmut7-Jun-19 5:23 
GeneralMy vote of 5 Pin
Stylianos Polychroniadis4-Jun-19 9:38
memberStylianos Polychroniadis4-Jun-19 9:38 
GeneralRe: My vote of 5 Pin
Ziya Mollamahmut4-Jun-19 23:10
memberZiya Mollamahmut4-Jun-19 23:10 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

Article
Posted 3 Jun 2019

Stats

15.1K views
320 downloads
18 bookmarked