Adaptez votre site Web à diverses cultures en utilisant la localisation
Dans un monde de plus en plus interconnecté, répondre à des publics diversifiés est devenu crucial pour les entreprises et les organisations à la recherche d'une portée mondiale. La localisation, le processus d'adaptation du logiciel ou du contenu pour répondre aux préférences linguistiques, culturelles et régionales de marchés cibles spécifiques, joue un rôle central dans la réalisation de cet objectif. Dans ce blog, nous explorerons l'importance de la localisation dans les applications Web, discuterons de ses avantages et fournirons des informations sur la façon de mettre en œuvre efficacement des stratégies de localisation. Veuillez vous joindre à moi dans ce voyage alors que nous découvrons le pouvoir transformateur de la localisation pour améliorer l'expérience utilisateur et élargir votre empreinte numérique au-delà des frontières.
Je vais utiliser une application simple écrite en ASP.NET Core. Le code de l'application peut être trouvé ici. Ce tutoriel suppose que .NET CLI est installé sur votre machine et les instructions pour l'installer peuvent être trouvées ici. Un certain niveau de connaissance des principes de programmation est recommandé.
Accédez au répertoire de votre choix où vous pouvez créer le projet, puis exécutez ce qui suit pour créer l'application sample_app.
mkdir sample_app
cd sample_app
dotnet new mvc -au None
Les commandes ci-dessus ont créé un répertoire racine pour le projet sample_app, puis ont créé un projet MVC sans autorisation dans ce répertoire. Nous ne choisissons aucune autorisation pour des besoins de simplicité car ce tutoriel ne nécessite pas la configuration de l'identité. De plus, par souci de simplicité, aucun service de base de données n'est requis pour ce projet. Dans le répertoire racine du projet, essayez d'exécuter ce qui suit:
dotnet run
Le serveur devrait démarrer et vous devriez voir la page ASP.NET Core par défaut rendue. Dans mon cas, le serveur écoute sur http://localhost:5010, donc quand je vais à cette URL, je peux voir la page suivante rendue. Maintenant que nous avons créé le projet, nous devrons mettre en place quelques autres choses.
Tout d'abord, créons un répertoire dans le répertoire racine et appelons-le Services. Dans ce répertoire, nous créons un fichier appelé SharedResources.cs. Ajoutez le code suivant au fichier:
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];
}
}
}
Essentiellement, le fichier ci-dessus crée un service linguistique (la méthode LanguageService), puis une autre méthode pour trouver les valeurs traduites dans une langue particulière à l'aide d'une clé, d'où la méthode LocalizedString.
Maintenant, nous sommes prêts à enregistrer le service créé ci-dessus dans le fichier Program.cs. Le fichier Program.cs doit se tenir dans votre répertoire racine. C'est également l'étape dans laquelle nous spécifions les langues et les cultures que notre site Web prendra en charge. Pour cette sample_app, nous allons utiliser seulement l'anglais (États-Unis) et l'espagnol (Espagne). En d'autres termes, c'est l'étape où nous localisons le contenu de notre site Web. C'est ce qu'on appelle la localisation. Par conséquent, nous ajoutons le code suivant au fichier 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
Maintenant que nous avons enregistré notre service linguistique, avant de commencer à créer les ressources pour traduire le contenu du site Web, nous devons trouver un moyen de basculer entre les langues et les cultures. Dans le répertoire ~/Views/Shared, créons un fichier de vue partielle et appelons-le _SelectLanguagePartial.cshtml qui nous aidera à faire exactement cela. Ajoutez le contenu suivant à ce fichier:
<div class="dropdown">
<button type="button" class="btn btn-default dropdown-toggle" data-bs-toggle="dropdown">Langue</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>
Le fichier ci-dessus nous permet d'avoir une bascule déroulante où l'utilisateur peut basculer entre les langues et les cultures en-US et es-ES. Mais nous n'avons pas encore terminé, il doit être visible, alors ajoutons ce fichier de vue partielle au fichier _Layout.cshtml, situé dans le même répertoire. N'hésitez pas à l'ajouter à n'importe quelle partie du fichier comme bon vous semble tant qu'il se trouve dans la balise "body".:
<div class="justify-content-end">
<div class="dropdown border-right px-3">
<partial name="_SelectLanguagePartial" />
</div>
</div>
La raison pour laquelle nous ajoutons le fichier de vue partielle dans le fichier _Layout.cshtml est qu'en fin de compte, vous voudriez que les visiteurs du site puissent traduire n'importe quelle page du site Web. Par conséquent, plutôt que de l'ajouter à chaque page, nous l'ajoutons simplement au fichier _Layout.cshtml et laissons chaque page en dériver pour qu'elle apparaisse partout.
À ce stade, nous avons créé le service LanguageService (~/Services/LanguageService.cs) et l'avons enregistré dans Program.cs. Nous avons également mis en place un bascule pour les langues de notre service LanguageService. Nous aurons besoin d'une chose de plus avant de pouvoir injecter le service dans le projet, essentiellement en le rendant prêt à l'emploi. Créons un répertoire de plus dans le répertoire racine du projet et appelons-le Ressources. Dans ce répertoire, nous allons créer 2 fichiers, connus sous le nom de fichiers de ressources, qui contiendront le contenu de notre page en anglais, puis en espagnol. Ce lien contient de la documentation sur la façon de créer et de travailler avec des fichiers de ressources (RESX) dans . NET. Nous appellerons les fichiers de ressources ShareResources.en-US.resx et ShareResource.es-ES.resx, respectivement. Nous aurons 4 clés dans chaque fichier en tant que tel:
| 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! |
Nous sommes maintenant prêts à injecter le service dans notre projet. Pour ce faire, apportons quelques modifications au fichier Home Controller (~/Controllers/HomeController.cs). Nous injectons le service, créons un ViewBag.IndexPageContent dans la méthode Index() et un ViewBag.PrivacyPageContent dans la méthode Privacy() qui contiendra nos textes traduits, puis ajoutons une méthode supplémentaire appelée ChangeLanguage() qui prendra la langue activée par l'utilisateur comme argument avant de rendre le contenu de la page Index. Le contenu du fichier devrait ressembler à ceci:
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
}
Nous avons injecté avec succès le service dans le contrôleur et l'avons utilisé dans les méthodes du contrôleur, nous sommes maintenant prêts à visualiser le contenu de la page. Pour ce faire, il nous suffit de remplacer le contenu des fichiers ~/Views/Home/Index.cshtml et ~/Views/Home/Privacy.cshtml par les fichiers suivants, respectivement:
@{
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>
Maintenant, si nous construisons le projet et exexécutez à nouveau la commande "dotnet run", nous devrions être en mesure de voir à la fois les pages d'accueil et de confidentialité mises à jour avec le contenu traduit approprié lorsqu'une langue est activée.
Nous avons montré avec succès qu'il est possible d'adapter notre site Web aux langues et cultures anglaises et espagnoles. Nous avons utilisé une application simple et très basique pour le montrer, mais cette méthode peut également être utilisée dans des projets à plus grande échelle. Nous avons utilisé ASP.NET Core pour le montrer, mais il est également possible d'utiliser un autre framework web ou un autre langage de programmation pour accomplir la même chose, car c'est fondamentalement la même idée. En fin de compte, j'espère que vous trouverez cet article utile et applicable dans vos projets à plus grande échelle et j'aimerais obtenir des commentaires ou des idées sur l'endroit où ce processus peut être amélioré ou non.
Commentaires du blog
Par brat-trebles-0z · 01/08/2023