Session 20: In-Depth Explanation

Lecture Topics:

• Localization in MVC (Demo Only)
• Deploying ASP.NET MVC Application (Demo Only)

No Lab

Lecture: Detailed Explanation

1. Localization in MVC

Localization enables an ASP.NET MVC application to support multiple languages and cultures, adapting content based on the user’s locale.

• Definition:

  • Localization involves providing translated resources (e.g., text, date formats) for different cultures.
  • In ASP.NET Core, localization is achieved using middleware, resource files, and dependency injection.
  • Key components:
    • Resource Files (.resx): Store translated strings for each culture.
    • IStringLocalizer: Accesses localized strings.
    • Request Localization Middleware: Detects user’s culture from headers, cookies, or query strings.

• Implementation Steps (Demo Overview):

  1. Configure Localization Middleware:

     • In Program.cs, add localization services and middleware:

       var builder = WebApplication.CreateBuilder(args);
       builder.Services.AddLocalization(options => options.ResourcesPath = "Resources");
       builder.Services.AddControllersWithViews()
           .AddViewLocalization(LanguageViewLocationExpanderFormat.Suffix)
           .AddDataAnnotationsLocalization();
       var app = builder.Build();
       var supportedCultures = new[] { "en-US", "fr-FR", "es-ES" };
       var localizationOptions = new RequestLocalizationOptions()
           .SetDefaultCulture("en-US")
           .AddSupportedCultures(supportedCultures)
           .AddSupportedUICultures(supportedCultures);
       app.UseRequestLocalization(localizationOptions);
       app.UseRouting();
       app.MapControllerRoute(
           name: "default",
           pattern: "{controller=Home}/{action=Index}/{id?}");
       app.Run();
       
       

     • Explanation:

       • AddLocalization: Specifies the folder for resource files (Resources).
       • AddViewLocalization: Enables localized views (e.g., Index.fr-FR.cshtml).
       • AddDataAnnotationsLocalization: Localizes validation messages.
       • UseRequestLocalization: Applies culture based on request (e.g., Accept-Language header).

  2. Create Resource Files:

     • Create .resx files in the Resources folder:

       • Resources/Controllers.EmployeeController.en-US.resx:

         <data name="WelcomeMessage" xml:space="preserve">
           <value>Welcome to Employee Management</value>
         </data>
         
         

       • Resources/Controllers.EmployeeController.fr-FR.resx:

         <data name="WelcomeMessage" xml:space="preserve">
           <value>Bienvenue dans la gestion des employés</value>
         </data>
         
         

     • For models (e.g., Employee):

       • Resources/Models.Employee.en-US.resx:

         <data name="Name_Required" xml:space="preserve">
           <value>Name is required</value>
         </data>
         
         

       • Resources/Models.Employee.fr-FR.resx:

         <data name="Name_Required" xml:space="preserve">
           <value>Le nom est requis</value>
         </data>
         
         

  3. Use IStringLocalizer in Controller:

     • Example:

       // Controllers/EmployeeController.cs
       using Microsoft.AspNetCore.Mvc;
       using Microsoft.Extensions.Localization;
       using EmployeeApp.Models;
       
       namespace EmployeeApp.Controllers
       {
           public class EmployeeController : Controller
           {
               private readonly IStringLocalizer<EmployeeController> _localizer;
               public EmployeeController(IStringLocalizer<EmployeeController> localizer)
               {
                   _localizer = localizer;
               }
       
               public IActionResult Index()
               {
                   ViewBag.Message = _localizer["WelcomeMessage"];
                   return View(new List<Employee>());
               }
           }
       }
       
       

     • View (Views/Employee/Index.cshtml):

       <h1>@ViewBag.Message</h1>
       
       

  4. Localize Model Validation:

     • Example Employee model (from Lab 1, enhanced):

       // Models/Employee.cs
       using System.ComponentModel.DataAnnotations;
       
       namespace EmployeeApp.Models
       {
           public class Employee
           {
               public string EmployeeId { get; init; }
               [Required(ErrorMessageResourceName = "Name_Required", ErrorMessageResourceType = typeof(Employee))]
               public string Name { get; set; }
               public double Salary { get; set; }
           }
       }
       
       

     • Validation messages are pulled from resource files.

  5. Switching Cultures:

     • Example: Allow users to select language via a dropdown.

       <!-- Views/Shared/_Layout.cshtml -->
       <form asp-controller="Home" asp-action="SetLanguage" method="post">
           <select name="culture" onchange="this.form.submit()">
               <option value="en-US">English</option>
               <option value="fr-FR">French</option>
           </select>
       </form>
       
       

       // Controllers/HomeController.cs
       [HttpPost]
       public IActionResult SetLanguage(string culture, string returnUrl)
       {
           Response.Cookies.Append(
               CookieRequestCultureProvider.DefaultCookieName,
               CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(culture)),
               new CookieOptions { Expires = DateTimeOffset.UtcNow.AddYears(1) }
           );
           return LocalRedirect(returnUrl);
       }
       
       

• Key Points:

  • Resource files are named by convention (e.g., Controllers.EmployeeController.<culture>.resx).
  • Culture is set via Accept-Language header, cookies, or query strings.
  • Supports localized views, strings, and validation messages.
  • Demo likely shows switching between English and French for an Employee management UI.

• Why This Matters:

  • Localization enables globalized applications, critical for reaching diverse audiences.

2. Deploying ASP.NET MVC Application

Deploying an ASP.NET MVC Core application involves publishing it to a hosting environment (e.g., Azure, IIS, or Linux server).

• Definition:
  • Deployment packages the application into a portable format, including compiled code, dependencies, and configuration.
  • Common hosting options:
    • Azure App Service: Cloud-based hosting.
    • IIS: Windows server hosting.
    • Docker: Containerized deployment.
• Implementation Steps (Demo Overview):
  1. Publish the Application:
     • In Visual Studio 2022:

       • Right-click project → Publish → Select target (e.g., Folder, Azure).

       • For folder publish:

         dotnet publish -c Release -o ./publish
         
         

       • Outputs compiled app to publish folder.

  2. Configure Hosting Environment:

     • IIS Example:

       • Install IIS and .NET 6 Hosting Bundle.

       • Create a website in IIS Manager, pointing to the publish folder.

       • Configure web.config (auto-generated):

         <configuration>
             <system.webServer>
                 <handlers>
                     <add name="aspNetCore" path="*" verb="*" modules="AspNetCoreModuleV2" />
                 </handlers>
                 <aspNetCore processPath="dotnet" arguments=".\\\\EmployeeApp.dll" />
             </system.webServer>
         </configuration>
         
         

     • Azure App Service:

       • Deploy via Visual Studio or CLI:

         az webapp up --sku B1 --name EmployeeApp --resource-group MyGroup --location eastus
         
         

       • Configure appsettings.json for connection strings.

  3. Database Deployment:
     • For EF Core (e.g., EmployeeContext from Sessions 13-19):
       • Apply migrations to the production database:
       • Or use SQL scripts for ADO.NET.
  4. Environment Configuration:
  5. Testing Deployment:
• Example with Employee:
• Key Points: