Publicaciones de blog

Adapta tu sitio web a varias culturas usando la localización

Por brat-trebles-0z Publicado: 1/8/2023 Calificaciones: 5/5


En un mundo cada vez más interconectado, atender a un público diverso se ha vuelto crucial para las empresas y organizaciones que buscan un alcance global. La localización, el proceso de adaptación del software o el contenido para satisfacer las preferencias lingüísticas, culturales y regionales de mercados objetivo específicos, desempeña un papel fundamental en el logro de este objetivo. En esta publicación, exploraremos la importancia de la localización en las aplicaciones web, discutiremos sus beneficios y proporcionaremos información sobre cómo implementar eficazmente las estrategias de localización. Por favor, únase a mí en este viaje mientras descubrimos el poder transformador de la localización para mejorar la experiencia del usuario y expandir su huella digital a través de las fronteras.

Voy a usar una aplicación sencilla escrita en ASP.NET Core. Se puede encontrar el código de la aplicación aquí. Este tutorial asume que .NET CLI está instalado en su máquina y se pueden encontrar instrucciones para instalarlo aquí. Se recomienda un cierto nivel de conocimiento de los principios de programación.

Navegue hasta un directorio de su elección donde pueda crear el proyecto; y luego, ejecute lo siguiente para crear la aplicación sample_app.

                                mkdir sample_app
                                cd sample_app
                                dotnet new mvc -au None
                            

Los comandos anteriores crearon un directorio raíz para el proyecto sample_app y luego crearon un proyecto MVC sin autorización en ese directorio. No elegimos ninguna autorización por simplicidad, ya que este tutorial no requiere que se configure la identidad. Además, en aras de la simplicidad, no se requiere ningún servicio de base de datos para este proyecto. En el directorio raíz del proyecto, intente ejecutar lo siguiente:

                                dotnet run
                            

El servidor debería iniciarse y deberías ver la página predeterminada de ASP.NET Core renderizada. En mi caso, el servidor está escuchando en http://localhost:5010, así que cuando voy a esa URL, puedo ver la siguiente página renderizada. Ahora que hemos creado el proyecto, tendremos que configurar algunas cosas más.


Primero, creemos un directorio en el directorio raíz y llamémoslo Servicios. En este directorio, creamos un archivo llamado SharedResources.cs. Añade el siguiente código al archivo:

                                using System;
                                using Microsoft.Extensions.Localization;
                                using System.Reflection;

                                namespace sample_app.Services
                                {
                                    public class SharedResource
                                    {
                                    }

                                    public class LanguageService
                                    {
                                        private readonly IStringLocalizer _localizer;
                                        public LanguageService(IStringLocalizerFactory factory)
                                        {
                                            var type = typeof(SharedResource);
                                            var assemblyName = new AssemblyName(type.GetTypeInfo().Assembly.FullName);
                                            _localizer = factory.Create("ShareResource", assemblyName.Name);
                                        }
                                        public LocalizedString Getkey(string key)
                                        {
                                            return _localizer[key];
                                        }
                                    }
                                }
                            

Esencialmente, el archivo anterior crea un servicio de idioma (el método LanguageService) y luego otro método para encontrar los valores traducidos dentro de un idioma en particular utilizando una clave, de ahí el método LocalizedString.

