Localización en una WebpApi

Hace un tiempito, con unos amigos, estuvimos hablando para llevar adelante un proyecto. Uno de los requerimientos era que soporte varios idiomas, pero no en la interfaz, sino en los servicios APIs. Por esta razón, decidí escribir este post sobre cómo implementamos en un middleware el soporte de Localicalización.

Primero tenemos que tener en cuenta lo siguiente, deberemos configurar un middleware, crear archivos de recursos acorde a los idiomas y utilizar la interfaz para poder manejar esta información. Algunas recomendaciones que te puedo dar relacionado con la experiencia de usuarios son: Primero, cuando mejor sea tu localización y globalización tendrás un alcance más amplio en usuarios que usen tu sitio, muchas veces un solo idioma no alcanza por más que sea inglés que es casi universal. Segundo, si tu sitio está en un idioma y en tu contenido en otro, la interacción se verá afectada, contenido y aplicación deberían estar acordes.

Llegó el momento de comenzar a crear nuestra aplicación. Lo primero será crear un proyecto. Crearé el proyecto en Visual Studio, en mi caso la versión 2022 y utilizaremos la última versión de .Net como se ve en la imagen.

Comenzaremos a preparar todo para aplicar la localización. Primero necesitaremos incluir un middleware como comentamos, segundo utilizaremos un archivo de recursos para guardar la información de la localización. Por último utilizaremos la interfaz IStringlocalizar para manipular el archivo de recursos.

Nuestros archivos de recursos se ubican en una carpeta llamada Resources. Por esta razón deberemos decirle a nuestro API la ruta. Para esto deberemos agregar en nuestro program.cs la siguiente línea:

builder.Services.AddLocalization(options => options.ResourcesPath = "Resources");

Ahora debemos crear la inyección de las configuraciones necesarias para que el middleware pueda resolver la cultura o la localización. Es posible crear varias culturas en nuestra localización. Veamos cómo agregarlo en nuestro program.cs.

var app = builder.Build();

var supportedCultures = new[] { "en-US", "ar" };
var localizationOptions =
    new RequestLocalizationOptions().SetDefaultCulture(supportedCultures[0])
    .AddSupportedCultures(supportedCultures)
    .AddSupportedUICultures(supportedCultures);


app.UseRequestLocalization(localizationOptions);

Lista nuestra configuración. Lo siguiente será crear nuestra una carpeta resources en nuestro proyecto que contendrá una carpeta controllers  y agregamos un nuevo archivo de recursos que se llamarada BlogPostsController.ar.resx.:

Ahora vamos con nuestro controlador. Crearemos un controlador vacío que se llamará BlogPostsController.cs:

Abramos nuestro archivo de recursos. Veremos que es una especie de grilla con 2 columnas del tipo Key-Value. Además es posible crear un comentario, pero no lo utilizaremos. Agregaremos 2 llaves, Article y Description.

Debemos generar una nueva recurso que llamaremos SharedResources.ar.resx y una clase SharedResource.cs. Que utilizaremos compartidos y veremos más adelante.

Nuestra clase se vera algo así:

namespace webapilocalization.resources
{
    public class SharedResource
    {
    }
}

Vamos a nuestro controller. Para tener disponible nuestros archivos de recursos deberemos inyectar por medio de constructor. Le enviaremos IStringLozalizer<BlogPostsController> y IStringLocalizer<SharedResource>. Nuestro controller se ver algo así:

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Localization;
using webapilocalization.resources;

namespace webapilocalization.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class BlogPostsController : ControllerBase
    {
        private readonly IStringLocalizer<BlogPostsController> stringLocalizer;
        private readonly IStringLocalizer<SharedResource> sharedResourceLocalizer;

        public BlogPostsController(IStringLocalizer<BlogPostsController> postsControllerLocalizer,
                               IStringLocalizer<SharedResource> sharedResourceLocalizer)
        {
            this.stringLocalizer = postsControllerLocalizer;
            this.sharedResourceLocalizer = sharedResourceLocalizer;
        }

        [HttpGet]
        [Route("PostsControllerResource")]
        public IActionResult GetUsingBlogPostsControllerResource()
        {
            var article = stringLocalizer["Article"];
            var description = stringLocalizer.GetString("Description").Value ?? "";

            return Ok(new { PostType = article.Value, Description = description });
        }

        [HttpGet]
        [Route("SharedResource")]
        public IActionResult GetUsingSharedResource()
        {
            var article = sharedResourceLocalizer["Article"];
            var description = sharedResourceLocalizer.GetString("Description").Value ?? "";

            return Ok(new { PostType = article.Value, Description = description });
        }
    }
}

¿Qué hace nuestro controlador? Como vimos antes, por medio del constructor, inyectamos las instancias IStringLocalizer que nos darán el acceso a los archivos de recursos. Por otro lado, tenemos 2 endpoints los cuales devolverán diferentes resultados para que podamos ver las diferencias. Por medio del método GetString accedemos a la información del archivo de recursos. Ejecutemos y veamos el resultado.

Hagamos unas pruebas con el postman:

Conclusión

En este post vimos cómo podemos implementar un middleware que nos permitirá utilizar localización por medio de archivos de recursos. Espero que el post le sea de utilidad. Déjame tus comentarios.