Establecer la cultura en un ASP.Net Aplicación MVC

Sé que esta es una pregunta antigua, pero si realmente desea que esto funcione con su ModelBinder (con respecto a DefaultModelBinder.ResourceClassKey = "MyResource"; así como a los recursos indicados en las anotaciones de datos de las clases viewmodel), el controlador o incluso un ActionFilter es demasiado tarde para establecer la cultura.

La cultura podría establecerse en Application_AcquireRequestState, por ejemplo:

protected void Application_AcquireRequestState(object sender, EventArgs e)
    {
        // For example a cookie, but better extract it from the url
        string culture = HttpContext.Current.Request.Cookies["culture"].Value;

        Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo(culture);
        Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo(culture);
    }

EDITAR

En realidad hay una mejor manera de usar un enrutador personalizado que establece la cultura según la url, perfectamente descrita por Alex Adamyan en su blog .

Todo lo que hay que hacer es anular la GetHttpHandler método y establecer la cultura allí.

public class MultiCultureMvcRouteHandler : MvcRouteHandler
{
    protected override IHttpHandler GetHttpHandler(RequestContext requestContext)
    {
        // get culture from route data
        var culture = requestContext.RouteData.Values["culture"].ToString();
        var ci = new CultureInfo(culture);
        Thread.CurrentThread.CurrentUICulture = ci;
        Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(ci.Name);
        return base.GetHttpHandler(requestContext);
    }
}

Lo haría en el evento Initialize del controlador de esta manera...

    protected override void Initialize(System.Web.Routing.RequestContext requestContext)
    {
        base.Initialize(requestContext);

        const string culture = "en-US";
        CultureInfo ci = CultureInfo.GetCultureInfo(culture);

        Thread.CurrentThread.CurrentCulture = ci;
        Thread.CurrentThread.CurrentUICulture = ci;
    }

Al ser una configuración que se almacena por usuario, la sesión es un lugar apropiado para almacenar la información.

Cambiaría su controlador para tomar la cadena de cultura como parámetro, en lugar de tener un método de acción diferente para cada cultura potencial. Agregar un enlace a la página es fácil, y no debería necesitar escribir el mismo código repetidamente cada vez que se requiera una nueva cultura.

public class CultureController : Controller    
{
        public ActionResult SetCulture(string culture)
        {
            HttpContext.Session["culture"] = culture
            return RedirectToAction("Index", "Home");
        }        
}

<li><%= Html.ActionLink("French", "SetCulture", new {controller = "Culture", culture = "fr-FR"})%></li>
<li><%= Html.ActionLink("Spanish", "SetCulture", new {controller = "Culture", culture = "es-ES"})%></li>

Cuál es el mejor lugar es tu pregunta. El mejor lugar es dentro de la Controlador.Inicializar método. MSDN escribe que se llama después del constructor y antes del método action. Al contrario de sobreescribir OnActionExecuting, colocar su código en el método Initialize le permite beneficiarse de tener todas las anotaciones y atributos de datos personalizados en sus clases y en sus propiedades para ser localizados.

Por ejemplo, mi lógica de localización proviene de una clase que es inyectado a mi controlador personalizado. Tengo acceso a este objeto ya que Inicialize se llama después del constructor. Puedo hacer la asignación de cultura del Hilo y no tener todos los mensajes de error mostrados correctamente.

 public BaseController(IRunningContext runningContext){/*...*/}

 protected override void Initialize(RequestContext requestContext)
 {
     base.Initialize(requestContext);
     var culture = runningContext.GetCulture();
     Thread.CurrentThread.CurrentUICulture = culture;
     Thread.CurrentThread.CurrentCulture = culture;
 }

Incluso si su lógica no está dentro de una clase como el ejemplo que proporcioné, tiene acceso a la RequestContext que le permiten tener la URL y HttpContext y el RouteData que puede hacer básicamente cualquier análisis posible.

Si se usan subdominios, por ejemplo como "pt.mydomain.com" para establecer portugués, por ejemplo, el uso de Application_AcquireRequestState no funcionará, porque no se llama en las solicitudes de caché posteriores.

Para resolver esto, sugiero una implementación como esta:

1. Agregue el parámetro VaryByCustom al OutputCache de la siguiente manera:

   [OutputCache(Duration = 10000, VaryByCustom = "lang")]
   public ActionResult Contact()
   {
       return View("Contact");
   }
   

2. En global.asax.cs, obtenga la cultura del host usando una llamada a la función:

   protected void Application_AcquireRequestState(object sender, EventArgs e)
   {
       System.Threading.Thread.CurrentThread.CurrentUICulture = GetCultureFromHost();
   }
   

3. Añadir el Función GetCultureFromHost a global.asax.cs:

   private CultureInfo GetCultureFromHost()
   {
       CultureInfo ci = new CultureInfo("en-US"); // en-US
       string host = Request.Url.Host.ToLower();
       if (host.Equals("mydomain.com"))
       {
           ci = new CultureInfo("en-US");
       }
       else if (host.StartsWith("pt."))
       {
           ci = new CultureInfo("pt");
       }
       else if (host.StartsWith("de."))
       {
           ci = new CultureInfo("de");
       }
       else if (host.StartsWith("da."))
       {
           ci = new CultureInfo("da");
       }
   
       return ci;
   }
   

4. Y finalmente sobrescribir el GetVaryByCustomString(...) para usar también esta función:

   public override string GetVaryByCustomString(HttpContext context, string value)
   {
       if (value.ToLower() == "lang")
       {
           CultureInfo ci = GetCultureFromHost();
           return ci.Name;
       }
       return base.GetVaryByCustomString(context, value);
   }
   

La función Application_AcquireRequestState se llama en llamadas no almacenadas en caché, lo que permite que el contenido se genere y almacene en caché. GetVaryByCustomString se llama en las llamadas en caché para comprobar si el contenido está disponible en caché, y en este caso examinamos el valor de dominio de host entrante, de nuevo, en lugar de confiar solo en la información de la cultura actual, que podría haber cambiado para la nueva solicitud (porque estamos usando subdominios).

1: Cree un atributo personalizado y un método de anulación como este:

public class CultureAttribute : ActionFilterAttribute
{
    public override void OnActionExecuting(ActionExecutingContext filterContext)
    {
    // Retreive culture from GET
    string currentCulture = filterContext.HttpContext.Request.QueryString["culture"];

    // Also, you can retreive culture from Cookie like this :
    //string currentCulture = filterContext.HttpContext.Request.Cookies["cookie"].Value;

    // Set culture
    Thread.CurrentThread.CurrentCulture = new CultureInfo(currentCulture);
    Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture(currentCulture);
    }
}

2: En App_Start, busca FilterConfig.cs, agrega este atributo. (esto funciona para TODA la aplicación)

public class FilterConfig
{
    public static void RegisterGlobalFilters(GlobalFilterCollection filters)
    {
    // Add custom attribute here
    filters.Add(new CultureAttribute());
    }
}    

¡Eso es todo !

Si desea definir la cultura para cada controlador / acción en lugar de toda la aplicación, puede usar este atributo de la siguiente manera:

[Culture]
public class StudentsController : Controller
{
}

O:

[Culture]
public ActionResult Index()
{
    return View();
}

protected void Application_AcquireRequestState(object sender, EventArgs e)
        {
            if(Context.Session!= null)
            Thread.CurrentThread.CurrentCulture =
                    Thread.CurrentThread.CurrentUICulture = (Context.Session["culture"] ?? (Context.Session["culture"] = new CultureInfo("pt-BR"))) as CultureInfo;
        }