Ahora, estamos listos para registrar el servicio creado anteriormente en el archivo Program.cs. El archivo Program.cs debe estar en su directorio raíz. Este es también el paso en el que especificamos qué idiomas y culturas será compatible nuestro sitio web. Para esta aplicación de muestra, vamos a usar solo inglés (EE. UU.) y español (España). En otras palabras, este es el paso en el que localizamos el contenido de nuestro sitio web. Esto se llama localización. Como resultado, añadimos el siguiente código al archivo Program.cs:

                                // Other service registration code

                                // Localization (en-US and es-ES)
                                #region Localization
                                builder.Services.AddSingleton<LanguageService>();
                                builder.Services.AddLocalization(options => options.ResourcesPath = "Resources");
                                builder.Services.AddMvc().AddViewLocalization().AddDataAnnotationsLocalization(options => {
                                    options.DataAnnotationLocalizerProvider = (type, factory) => {
                                        var assemblyName = new AssemblyName(typeof(SharedResource).GetTypeInfo().Assembly.FullName);
                                        return factory.Create("ShareResource", assemblyName.Name);
                                    };
                                });

                                builder.Services.Configure<RequestLocalizationOptions>(options =>
                                        {
                                            var supportedCultures = new List<CultureInfo>
                                            {
                                                new CultureInfo("en-US"),
                                                new CultureInfo("es-ES"),
                                            };
                                            options.DefaultRequestCulture = new RequestCulture(culture:"en-US", uiCulture: "en-US");
                                            options.SupportedCultures = supportedCultures;
                                            options.SupportedUICultures = supportedCultures;
                                            options.RequestCultureProviders.Insert(0, new QueryStringRequestCultureProvider());
                                        });
                                #endregion

                                // Other app settings code

                                // App Localization
                                app.UseRequestLocalization(app.Services.GetRequiredService<IOptions<RequestLocalizationOptions>>().Value);

                                // More app settings code
                            

Ahora que hemos registrado nuestro servicio de idiomas, antes de comenzar a crear los recursos para traducir el contenido del sitio web, necesitamos encontrar una manera de alternar entre idiomas y culturas. En el directorio ~/Views/Shared, creemos un archivo de vista parcial y llamémoslo _SelectLanguagePartial.cshtml que nos ayudará a hacer precisamente eso. Añade el siguiente contenido a ese archivo:

                                <div class="dropdown">
                                    <button type="button" class="btn btn-default dropdown-toggle" data-bs-toggle="dropdown">Idioma</button>
                                    <ul class="dropdown-menu">
                                        <li>
                                            <a asp-controller="Home" asp-action="ChangeLanguage" asp-route-culture="en-US" class="dropdown-item">
                                                <i class="flag-icon flag-icon-us"></i>English
                                            </a>
                                        </li>
                                        <li>
                                            <a asp-controller="Home" asp-action="ChangeLanguage" asp-route-culture="es-ES" class="dropdown-item">
                                                <i class="flag-icon flag-icon-sp"></i>Español
                                            </a>
                                        </li>
                                    </ul>
                                </div>
                            

El archivo anterior nos permite tener un menú desplegable donde el usuario puede alternar entre los idiomas y culturas en-US y es-ES. Pero aún no hemos terminado, tiene que ser visible, así que agreguemos ese archivo de vista parcial al archivo _Layout.cshtml, ubicado en el mismo directorio. Siéntase libre de agregarlo a cualquier parte del archivo como mejor le parezca, siempre y cuando esté dentro de la etiqueta "body":

                                <div class="justify-content-end">
                                    <div class="dropdown border-right px-3">
                                        <partial name="_SelectLanguagePartial" />
                                    </div>
                                </div>
                            

La razón por la que agregamos el archivo de vista parcial en el archivo _Layout.cshtml es porque, en última instancia, le gustaría que los visitantes del sitio pudieran traducir cualquier página del sitio web. Por lo tanto, en lugar de agregarlo a cada página, simplemente lo agregamos al archivo _Layout.cshtml y dejamos que cada página se derive de él para que aparezca en todas partes.

En este punto, hemos creado el servicio LanguageService (~/Services/LanguageService.cs) y lo hemos registrado en Program.cs. También configuramos un interruptor para los idiomas en nuestro servicio LanguageService. Necesitaremos una cosa más antes de poder inyectar el servicio en el proyecto, esencialmente preparándolo para su uso. Vamos a crear un directorio más en el directorio raíz del proyecto y llamarlo Recursos. En este directorio, crearemos 2 archivos, conocidos como archivos de recursos, que contendrán el contenido de nuestra página tanto en inglés como en español. Este enlace contiene documentación sobre cómo crear y trabajar con archivos de recursos (RESX) en . NET. Llamaremos a los archivos de recursos ShareResources.en-US.resx y ShareResource.es-ES.resx, de forma repectiva. Tendremos 4 claves en cada archivo como tal:

