Posted by Parveen Shaikh

What is Docker?

Docker is an open-source platform for developing, shipping, and running applications which enables to separate applications from infrastructure, and software that can deliver quickly. Docker provides many benefits such as runtime environment isolation, consistency via code, and portability.

What are Containers?

Containers are the organizational units of Docker. When we build an image and start running it; we are running in a container. The container analogy is used because of the portability of the software we have running in our container. The isolation and security allow you to run many containers simultaneously on a given host. There is no need for an extra load of a hypervisor so containers are lightweight, & it runs directly within the host machine’s kernel. 

Difference between virtual machines and dockers:

Docker Engine

Docker Engine lets  you to develop, assemble, ship, and run application usage of the following components:

1. Docker Daemon

It is a persistent background process that listens for Docker API requests and processes them & manages Docker images, containers, networks, and storage volumes. 

2. Docker Engine REST API

An API utilized by programs to engage with the Docker daemon; it could be accessed with the aid of an HTTP client.

3. Docker CLI

A command-line interface purchaser for interacting with the Docker daemon. It substantially simplifies how you manage container times and is one of the key reasons why developers love the use of Docker.

Docker architecture

• Docker uses a client-server architecture.
• The Docker patron talks to the Docker daemon, which does the heavy lifting of building, running, and dispensing your Docker containers.
• The Docker patron and daemon can run on the same system, or you may join a Docker consumer to a remote Docker daemon.
• The Docker client and daemon talk about the use of a REST API, over UNIX sockets, or a community interface.

1. Docker daemon

A chronic background process that manages Docker images, containers, networks, and storage volumes. The Docker daemon constantly listens for Docker API requests and methods them.

2. Docker client

Docker users can engage with Docker via a client. When any docker commands run, the client sends them to docker daemon, which carries them out. Docker API is used by Docker commands. It is possible for Docker clients to communicate with more than one daemon.

3. Docker registries

A Docker registry stores Docker images. There are public and private registries. Docker has a public registry called Docker hub, where you could also store photos privately.

If you are using Docker Datacenter (DDC), it includes Docker Trusted Registry (DTR).

docker pull or docker run commands, images are pulled from the configured registry. 

docker push command, image is pushed to the configured registry.

Docker objects

While working with Dockers, we use the following Docker objects.

Images

Docker images are read-most effective templates with instructions to create a docker container. Docker images may be pulled from a Docker hub and used or you may add additional instructions to the base image and create a new and modified docker image. Using dockerfile users can create their own docker images.

Containers

Using Docker API or CLI users can create, start, stop, move, or delete a container. Containers are runnable instances of image.

After you run a docker image, it creates a docker container. All the applications and their surroundings run inside this container. Use Docker API or CLI to start, stop, delete a docker container.

Networking

Docker implements networking in an application-driven manner and provides various options even as maintaining enough abstraction for utility developers. There are basically two styles of networks available – the default Docker network and user-described networks. By default, you get 3 specific networks on the set up of Docker – none, bridge, and host.

Storage

Data can store within the writable layer of a container but it requires a storage driver. Being non-persistent, it perishes whenever the container is not running. So it is not easy to transfer this data. Docker supports the following four options for persistent storage:

• Data Volumes
• Data Volume Container
• Directory Mounts
• Storage Plugins

.NET AND DOCKER

Containers offer a lightweight way to isolate your software from the relaxation of the host system, sharing simply the kernel, and the usage of sources given on your software.

Build a .NET Core image

You can build and run a .NET Core-based container image using the following instructions:

docker build --pull -t dotnetapp
docker run --rm dotnetapp Dockers in .Net Core

You can use the docker images command to see a listing of your image, as you can see in the following example.

% docker images dotnetapp

Package an ASP.NET Core app in the container:

To package an ASP.NET Core app in a container, there are 3 steps.

1. Create ASP.NET Core project
2. Write a Dockerfile that will describe how to construct your image
3. Create a container in order to make your image alive or permit the execution of your image like one process.

Create your ASP.NET Core Project

Step 1: Run the following commands in the Command Prompt,

