ASP.NET Core 9: Localized Response from ASP.NET Core 9 API

-

When building enterprise applications, it is highly important to support different language and localized settings. Recently, while discussing with one of my student, a point raised on the multi-lingual response management from the API applications. The need was to send the response from the API based on the local language settings sent to it in the HTTP request. One of the benefits of the ASP.NET Core is an easy support for Localization using the Middleware. The UseRequestLocalization() Middleware is used to configure the Localization options so that the API can be configured to use the Localized resource before sending the response. The RequestLocalizationOptions class is used to set the configuration for default culture that can be changed while processing the request based on the Accept-Language header received from the HTTP Request.

How the Localization is handled in ASP.NET Core

Figure 1, explains the localized response processing



Figure 1: The Localized Response Processing

 As shown in Figure 1, the ASP.NET Core loads the Localization Service and Middleware to read the Localized Resource file based on the Accept-Language value from the HTTP request. Based on the language values read from the HTTP request the localized keys from the resource file will be read and theses keys withe its values will be used while generating response. The success of the application implementation is dependant on the the Resource files. For this article I have used the Google translator to translated the keys.

The implementation

Step 1: Open Visual Studio 2022, and create a new ASP.NET Core API Project targeted to .NET 9. Name this project as Core_APILocalization.  In this project add a new folder named Models. In this folder add a new class file named Person.cs. As shown in Listing1, add code for Person class in this file.

 public class Person
 {
        public int PersonId { get; set; }
        public string PersonName { get; set; } = null!;
        public string Address { get; set; } = null!;
        public string City { get; set; } = null!;
        public string Occupation { get; set; } = null!;
        public int Income { get; set; }
 }


Listing 1: The Person class

We need to define hard-coded values for the Person class. (You can use the database table for the data). In the project, add a new folder named Database. In this folder, add anew class file named PersonDB.cs. In this class file we will add hard coded values for Person List as shown in Listig 2.


  public class PersonDB : List<Person>
    {
        public PersonDB()
        {
            Add(new Person { PersonId = 101, PersonName = "Mahesh", Address = "S.B.Road", City = "Pune", Occupation = "Service", Income = 780000 });
            Add(new Person { PersonId = 102, PersonName = "Tejas", Address = "P.B.Road", City = "Pune", Occupation = "Service", Income = 670000 });
        }
    }

Listing 2: The Person data

Step 2: To create localized key/Values for the Person class properties we need to create resources files. In the project, add a new folder named Resources. In this folder add a new class named SharedResource.cs. In this file, we will add code for SharedResource class. This will be an empty class but this will be used by the Localization Service and Middleware to load an read localized strings. Listing 3 shows the code for the SharedResource class.


 public class SharedResource
 {
 }

Listing 3: The SharedResource class

Step 3: In the Resources folder, add a new Resource file and name it as SharedResource.resx for English culture. In this file add keys for the properties from the Person class as shown in Figure 2.



Figure 2: The English Culture Resource

In the same folder add a new Resources file and name it as SharedResources.de.resx for the German culture and in this file add keys for the properties from the Person class as shown in Figure 3



Figure 3: The German Culture Resources

 As per the requirements for the various cultures, additional resource files can be added in the project.     

Step 4: So far, we are ready with the required resources. Now, it's a time to start implementing the Localization using the ASP.NET Core Localization APIs. In the project, add a new folder named LocalizationService. In this folder add a new interface file named IAppLocalizerServce.cs. In tis file let's add an interface named IAppLocalizerService as shown in Listing 4.

  public interface IAppLocalizerService
  {
        string GetLocalizationString(string key);
  }


Listing 4:IAppLocalizerService interface

