ASP.NET MVC, lokalisierte Routen und die default-Sprache für den Benutzer

Dies ist, wie ich es tun würde.

~~ Disclaimer : Pseudo-code ~~

global.asax

public static void RegisterRoutes(RouteCollection routes)
{
    routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
    routes.IgnoreRoute("{*favicon}",
        new { favicon = @"(.*/)?favicon.ico(/.*)?" });

    routes.MapRoute(
        "Question-Answer", //Route name
        "{languageCode}/{controller}/{action}", //URL with parameters
        new {controller = "home", action = "index"} //Parameter defaults
        );

}

Beachten Sie: der controller und/oder action brauchen NICHT zu ersten und zweiten. in der Tat, Sie brauchen nicht zu existieren, in der url with parameters Abschnitt.

Dann ...

HomeController.cs

public ActionResult Index(string languageCode)
{
   if (string.IsNullOrEmpty(languageCode) ||
      languageCode != a valid language code)
   {
       //No code was provided OR we didn't receive a valid code 
       //which you can't handle... so send them to a 404 page.
       //return ResourceNotFound View ...
   }

   //.. do whatever in here ..
}

Bonus Anregung

Können Sie auch hinzufügen, eine Route Einschränkung, um Ihre Routen, damit Sie akzeptiert nur bestimmte Zeichenfolgen für die languageCode parameter. So stehlen diese dude-code ....

(mehr pseduo-code)...

public class FromValuesListConstraint : IRouteConstraint
{
    public FromValuesListConstraint(params string[] values)
    {
        this._values = values;
    }

    private string[] _values;

    public bool Match(HttpContextBase httpContext,
        Route route,
        string parameterName,
        RouteValueDictionary values,
        RouteDirection routeDirection)
    {
        //Get the value called "parameterName" from the 
        //RouteValueDictionary called "value"
        string value = values[parameterName].ToString();

        //Return true is the list of allowed values contains 
        //this value.
        return _values.Contains(value);
    }
}

bedeutet, dass Sie dies tun könnte ......

routes.MapRoute(
    "Question-Answer", //Route name
    "{languageCode}/{controller}/{action}", //URL with parameters
    new {controller = "home", action = "index"} //Parameter defaults
    new { languageCode = new FromValuesListConstraint("en", "sv", .. etc) }
    );

und dort haben Sie es 🙂

Ich etwas tun, wie dies für Versionierung mein MVC-Api.

GL 🙂 Hoffe, das hilft.

InformationsquelleAutor Pure.Krome

Ich weiß, das ist eine sehr alte Frage, aber hatte gerade zu lösen, die komplette Reihe von Themen, die ich dachte, ich würde teilen meine Lösung.

Unten ist eine komplette Lösung, inklusive ein paar extra tricks ermöglichen einen einfachen Wechsel der Sprache. Es ermöglicht für bestimmte Kulturen, nicht nur für bestimmte Sprachen (aber nur die Sprache bleibt in diesem Beispiel).

Funktionen gehören:

• Fallback für browser-locale in der Bestimmung der Sprache
• Verwendet cookies behalten Sprache über Besuche
• Überschreiben Sprache mit der url
• Unterstützt die änderung der Sprache über einen link (z.B. einfache Menü-Optionen)

Schritt 1: Ändern RegisterRoutes in RouteConfig

Diese neue routing enthält eine Einschränkung (wie die anderen auch empfehlen), damit der language route nicht greifen bestimmte standard-Pfade. Es gibt keine Notwendigkeit für eine Standard-Sprache Wert, wie das alles behandelt, indem die LocalisationAttribute (siehe Schritt 2).

    public static void RegisterRoutes(RouteCollection routes)
    {
        ...

        //Special localisation route mapping - expects specific language/culture code as first param
        routes.MapRoute(
            name: "Localisation",
            url: "{lang}/{controller}/{action}/{id}",
            defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional },
            constraints: new { lang = @"[a-z]{2}|[a-z]{2}-[a-zA-Z]{2}" }
        );

        //Default routing
        routes.MapRoute(
            name: "Default",
            url: "{controller}/{action}/{id}",
            defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
        );

    }

Schritt 2: Erstellen Sie eine Lokalisierung Attribut

Diese betrachten controller-Anforderungen, bevor Sie behandelt werden, und ändern Sie die aktuelle Kultur auf der Grundlage der URL, die ein cookie, oder die Standard-browser-Kultur.

//Based on: http://geekswithblogs.net/shaunxu/archive/2010/05/06/localization-in-asp.net-mvc-ndash-3-days-investigation-1-day.aspx
public class LocalisationAttribute : ActionFilterAttribute
{
    public const string LangParam = "lang";
    public const string CookieName = "mydomain.CurrentUICulture";

    //List of allowed languages in this app (to speed up check)
    private const string Cultures = "en-GB en-US de-DE fr-FR es-ES ro-RO ";