Key Value
index_page_title Welcome
index_page_content Hello, this is our sample app to demonstrate how to adapt web app to various cultures.
privacy_page_title Privacy policy
privacy_page_content Here is our privacy policy. Please read it thoroughly!
Key Value
index_page_title Bienvenida
index_page_content Hola, esta es nuestra aplicación de muestra para demostrar cómo adaptar la aplicación web a varias culturas.
privacy_page_title Política de privacidad
privacy_page_content Aquí está nuestra política de privacidad. ¡Por favor, léalo detenidamente!

Ahora estamos listos para inyectar el servicio en nuestro proyecto. Para hacer esto, hagamos algunos cambios en el archivo Home Controller (~/Controllers/HomeController.cs). Inyectamos el servicio, creamos un ViewBag.IndexPageContent en el método Index() y un ViewBag.PrivacyPageContent en el método Privacy() que contendrá nuestros textos traducidos, y luego agregamos un método adicional llamado ChangeLanguage() que tomará el idioma que está cambiando el usuario como argumento antes de renderizar el contenido de la página del índice. El contenido del archivo debería verse así:

                                using System.Diagnostics;
                                using Microsoft.AspNetCore.Localization;
                                using Microsoft.AspNetCore.Mvc;
                                using sample_app.Models;
                                using sample_app.Services;

                                namespace sample_app.Controllers;

                                public class HomeController : Controller
                                {
                                    private readonly ILogger<HomeController> _logger;
                                    private LanguageService _localization;

                                    public HomeController(ILogger<HomeController> logger, LanguageService localization)
                                    {
                                        _logger = logger;
                                        _localization = localization;
                                    }

                                    public IActionResult Index()
                                    {
                                        ViewBag.IndexPageContent = _localization.Getkey("index_page_content");
                                        return View();
                                    }

                                    public IActionResult Privacy()
                                    {
                                        ViewBag.PrivacyPageContent = _localization.Getkey("privacy_page_content");
                                        return View();
                                    }

                                    [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
                                    public IActionResult Error()
                                    {
                                        return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
                                    }

                                    #region Localization
                                    public IActionResult ChangeLanguage(string culture)
                                    {
                                        Response.Cookies.Append(CookieRequestCultureProvider.DefaultCookieName, CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(culture)), new CookieOptions()
                                        {
                                            Expires = DateTimeOffset.UtcNow.AddYears(1)
                                        });
                                        return Redirect(Request.Headers["Referer"].ToString());
                                    }
                                    #endregion
                                }
                            

Hemos inyectado con éxito el servicio en el controlador y lo hemos utilizado en los métodos del controlador, ahora estamos listos para visualizar el contenido de la página. Para ello, solo tenemos que reemplazar el contenido de los archivos ~/Views/Home/Index.cshtml y ~/Views/Home/Privacy.cshtml con los siguientes, respectivamente:

                                @{
                                    ViewData["Title"] = _localization.Getkey("index_page_title");
                                }

                                <div class="text-center">
                                    <h1 class="display-4">@ViewData["Title"]</h1>
                                    <p>@ViewBag.IndexPageContent</p>
                                </div>
                            

                                @{
                                    ViewData["Title"] = _localization.Getkey("privacy_page_title");
                                }

                                <h1 class="display-4">@ViewData["Title"]</h1>
                                <p>@ViewBag.PrivacyPageContent</p>
                            

Ahora, si creamos el proyecto y ejecutamos el comando "dotnet run" de nuevo, deberíamos poder ver las páginas de inicio y privacidad actualizadas con el contenido traducido apropiado cuando se cambia un idioma.

Hemos demostrado con éxito que es posible adaptar nuestro sitio web a los idiomas y culturas inglés y español. Hemos utilizado una aplicación simple y muy básica para demostrarlo, pero este método también se puede utilizar en proyectos a mayor escala. Usamos ASP.NET Core para mostrar esto, pero también es posible usar otro marco web o lenguaje de programación para lograr lo mismo, ya que es básicamente la misma idea. En última instancia, espero que esta publicación le resulte útil y aplicable en sus proyectos a mayor escala y me encantaría obtener algunos comentarios o ideas sobre dónde se puede mejorar o no este proceso.

Comentarios de publicaciones de blog

Por brat-trebles-0z · 1/8/2023