In the same folder, add a new class file named AppLocalizerService.cs. In this file we will add code for the AppLocalizerService class. This class will implement the IAppLocalizerService interface. This class will be constructor injected with the IStringLocalizerFactory interface. IStringLocalizerFactory is a part of ASP.NET Core, used for localizing strings in the application. It allows the creation of IStringLocalizer instances, that is responsible for accessing localized resources for a specific type or resource name. The factory pattern helps provide a centralized way to get localizers, ensuring consistency across the application. It is typically used in dependency injection to provide localized resources to various components. Listing 5 shown an implementation of the AppLocalizerService class.

 public class AppLocalizerService : IAppLocalizerService

    {
        private readonly IStringLocalizer stringLocalizer;
        private readonly ILogger<AppLocalizerService> logger;

        public AppLocalizerService(IStringLocalizerFactory factory, ILogger<AppLocalizerService> logger)
        {
            this.logger = logger;
            logger.LogInformation($"Accept-Language Header ");
            var type = typeof(SharedResource);
            var assembly = type.GetTypeInfo().Assembly;
            if (assembly != null && !string.IsNullOrEmpty(assembly.FullName))
            {
                var assemblyName = new AssemblyName(assembly.FullName);
                stringLocalizer = factory.Create("SharedResource", assemblyName?.Name ?? throw new ArgumentNullException(nameof(assemblyName.Name)));
                logger.LogInformation($"Using resource assembly: {assemblyName.Name}");
            }
            else
            {
                throw new ArgumentNullException(nameof(assembly));
            }
        }

        public string GetLocalizationString(string key)
        {
            var localizedString = stringLocalizer[key];

            foreach (var culture in stringLocalizer.GetAllStrings())
            {
                logger.LogInformation($"Culture: {culture}");
            }


            logger.LogInformation($"Localized string for key '{key}': {localizedString}");
            return localizedString;
        }
    }

Listing 4: The AppLocalizerService class

So now we are are ready with the process of reading the localized strings for out application using the IStringLocalizerFactory and IStringLocalizer types. The IStringLocalizer instance will baes used to create the localized string using the various culture Resources of the application. So in the nest step we will be implementing Dependency Injection for the Localization Service with the Middleware and furthermore we will define endpoints to accept HTTP request and generate localized response based on the accepted language received from the HTTP Header.

Step 5: Add the code as shown in Listing 5 to register the AppLocalizerService class, ASP.NET Core Localizer service and the Localizer Middleware.


.........
// Register the Localization service
builder.Services.AddLocalization(options =>
{
    options.ResourcesPath = "Resources";
});

builder.Services.Configure<RequestLocalizationOptions>(options =>
{
    var supportedCultures = new[]
    {
        "en-US","de"
    };
   options.SetDefaultCulture(supportedCultures[0])
          .AddSupportedCultures(supportedCultures)
          .AddSupportedUICultures(supportedCultures);
});

builder.Services.AddScoped<IAppLocalizerService, AppLocalizerService>();

builder.Services.Configure<Microsoft.AspNetCore.Http.Json.JsonOptions>(options =>
{
    options.SerializerOptions.PropertyNameCaseInsensitive = false;
    options.SerializerOptions.PropertyNamingPolicy = null;
    options.SerializerOptions.WriteIndented = true;
});

// Add services to the container.
builder.Services.AddOpenApi();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.MapOpenApi();
}

// Localization configuration
var cultures = new[] { "en", "de" };
var requestLocalizationOptions = new RequestLocalizationOptions()
    .SetDefaultCulture(cultures[0])
    .AddSupportedCultures(cultures)
    .AddSupportedUICultures(cultures);

requestLocalizationOptions.RequestCultureProviders.Insert(0, new AcceptLanguageHeaderRequestCultureProvider());
app.UseRequestLocalization(requestLocalizationOptions);
app.UseStaticFiles();
........

Listing 5: The Localization registration in the ASP.NET Core App

As shown in Listing 5, we have added the Localizer service by configuring the Resourced path to the Resources folder. We have also configured the RequestLocalizationOption to the default culture to en-Us. Finally, we have configured the UseRequestLocalization() middleware this will make sure that when the HTTP Header does not have Accept-Language then the default request with the English culture will be accepted otherwise based on the Accept-Language value the middleware will process request and from the resources the matching culture strings will be used in the response as shown in Figure 1.

Let's add API endpoints in Program.cs as shown in Listing 6.


app.MapGet("/persons", (HttpContext ctx, IAppLocalizerService serv) =>
{
    var persons = new PersonDB();
    var response = new List<Dictionary<string, string>>();

    var properties = typeof(Person).GetProperties(BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Instance);

    foreach (var person in persons)
    {
        var record = properties.ToDictionary(
            property => serv.GetLocalizationString(property.Name),
            property => serv.GetLocalizationString(property.GetValue(person)?.ToString() ?? string.Empty)
        );

        response.Add(record);
    }

    return Results.Ok(response); 
})
.WithName("GetPersons");