mkdir dockerapp
cd dockerapp
dotnet new webapi

After that, you will have a functional API. To test it, run this command.

dotnet build
dotnet run

Type below address to get the values from ValuesController –

localhost: 5000/api/values

Here we have our WebAPI that returns [“value1”, ”value2”] in JSON.

Step 2: Deployment Environment

Here, we do not need a compiler because we will have to build our application externally from our image, integrate all built files in the image, and just use a lightweight image containing the .NET Core runtime Microsoft/aspnetcore to execute our application.

Copy and paste below instructions in your Dockerfile:

#Development Environment Process 
FROM Microsoft/aspnetcore-build:latest AS build-env 
WORKDIR /app 

#copy csproj and restore distinct layers, make sure that we all dependencies 
COPY *.csproj ./ 
RUN dotnet restore 

#Copy everything else and build the project in the container 
COPY . ./ 
RUN dotnet publish --configuration Release --output dist 

#Deployment Environment Process 
#Build runtime image 
FROM microsoft/aspnetcore:latest 
WORKDIR /app 
COPY --from=build-env /app/dist ./ 
EXPOSE 80/tcp 
ENTRYPOINT [ "dotnet","dockerapp.dll" ] 

Step 3: In command prompt type:

docker build. –t rootandadmin/dockerapp –f Dockerfile

Step 4: Create a Container

Now, we have our image rootandadmin/dockerapp but as this image is not active we should make it alive. For this we need to create a container.

There is a big difference between Image and Container; a container is a process that contains an image and executes it.

To create a container from our image type below command:

docker create command –p 555:80 –name rootandadmin/dockerapp01 rootandadmin/dockerapp

docker start rootandadmin/dockerapp01

Access your API in the browser using the following address:

localhost: 555/api/values

Benefits of containerization

Containers solved an important problem: how to make sure that software runs correctly when it is moved from one computing environment to another.

Agile methodologies are based on frequent and incremental changes in the code versions, such that frequent testing and deployment are required.

DevOps engineers frequently move software from a test environment to a production environment and to ensure that the required resources for provisioning and getting the appropriate deployment model are in place, and also validating and monitoring the performance.

The initial solution for this was Virtualization. Virtualization allows multiple operating systems to be run completely independently on a single machine.

The virtualization Idea is extended using containers. In virtualization, the hypervisor creates and runs multiple instances of an operating system so that multiple operating systems can be run on a single physical machine sharing the hardware resources.

The container model eliminates hypervisors entirely. Instead of hypervisors, containers are essentially applications, and all their dependencies packaged into virtual containers. Each application shares a single instance of the operating system and runs on the “bare metal” of the server. 

Advantages of Container:

1. All the containers share the resources of the single operating system and there is no virtualized hardware. Since the operating system is shared by means of all containers, they’re much more light-weight than traditional virtual machines. It’s possible to host far more containers on a single host than fully-fledged virtual machines.
2. Containers share a single operating system kernel start-up in a few seconds, instead of the minutes required to start-up a virtual machine.
3.  Containers are also very easy to share.

Conclusion

Docker is a mature technology that helps you package your applications. It reduces the time necessary to bring applications to production and simplifies reasoning about them. Furthermore, Docker encourages a deployment style that’s scripted and automatic. As such, it promotes reproducible deployments.

What is a Dashboard?

A Dashboard is a user interface that visually tracks, analyzes and provides key performance indicators (KPI), metrics and key data points to monitor business or specific processes. 

What is a Travel Dashboard?

Travel Dashboard is a tool to summarize data trends related to air, car rental, hotel, cruise, and vacation packages. Using Travel Dashboard users can configure settings for different environments related to GDS, User management, Configuring TMCs, Travel Agency setup with policies, Vehicle configuration and can also set Location configuration.

Building a Travel Dashboard

There are many factors that need to be taken into account when deciding which elements to include in a dashboard. Some considerations are more relevant for certain processes, and hence it is quite difficult to give specific guidelines that will be suitable for every contingency on how to build a better Dashboard. However, before setting out to create any kind of dashboard there are certain questions you need to ask to understand the ‘story’ for the dashboard is going to tell, how that story can be told as clearly as possible, and who will be the target audience.

