We will start this example from a blanc ASP.NET MVC Website. This will be easier for you to follow. Now that you have your new ASP.NET MVC Website, create a new class and name it SetCultureAttribute.cs in a new ActionFilter directory and paste this code inside of it.

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

namespace MvcApplication1.ActionFilter
{
    public class SetCultureAttribute : FilterAttribute, IActionFilter
    {
        public void OnActionExecuting(ActionExecutingContext
            filterContext)
        {
            string cultureCode = SetCurrentLanguage(filterContext);

            if (string.IsNullOrEmpty(cultureCode)) return;

            HttpContext.Current.Response.Cookies.Add(
                new HttpCookie("Culture", cultureCode)
                {
                    HttpOnly = true,
                    Expires = DateTime.Now.AddYears(100)
                }
            );

            filterContext.HttpContext.Session["Culture"] = cultureCode;

            CultureInfo culture = new CultureInfo(cultureCode);
            System.Threading.Thread.CurrentThread.CurrentCulture =
                culture;
            System.Threading.Thread.CurrentThread.CurrentUICulture =
                culture;
        }

        public void OnActionExecuted(ActionExecutedContext filterContext)
        {

        }

        private static string GetCookieCulture(ActionExecutingContext
            filterContext, ICollection Cultures)
        {
            /* Get the language in the cookie*/
            HttpCookie userCookie = filterContext.RequestContext
                                                .HttpContext
                                                .Request
                                                .Cookies["Culture"];

            if (userCookie != null)
            {
                if (!string.IsNullOrEmpty(userCookie.Value))
                {
                    if (Cultures.Contains(userCookie.Value))
                    {
                        return userCookie.Value;
                    }
                    return string.Empty;
                }
                return string.Empty;
            }
            return string.Empty;
        }

        private static string GetSessionCulture(ActionExecutingContext
            filterContext, ICollection Cultures)
        {
            if (filterContext.RequestContext.HttpContext
                                               .Session["Culture"]
                                                             != null)
            {
                string SessionCulture = filterContext.RequestContext
                                                .HttpContext
                                                .Session["Culture"]
                                                .ToString();

                if (!string.IsNullOrEmpty(SessionCulture))
                {
                    return Cultures.Contains(SessionCulture)
                                 ? SessionCulture
                                 : string.Empty;
                }
                return string.Empty;
            }
            return string.Empty;
        }

        private static string GetBrowserCulture(ActionExecutingContext
            filterContext, IEnumerable Cultures)
        {
            /* Gets Languages from Browser */
            IList BrowserLanguages = filterContext.RequestContext
                                                         .HttpContext
                                                         .Request
                                                         .UserLanguages;

            foreach (var thisBrowserLanguage in BrowserLanguages)
            {
                foreach (var thisCultureLanguage in Cultures)
                {
                    if (thisCultureLanguage != thisBrowserLanguage)
                        continue;

                    return thisCultureLanguage;
                }
            }
            return string.Empty;
        }

        private static string SetCurrentLanguage(ActionExecutingContext
             filterContext)
        {
            IList Cultures = new List
            {
                "en-CA",
                "fr-CA"
            };

            string CookieValue = GetCookieCulture(
                                            filterContext,
                                            Cultures);

            if (string.IsNullOrEmpty(CookieValue))
            {
                string SessionValue = GetSessionCulture(
                                                  filterContext,
                                                  Cultures);

                if (string.IsNullOrEmpty(SessionValue))
                {
                    string BrowserCulture = GetBrowserCulture(
                                                         filterContext,
                                                         Cultures);
                    return string.IsNullOrEmpty(BrowserCulture)
                             ? "en-CA"
                             : BrowserCulture;
                }
                return SessionValue;
            }
            return CookieValue;
        }
    }
}

Once this is done, we need to tell our controllers to use this attribute, to do this we could simply go on top of every controller and decorate it with [SetCulture] attribute. The down side with this is that we want the complete site multicultural, not just a few controllers or actions. To fix this problem we’ll make a BaseController which will inherit Controller and will be inherited from all our controllers.

To do this, create a new directory and name it Infrastructure and then add a new class called BaseController.cs in it. This class should contain the following code:

using System.Web.Mvc;
using MvcApplication1.ActionFilter;

namespace MvcApplication1.Infrastructure
{
    [SetCulture]
    public class BaseController : Controller
    {
         // Anything you put here will be accessible
         // in every controllers
    }
}

As I said before, we need to tell every controllers to use BaseController, so open every controllers and change the inheritance from Controller to BaseController. As of now, your website knows how to handle localization!!!

What we need now, is a way to switch between french and english… To do this I simply created a new ASP.NET MVC View User Controller (CultureUserControl.ascx) in Views/Shared with the following code.

<% if (Session["Culture"].ToString() == "en-CA") {%>
    [ Français ]
<% } else if (Session["Culture"].ToString() == "fr-CA") { %>
    [ English ]
<% } %>

Then I added it to the masterpage, right next to the Log On link.

    <% Html.RenderPartial("LogOnUserControl"); %>
    <% Html.RenderPartial("CultureUserControl"); %>

Last, but not least, add a new Global.resx and Global.fr.rex in the App_GlobalResources folder. You can start with the welcome message in About – Index and call it using Resources.Global.Welcome

You can find a working example of this tutorial here.

1. Open up your Website in Visual Studio
2. Open up Global.asax and add these lines

   void Session_Start(object sender, EventArgs e)
   {
       /*
        * Set the default language of the website
        * In my case it is en-CA, but you could put anything
        */
       Session["MyCulture"] = "en-CA";
   }

3. Create two links in your MasterPage.master

   <asp:linkbutton
       onclick="changeCulture_Click"
       commandargument="fr-CA"
       text="Français"
       runat="server"
       id="btnSetFR"/>
   <asp:linkbutton
       onclick="changeCulture_Click"
       commandargument="en-CA"
       text="English"
       runat="server"
       id="btnSetEN"/>

4. Add the Click Event to your MasterPage.master.cs

       protected void changeCulture_Click(object sender,
          EventArgs e)
       {
           LinkButton senderLink = sender as
               LinkButton;
   
           Session["userCulture"] =
              senderLink.CommandArgument;
   
           Server.Transfer(Request.Path);
       }

5. Create a new C# Class in App_Code, name it BasePage.cs and copy this code in it.

       public class MyPage : Page
       {
           protected override void InitializeCulture()
           {
               /*
                * Get the culture from the Sessions
                */
               string currentCulture =
                   Convert.ToString(Session["userCulture"]);
   
               /*
                * Check if there's in a
                * culture in the Sessions
                * Otherwise, set the Default Culture
                */
               if (!string.IsNullOrEmpty(currentCulture))
                   currentCulture = currentCulture;
               else
                   currentCulture = "en-CA"; 
   
               /*
                * Apply the Culture to our thread.
                */
               Thread.CurrentThread.CurrentCulture =
                   CultureInfo.CreateSpecificCulture(
                       currentCulture
                   );
   
               Thread.CurrentThread.CurrentUICulture =
                   new CultureInfo(currentCulture);
   
               base.InitializeCulture();
           }
       }

6. Change the inheritance of all your web forms from Page to BasePage
7. Now all you need to do is create your Resources in GlobalResources and LocalResources Folders

As I said, I learned this from an article posted on CodeProject by Michael Ulmann. If you would like to read the original article or download the source code, follow this link