app.MapGet("/persons/{id}", (HttpContext ctx, IAppLocalizerService serv, int id, ILogger<Program> logger) =>
{
    var acceptLanguage = ctx.Request.Headers["Accept-Language"];
    logger.LogInformation($"Accept-Language Header {id}: {acceptLanguage}");
    var persons = new PersonDB();
    var response = persons.Where(p => p.PersonId == id).FirstOrDefault();
    if (response == null)
    {
        return Results.NotFound();
    }

    // Read Ptoperties of the Person class
    var properties = response.GetType().GetProperties(BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Instance);

    var record = properties.ToDictionary(property => serv.GetLocalizationString(property.Name), property => serv.GetLocalizationString(property.GetValue(response)?.ToString() ?? string.Empty));

    return Results.Ok(record);
})
.WithName("GetPersonsById");

Listing 6: API Endpoints

The endpoints uses reflection to read properties from the Person class and localize them based on the received culture from the HTTP request.

To test the application, run it and using the .http file make HTTP request with accept language as de-DE. The response will be received as shown in Figure 4.



Figure 4: The Localized Response

Conclusion: The Localization in the API offers the great deal of flexibility and reusability for the users/application those who wants to receive response in the specific culture forms.   

 Code for this article can be downloaded from this link.                

Popular posts from this blog

Uploading Excel File to ASP.NET Core 6 application to save data from Excel to SQL Server Database

-
Image
Recently, while conducting a session on ASP.NET Core 6, my client raised a query regarding uploading excel files to the ASP.NET Core MVC application and then further saving data from excel to the SQL Server Database table. I gave him the solution and then thought to write a post on it. As we all know, the Excel Workbook is one of the most heavily used files to save data. But to persist data it is recommended that it should be stored in an SQL Server database.  If the data is stored in an SQL Server database it can be queried easily.  Figure 1, explains an implementation of the application which we are going to discuss in the article. Figure 1: The ASP.NET Core That accepts Excel files and then further store data from Excel Files in SQL Server Database The   ExcelDataReader.DataSet Library To read excel files in ASP.NET Core applications, we need to use the ExcelDataReader.DataSet package. This is a lightweight and fast library for reading Excel files in .NET applications....
Read more

ASP.NET Core 6: Downloading Files from the Server

-
Image
In this article, we will implement the file downloading feature using ASP.NET Core 6 application. In real-world applications, we can have various files like reports, spreadsheets, images, PDF documents stored on the server. (Note that all cloud-hosted applications prefer to store these files on the storage services, e.g. Blob, S3, etc.). But what if the client prefers to store files on the separate file server mapped to the web application host server? Then, in that case, we may need to download these files from the file server. In this article, we will implement exactly the same thing.   Step 1: Open Visual Studio 2022 and create a new ASP.NET Core MVC Application targetted to .NET 6. Name this application as Core6_FileDownload. In this project add a new folder and name it as ServerFiles. In this file add some images. (You can add Excel, PDF, Word, Files). Step 2: Since we need to read the ServerFiles folder using the ASP.NET Core application, we need to add the IFi...
Read more

ASP.NET Core 6: Using Entity Framework Core with Oracle Database with Code-First Approach

-
Image
In this article, we will see how to use Oracle Database with Entity Framework Core with Code-First Approach. The reason behind writing a post on this is, recently while conducting training, one of my students raised the query regarding the EF Core with Oracle. Since Oracle is one of the most powerful databases, various enterprise applications are using it for the past several years and since the .NET Core is the most popular technology for building modern apps, the scenarios for accessing the Oracle database in .NET Core apps the use Entity Framework Core is common. Oracle Data Provider for .NET Entity Framework Core The Oracle Data Provider for .NET i.e. ODP.NET is used to access data from the Oracle database in the .NET Core apps using Entity Framework Core. This uses the Oracle.EntityFrameworkCore.dll, a managed library. This data provider allows using Code-First and Database-First approaches to perform Read/Write Operations with Oracle database.    Implementation To implem...
Read more