Adapta tu sitio web a varias culturas usando la localización
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