    public override void OnActionExecuting(ActionExecutingContext filterContext)
    {
        //Try getting culture from URL first
        var culture = (string)filterContext.RouteData.Values[LangParam];

        //If not provided, or the culture does not match the list of known cultures, try cookie or browser setting
        if (string.IsNullOrEmpty(culture) || !Cultures.Contains(culture))
        {
            //load the culture info from the cookie
            var cookie = filterContext.HttpContext.Request.Cookies[CookieName];
            if (cookie != null)
            {
                //set the culture by the cookie content
                culture = cookie.Value;
            }
            else
            {
                //set the culture by the location if not specified
                culture = filterContext.HttpContext.Request.UserLanguages[0];
            }
            //set the lang value into route data
            filterContext.RouteData.Values[LangParam] = culture;
        }

        //Keep the part up to the "-" as the primary language
        var language = culture.Split(new char[] { '-' }, StringSplitOptions.RemoveEmptyEntries)[0];
        filterContext.RouteData.Values[LangParam] = language;

        //Set the language - ignore specific culture for now
        Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture(language);

        //save the locale into cookie (full locale)
        HttpCookie _cookie = new HttpCookie(CookieName, culture);
        _cookie.Expires = DateTime.Now.AddYears(1);
        filterContext.HttpContext.Response.SetCookie(_cookie);

        //Pass on to normal controller processing
        base.OnActionExecuting(filterContext);
    }
}

Schritt 3: Wenden Lokalisierung an alle Controller

z.B.

[Localisation]  <<< ADD THIS TO ALL CONTROLLERS (OR A BASE CONTROLLER)
public class AccountController : Controller
{

Schritt 4: um die Sprache Zu ändern (z.B. über ein Menü)

Dies ist, wo es noch ein bisschen schwierig und benötigt einige workarounds.

Fügen Sie eine Methode ChangeLanguage auf Ihr Konto controller. Dies Streifen aus jedem bestehenden Sprachcode aus der "letzten Weg" zu ermöglichen, um die neue Sprache wirksam wird.

    //Regex to find only the language code part of the URL - language (aa) or locale (aa-AA) syntax
    static readonly Regex removeLanguage = new Regex(@"/[a-z]{2}/|/[a-z]{2}-[a-zA-Z]{2}/", RegexOptions.Compiled);

    [AllowAnonymous]
    public ActionResult ChangeLanguage(string id)
    {
        if (!string.IsNullOrEmpty(id))
        {
            //Decode the return URL and remove any language selector from it
            id = Server.UrlDecode(id);
            id = removeLanguage.Replace(id, @"/");
            return Redirect(id);
        }
        return Redirect(@"/");
    }

Schritt 5: Fügen Sie die Sprache im Menü links

Den Menü-Optionen bestehen aus einer Verknüpfung mit der neuen Sprache angegeben als parameter der route.

z.B. (Razor Beispiel)

<li>@Html.ActionLink("English", "ChangeLanguage", "Account", new { lang = "en", id = HttpUtility.UrlEncode(Request.RawUrl) }, null)</li>
<li>@Html.ActionLink("Spanish", "ChangeLanguage", "Account", new { lang = "es", id = HttpUtility.UrlEncode(Request.RawUrl) }, null)</li>

Den Rückgabe-URl der aktuellen Seite, codiert, so dass es den parameter id in der URL. Dies bedeutet, dass Sie benötigen, um bestimmte escape-Sequenzen, die sonst abgelehnt von Razor wie eine potenzielle Sicherheitsverletzung.

Hinweis: für nicht-razor-setups, die Sie wollen im Grunde, ein Anker, hat die neue Sprache und die aktuelle Seite relative URL, die in einem Pfad wie:
http://website.com/{language}/account/changelanguage/{existingURL}

{language} ist die neue Kultur-code und {existingURL} ist eine URLencoded version der aktuellen relative Adresse der Seite (so dass wir wieder auf die gleiche Seite, die die neue Sprache ausgewählt ist).

Schritt 6: Aktivieren Sie bestimmte "unsichere" Zeichen in URLs

Die erforderliche Kodierung der URL zurück, bedeutet, dass Sie benötigen, um bestimmte escape-Zeichen, in der web.config oder die bestehende URL-parameter führt zu einem Fehler.

In Ihrer Website.config, finden die httpRuntime tag (oder hinzufügen) in <system.web> und fügen Sie den folgenden, um es (im Grunde entfernen Sie die%, die in der standard-version dieses Attributs):

  requestPathInvalidCharacters="<,>,&,:,\,?"

In Ihrer Website.config, finden die <system.webserver> Abschnitt und fügen Sie die folgende drin:

<security>
  <requestFiltering allowDoubleEscaping="true"/>
</security>

InformationsquelleAutor Gone Coding