Include only the most important content

Key features of the Travel Dashboard

• User Management
  • Corporate
  • Agency
• Service Configuration
• Rate configuration
• Bookings
• Site Visitors
• Policy Management
• Partner Approval
• Reports

Implementation of Dashboard using Asp.Net MVC

Areas in ASP.NET MVC allows us to separate a Web Application into smaller modules and organize the code. For the dashboard,  every module can be created as a separate area and that gives the flexibility to maintain the module code separately.

Step 1: Right click on the project, click Add and click on Area

Step 2: Enter the Area name and click Add

Step 3: Area gets created and Add Controller to Areas > Dashboard

Step 4: Now that we have Controllers created, right-click on Index action and click Add View

Set the start page in DashboardAreaRegistration.cs

Set the start page in DashboardAreaRegistration.cs

public override void RegisterArea(AreaRegistrationContext context)
{
context.MapRoute(
"Dashboard_default",
"Dashboard/{controller}/{action}/{id}",
new { action = "Index", id = UrlParameter.Optional },
<font style="background-color: #ffff00">new string[] { "DashboardApplication.Areas.Dashboard.Controllers" }
</font> );

 Similarly add folders for different modules with MVC components Controllers, Views, and Models.

In total we have five Areas , all areas have AreaRegistration.cs that are AgencyUserAreaRegistraion.cs, CorporateUserAreaRegistration.cs, RateConfigurationAreaRegistration.cs, DashboardAreaRegistration.cs and ServiceConfigurationAreaRegistration.cs classes respectively and all are inheriting AreaRegistration class, and also a route defined for the Area. These routes should be registered inside the Application_Start() method of Global.asax file.

A dashboard controller needs to be created to handle all the dashboard activities. Each widget will be treated as an individual child action. This child action is a type of action in the controller, where it can only be called from its parent.

DashboardController.cs

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Web; 
using System.Web.Mvc; 

namespace AspNetMVCDashboard.Controllers 
{ 
public class DashboardController :Controller 
{ 
// 
// GET: /Dashboard/ 

public ActionResult Index() 
{ 
return View(); 
} 
#region Child-Only 

[ChildActionOnly] 
[OutputCache(Duration = 1, VaryByParam = "None")] 
public ActionResult UsersConfiguration() 
{ 
return View(); 
} 
[ChildActionOnly] 
[OutputCache(Duration = 1, VaryByParam = "None")] 
public ActionResult RecentBookings() 
{ 
return View(); 
} 
[ChildActionOnly] 
[OutputCache(Duration = 1, VaryByParam = "None")] 
public ActionResult ServiceConfiguration() 
{ 
return View(); 
} 
[ChildActionOnly] 
[OutputCache(Duration = 1, VaryByParam = "None")] 
public ActionResult SiteVisitors() 
{ 
return View(); 
} 
#endregion 
} 
}

 SiteVisitors.cshtml

<script type="text/javascript"> 
google.load("visualization", "1", { packages: ["corechart"] }); 
google.setOnLoadCallback(drawVisitorChart); 
function drawVisitorChart() { 
var data = new google.visualization.DataTable(); 
data.addColumn('string', 'Year'); 
data.addColumn('number', 'New Visitors'); 
data.addColumn('number', 'Return Visitors'); 
data.addRows([ 
['2017', 1000, 400], 
['2018', 1170, 460], 
['2019', 860, 580], 
['2020', 1030, 540] 
]); 

var options = { 
title: 'Site Visitors' 
}; 

var chart = new google.visualization.LineChart(document.getElementById('chartVisitors')); 
chart.draw(data, options); 
} 
</script> 
<div class="dashboardItem"> 
<div class="dashboardItemHeader">Site Visitors</div> 
<div class="dashboardItemBody"> 
<div id="chartVisitors" style=""></div> 
</div> 
</div>

 Index.cshtml

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 
<html xmlns="http://www.w3.org/1999/xhtml"> 
<head runat="server"> 
<title></title> 
<script src="<%= Url.Content("~/Scripts/jquery-1.5.1.min.js") %>" type="text/javascript"></script> 
<link href="<%= Url.Content("~/Content/site.css") %>" rel="stylesheet" type="text/css" /> 
<link href="<%= Url.Content("~/Content/dashboard.css") %>" rel="stylesheet" type="text/css" /> 
<script type="text/javascript" src="https://www.google.com/jsapi"></script> 
</head> 
<body> 
<div class="pageHeader"> 
<h1>Dashboard </h1> 
</div> 
<div class="pageBody"> 
<div class="dashboard"> 
<div class="dashboard3Col"> 
<div class="dashboardCol"> 
<% Html.RenderAction("User Configuration", "DashBoard"); %> 
<% Html.RenderAction("Recent Bookings", "DashBoard"); %> 
</div> 
<div class="dashboardCol"> 
<% Html.RenderAction("Rate Configuration", "DashBoard"); %> 
<% Html.RenderAction("Service Configuration", "DashBoard"); %> 
</div> 
<div class="dashboardCol"> 
<% Html.RenderAction("Site Visitors", "DashBoard"); %> 
</div> 
<div class="dashboardFooter"></div> 
</div> 
</div> 
</div> 
</body> 
</html>

 RateConfig.cshtml

@{ 
Layout = "~/Areas/RateConfiguration/RateConfig.cshtml"; 
} 
<!DOCTYPE html> 
<html> 
<head> 
<meta name="viewport" content="width=device-width" /> 
<title></title> 
</head> 
<body> 
<div> @Html.ActionLink("Dashboard", "Home")</div>
<div class="dashboardItem"> 
<div class="dashboardItemHeader">Rate Configuration</div> 
<div class="dashboardItemBody"> 
<table class="tbl"> 
<tbody> 
<tr> 
<td>Select Corporate</td> 
<td> 
<select id="SelectCorp"> 
<option>ABC Travels</option> 
<option>Mars Corps</option> 
<option>ALink Travels</option> 
</select> 
</td> 
<td>Rate Type</td> 
<td> 
<select id="SelectRateType"> 
<option>Hourly</option> 
<option>Flat</option> 
<option>Retail</option> 
</select> 
</td> 
</tr> 
</tbody> 
</table> 
<input id="Configure" type="submit" value="SAVE" /> 
</div> 
</div> 
</body> 
</html>

Output:

Conclusion:

In a single click, we can visualize and dissect complex data in a dashboard with the help of dynamic filtering applied across every module. Complete visibility of your travel spends with consolidated data from multiple sources (GDS and partner agencies).

Optimize future travel spend with predictive forecasting and travel trend analysis by easily identifying possible savings through purchasing and booking behaviors. Identify cost savings opportunities pre-ticketing to reduce spend.

What is Globalization and localization?

Globalization is the process of designing the application in such a way that it can be used by users from across the globe i.e. in multiple cultures. 

The CultureInfo class holds culture-specific information, such as the associated language, sub-language, country/region, calendar, and cultural conventions. The cultures have a hierarchy, such that the parent of a specific culture is a neutral culture and the parent of a neutral culture is the InvariantCulture.

Neutral culture is a culture that is associated with a language but not with a country or region. A specific culture is a culture that is associated with both a language and a country or region. We specify the invariant culture by name by using an empty string (” “) in the call to a CultureInfo instantiation method.

Localization is the process of customization of a product or service to meet the needs of a particular language, culture.

These two things go together.

Why is localization important?

Localization of product or service improves customer satisfaction, increases customer base, and helps to enter a new market.

The key point of making your application localizable is to separate the page content from your logic implementation.

When something needs to be displayed on a web page, never put them directly on the page file or in the backend logic. By giving the content a key, which can be linked to the real content for the proper language setting.

Localization in ASP.NET MVC:

ASP.NET MVC was built on top of the ASP.NET runtime so all features provided by ASP.NET can be used in MVC such as caching, session state, and localization. 

In traditional ASP.NET Webforms application resource files are used to store the content of the application with different cultures and using the ResourceManager class to retrieve them which can be generated by Visual Studio automatically.

To understand Localization let’s have an example:

Here is the example of having a web page supported by two languages:

• English
• Hindi

Steps to follow:

1. Go to Add

First put all content out of the pages and the controllers. ASP.NET provides a special folder named App_GlobalResources which contains the resource files for the content of all cultures. Just right-click the project in the solution explorer window and create the folder under the Add > Add ASP.NET Folders menu.

Implementation of Localizing App for different cultures

2. In App_GlobalResources add two resource files for 2 languages: English and Hindi

• English language would be the default language of this application to create a Global.resx file firstly, then Global.hi-IN.resx. The middle name ‘hi-IN’ is the culture name of this language.
• The Visual Studio will help us to generate the accessing class for them.

Important! Make sure to change the access modifier of each resource file you create to the public. The Properties section also checks that resource files Custom Tool property value is “PublicResXFileCodeGenerator” and the build is “Embedded Resource”. Otherwise resource files won’t be compiled and won’t be accessible.

3. Adding Model and Attribute to Properties:

Add a model with the name “UserDetails.cs” and then add a display attribute with the name similar to the resource “Name” column.

using System;
using System.Collections.Generic;  
using System.ComponentModel.DataAnnotations;  
using System.Linq;  
using System.Web;  
using MvcLocalization.LocalResource;  
  
namespace MvcLocalization.Models  
{  
    public class UserDetails  
    {  
  
        [Display(Name = "FirstName", ResourceType = typeof(Resource))]  
        [Required(ErrorMessageResourceType = typeof(Resource),  
                  ErrorMessageResourceName = "FirstNameRequired")]  
        [StringLength(50, ErrorMessageResourceType = typeof(Resource),  
                          ErrorMessageResourceName = "VldFirstNameLength")]  
        public string FirstName { get; set; }  
        [Display(Name = "LastName", ResourceType = typeof(Resource))]  
        [Required(ErrorMessageResourceType = typeof(Resource),  
                  ErrorMessageResourceName = "LastNameRequired")]  
        [StringLength(50, ErrorMessageResourceType = typeof(Resource),  
                          ErrorMessageResourceName = "VldLastNameLength")]  
        public string LastName { get; set; }  
        [Display(Name = "Salary", ResourceType = typeof(Resource))]
        [Required(ErrorMessageResourceType = typeof(Resource),
                  ErrorMessageResourceName = "SalaryFormat")]
        public double Salary { get; set; }
 
    }  
}

4. Adding custom class:

Add a Helper class to set the Cultures. 

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Web;  
using System.Web.SessionState;  
using System.Threading;  
using System.Globalization;  
using System.ComponentModel.DataAnnotations;  
using MvcLocalization.LocalResource;  
  
namespace MvcLocalization.Helper  
{  
    public class CultureHelper  
    {  
        protected HttpSessionState session;  
  
        //constructor   
        public CultureHelper(HttpSessionState httpSessionState)  
        {  
            session = httpSessionState;  
        }  
        //Enum  
        public enum Language  
        {  
            [Display(Name = "en-GB", ResourceType = typeof(Resource))]  
            English = 0,  
            [Display(Name = "hi-IN", ResourceType = typeof(Resource))]  
            Hindi = 1  
        }  
  
        // Properties  
        public Language cultureLang;  
        public Language CurrentCulture  
        {  
               
            get  
            {  
                return cultureLang;  
            }  
                 
            set  
            {  
                switch (value)  
                {  
                    case "English":  
                        cultureLang = Language.English;
                        Thread.CurrentThread.CurrentUICulture = new CultureInfo(cultureLang);  
                        break;  
                    case "Hindi":  
                        cultureLang = Language.Hindi;  
                        Thread.CurrentThread.CurrentUICulture = new CultureInfo(cultureLang);  
                        break;  
                    default:  
                        cultureLang = Language.English;  
                        break;  
                }  
            }  
                 
        }  
    }  
}

5. Adding Controller

BaseController

BaseController in MVC that is inherited by all other controllers. In BaseController, common code is written which can be used in all the pages.

E.g.: by setting the language in the current thread for a multilingual site.

using Localization.Helper;  

using System;  

using System.Collections.Generic;  

using System.Linq;  

using System.Web;  

using System.Web.Mvc;  

  

namespace Localization.Controllers  

{  

    public class BaseController : Controller  

    {  

        protected override void ExecuteCore()  

        {  

            int culture = 0;  

            if (this.Session == null || this.Session["CurrentCulture"] == null)  

            {  

  

                int.TryParse(System.Configuration.ConfigurationManager.AppSettings["Culture"], out culture);  

                this.Session["CurrentCulture"] = culture;  

            }  

            else  

            {  

                culture = (int)this.Session["CurrentCulture"];  

            }  

            // calling CultureHelper class properties for setting    

            CultureHelper.CurrentCulture = culture;  

  

            base.ExecuteCore();  

        }  

  

        protected override bool DisableAsyncSupport  

        {  

            get { return true; }  

        }    

    }  

}  

HomeController

Home Controller will inherit BaseController. To add a Controller just right-click on the Controller folder and select Add then inside that select Controller.

using Localization.Helper;  

using Localization.Models;  

using System;  

using System.Collections.Generic;  

using System.Linq;  

using System.Web;  

using System.Web.Mvc;  

  

namespace Localization.Controllers  

{  

    public class HomeController : Controller  

    {  

        public ActionResult Index()  

        {  

            return View(new UserDetails());  

        }  

  

        public ActionResult ChangeCurrentCulture(string id)  

        {  

            //    

            // Change the current culture for this user.    

            //    

            CultureHelper.CurrentCulture = id;  

            //    

            // Cache the new current culture into the user HTTP session.     

            //    

            Session["CurrentCulture"] = id;  

            //    

            // Redirect to the same page from where the request was made!     

            //    

            return Redirect(Request.UrlReferrer.ToString());  

        }    

    }  

}  

6. Add a link button in the View

LoginPartial.cshtml page to display it on all pages of the website/application.

@{  

    Layout = null;  

}  

  

<!DOCTYPE html>  

  

<html>  

<head>  

    <meta name="viewport" content="width=device-width" />  

    <title></title>  

</head>  

<body>  

    <div>  

    @using System.Globalization  

    @using Localization  

    @using System.Threading;  

    @if (Request.IsAuthenticated)  

    {  

        <p>  

            Hello, @Html.ActionLink(User.Identity.Name, "ChangePassword", "Account",  

        routeValues: null,  

        htmlAttributes: new { @class = "username", title = "Change password" })!  

  

            @Html.ActionLink("Log off", "LogOff", "Account")  

        </p>  

    }  

    else  

    {  

        <ul>  

            <li>  

                @Html.ActionLink("Register", "Register", "Account",  

        routeValues: null, htmlAttributes: new { id = "registerLink" })  

        </li>  

  

        <li>  

            @Html.ActionLink("Log in", "Login", "Account",  

        routeValues: null, htmlAttributes: new { id = "loginLink" })  

    </li>  

</ul>  

    }  

  

    <ul style="margin-top:10px;">  

        @{  

            CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;  

  

            <li><a href="/Home/ChangeCurrentCulture/English">English</a></li>  

  

            <li><a href="/Home/ChangeCurrentCulture/Hindi">Hindi</a></li>  

        }  

    </ul>   

    </div>  

</body>  

</html>  

Here links are added from where the user will be able to change his website Language. When the user clicks on this link it will call the HomeController ChangeCurrentCulture Action result and it will pass an id to it.

According to that CultureHelper will get input and it will set the Culture for the page.

7. Adding View for HomeController

For adding a View just right-click anywhere inside HomeController and select Add View.

After clicking Add View a new dialog will pop up with the name Add View. Inside that you need to select:

View engine: Razor.

Model Class: UserDetails.

Scaffold template: Create.

Use a layout or master page: Check this Property.

@model MvcLocalization.Models.Userdetails  

  

@{  

    ViewBag.Title = "Index";  

}  

  
<h2>User Details</h2>  

@using (Html.BeginForm()) {  

    @Html.ValidationSummary(true)  

  

    <fieldset>  

        <legend>Userdetails</legend>  

  

        <div class="editor-label">  

            @Html.LabelFor(model => model.FirstName)  

        </div>  

        <div class="editor-field">  

            @Html.EditorFor(model => model.FirstName)  

            @Html.ValidationMessageFor(model => model.FirstName)  

        </div>  

  

        <div class="editor-label">  

            @Html.LabelFor(model => model.LastName)  

        </div>  

        <div class="editor-field">  

            @Html.EditorFor(model => model.LastName)  

            @Html.ValidationMessageFor(model => model.LastName)  

        </div>  

        <div class="editor-label">

            @Html.LabelFor(model => model.Salary)

        </div>

        <div class="editor-field">

            @Html.EditorFor(model => model.Salary)

            @Html.ValidationMessageFor(model => model.Salary)

        </div>
<p>  

            <input type="submit" value="Create" onclick="ShowError" />  

        </p>  

    </fieldset>  

}  

@section Scripts {  

    @Scripts.Render("~/bundles/jqueryval")  

}  

Client-Side Validating Decimals in Non-English Cultures:

Download and install the following packages:

Globalize: https://github.com/globalizejs/globalize

Jquery-validation-globalize: https://github.com/johnnyreilly/jquery-validation-globalize

CLDR-JSON data: https://github.com/unicode-cldr/cldr-json#cldr-json

@inject Microsoft.AspNetCore.Hosting.IHostingEnvironment HostingEnvironment  

@{  

    string GetDefaultLocale()  

    {  

        const string localePattern = "lib\\cldr-data\\main\\{0}";  

        var currentCulture = System.Globalization.CultureInfo.CurrentCulture;  

        var cultureToUse = "en-GB"; //Default regionalisation to use  


        if (System.IO.Directory.Exists(System.IO.Path.Combine(HostingEnvironment.WebRootPath, string.Format(localePattern, currentCulture.Name))))  

            cultureToUse = currentCulture.Name;  

        else if (System.IO.Directory.Exists(System.IO.Path.Combine(HostingEnvironment.WebRootPath, string.Format(localePattern, currentCulture.TwoLetterISOLanguageName))))  

            cultureToUse = currentCulture.TwoLetterISOLanguageName;  


        return cultureToUse;  

    }  

}  


<script type="text/javascript">  

    var culture = "@GetDefaultLocale()";  

    $.when(  

        $.get("/lib/cldr-data/supplemental/likelySubtags.json"),  

        $.get("/lib/cldr-data/main/" + culture + "/numbers.json"),  

        $.get("/lib/cldr-data/supplemental/numberingSystems.json"),  

        $.get("/lib/cldr-data/main/" + culture + "/ca-gregorian.json"),  

        $.get("/lib/cldr-data/main/" + culture +"/timeZoneNames.json"),  

        $.get("/lib/cldr-data/supplemental/timeData.json"),  

        $.get("/lib/cldr-data/supplemental/weekData.json")  

    ).then(function () {  

        // Normalize $.get results, we only need the JSON, not the request statuses.  

        return [].slice.apply(arguments, [0]).map(function (result) {  

            return result[0];  

        });  

    }).then(Globalize.load).then(function () {  

        Globalize.locale(culture);  

    });  

</script>  

•  Modify “_ValidationScriptsPartial.cshtml” file to include newly installed libraries

 The above code is configured for validating client-side based on culture.

Output:

It’s taking the default culture, English, when it loads the first time.

Check it by clicking on Hindi :

Conclusion:

This blog explained how to implement the localization on an ASP.NET MVC web application. 

The resource files are utilized as the container of the localization information which is provided by the ASP.NET runtime. 

The localization information can be stored in any place. Here the resource files are used which use the ASP.NET localization support classes.