How to implement localization and globalization in ASP .NET 8?

 Implementing localization and globalization in ASP.NET 8 involves configuring your application to support multiple languages and cultural formats. Localization refers to the process of translating your application into different languages, while globalization ensures that your application can handle different cultural norms, such as date formats and number formats.

Here’s a step-by-step guide on how to implement localization and globalization in ASP.NET 8:

1. Setup Localization Services

  1. Add Localization Services

    In Program.cs, configure localization services and specify supported cultures.

    csharp

    var builder = WebApplication.CreateBuilder(args);

// Add services to the container
builder.Services.AddControllersWithViews()
    .AddViewLocalization()
    .AddDataAnnotationsLocalization();

builder.Services.Configure<RequestLocalizationOptions>(options =>
{
    var supportedCultures = new[] { "en-US", "fr-FR", "es-ES" };
    options.DefaultRequestCulture = new RequestCulture("en-US");
    options.SupportedCultures = supportedCultures.Select(c => new CultureInfo(c)).ToList();
    options.SupportedUICultures = options.SupportedCultures;
});

var app = builder.Build();

  2. Configure Localization Middleware

    In Program.cs, add the localization middleware.

    csharp

    if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();

// Configure localization
app.UseRequestLocalization();

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

app.MapRazorPages();

app.Run();

2. Create Resource Files for Localization

  1. Add Resource Files

    • Create a folder named Resources in your project.
    • Add resource files named Messages.en.resx, Messages.fr.resx, etc., for each language you want to support.

    Example: Resources/Messages.en.resx might contain:

    xml

    <data name="WelcomeMessage" xml:space="preserve">
  <value>Welcome</value>
</data>

    And Resources/Messages.fr.resx:

    xml

    <data name="WelcomeMessage" xml:space="preserve">
  <value>Bienvenue</value>
</data>

  2. Access Resources in Code

    Inject IStringLocalizer into your controllers or services to access localized strings.

    csharp

    public class HomeController : Controller
{
    private readonly IStringLocalizer<HomeController> _localizer;

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

    public IActionResult Index()
    {
        ViewData["Message"] = _localizer["WelcomeMessage"];
        return View();
    }
}

  3. Access Resources in Views

    In Razor views, you can use the @localizer syntax.

    html

    @using Microsoft.Extensions.Localization
@inject IStringLocalizer<HomeController> Localizer

<h1>@Localizer["WelcomeMessage"]</h1>

3. Implement Culture-Specific Formatting

  1. Globalization in Formatting

    Configure CultureInfo to handle date and number formatting. Use CultureInfo directly for specific formatting needs.

    csharp

    var culture = new CultureInfo("fr-FR");
var formattedDate = DateTime.Now.ToString("D", culture); // Long date format in French

  2. Configure Globalization Settings

    You can configure globalization settings like date and number formats in your application’s settings or using CultureInfo.

    csharp

    public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllersWithViews()
            .AddViewLocalization()
            .AddDataAnnotationsLocalization();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        var culture = new CultureInfo("fr-FR");
        CultureInfo.DefaultThreadCurrentCulture = culture;
        CultureInfo.DefaultThreadCurrentUICulture = culture;

        app.UseRequestLocalization(new RequestLocalizationOptions
        {
            DefaultRequestCulture = new RequestCulture(culture),
            SupportedCultures = new[] { culture },
            SupportedUICultures = new[] { culture }
        });

        // Other middleware registrations
    }
}

4. Localize Data Annotations

  1. Add Localization to Data Annotations

    To localize data annotations, ensure you have resource files for the validation messages.

    xml

    <data name="RequiredAttribute_ValidationError" xml:space="preserve">
  <value>This field is required.</value>
</data>

  2. Configure Data Annotations Localization

    The configuration done in Program.cs with .AddDataAnnotationsLocalization() takes care of this.

5. Handling Culture in URLs

  1. Route Localization

    You can use route data to localize routes. Configure routes to support culture-specific paths.

    csharp

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

    Add middleware to set the culture based on route data.

    csharp

    public class CultureMiddleware
{
    private readonly RequestDelegate _next;

    public CultureMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        var culture = context.Request.RouteValues["culture"] as string;
        if (!string.IsNullOrEmpty(culture))
        {
            var cultureInfo = new CultureInfo(culture);
            CultureInfo.CurrentCulture = cultureInfo;
            CultureInfo.CurrentUICulture = cultureInfo;
        }
        await _next(context);
    }
}

  2. Add Middleware

    Register the custom middleware in Program.cs.

    csharp

    app.UseMiddleware<CultureMiddleware>();

Summary

  1. Setup Localization Services: Configure services and middleware in Program.cs to support localization.
  2. Create Resource Files: Add .resx files for each language and access them using IStringLocalizer.
  3. Implement Culture-Specific Formatting: Use CultureInfo for date and number formatting.
  4. Localize Data Annotations: Ensure validation messages are localized.
  5. Handling Culture in URLs: Use route data to manage culture-specific URLs and middleware to set culture based on routes.

By following these steps, you can build ASP.NET 8 applications that support multiple languages and cultural formats, providing a better experience for users around the world.

Post a Comment