ASP.net prise en charge MVC pour les URL avec des traits d'Union

C # version de John's Post pour tous ceux qui le préféreraient: C# et VB version sur mon blog

public class HyphenatedRouteHandler : MvcRouteHandler{
        protected override IHttpHandler  GetHttpHandler(RequestContext requestContext)
        {
            requestContext.RouteData.Values["controller"] = requestContext.RouteData.Values["controller"].ToString().Replace("-", "_");
            requestContext.RouteData.Values["action"] = requestContext.RouteData.Values["action"].ToString().Replace("-", "_");
            return base.GetHttpHandler(requestContext);
        }
    }

...et la nouvelle route:

routes.Add(
            new Route("{controller}/{action}/{id}", 
                new RouteValueDictionary(
                    new { controller = "Default", action = "Index", id = "" }),
                    new HyphenatedRouteHandler())
        );

vous pouvez utiliser la méthode suivante aussi, mais gardez à l'esprit que vous auriez besoin de nommer la vue My-Action qui peut être ennuyeux si vous aimez laisser visual studio auto générer vos fichiers de vue.

[ActionName("My-Action")]
public ActionResult MyAction() {
    return View();
}

Tout ce que vous devez vraiment faire dans ce cas est de nommer vos vues avec les traits d'Union que vous voulez qu'elles apparaissent dans L'URL, supprimer les traits d'Union dans votre controller et ensuite ajouter un attribut Actionnom qui a les traits d'union de retour en elle. Il n'y a aucun besoin d'avoir des underscores.

ont une vue appelée modifier-détails.aspx

et avoir un contrôleur comme celui-ci:

[ActionName("edit-details")]
public ActionResult EditDetails(int id)
{
    // your code
}

je me rends compte que c'est une question assez ancienne, mais pour moi ce n'est que la moitié de l'histoire d'accepter les url avec des traits d'Union en eux, l'autre moitié génère ces urls tout en étant capable d'utiliser Html.ActionLink et d'autres helpers dans le cadre MVC, j'ai résolu cela en créant une classe de route personnalisée similaire, voici le code au cas où il aide quelqu'un à venir ici à partir d'une recherche google. Il comprend également le boîtier inférieur de l'url.

public class SeoFriendlyRoute : Route
{
     // constructor overrides from Route go here, there is 4 of them

     public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
     {
          var path = base.GetVirtualPath(requestContext, values);

          if (path != null)
          {
              var indexes = new List<int>();
              var charArray = path.VirtualPath.Split('?')[0].ToCharArray();
              for (int index = 0; index < charArray.Length; index++)
              {
                  var c = charArray[index];
                  if (index > 0 && char.IsUpper(c) && charArray[index - 1] != '/')
                      indexes.Add(index);
              }

              indexes.Reverse();
              indexes.Remove(0);
              foreach (var index in indexes)
                  path.VirtualPath = path.VirtualPath.Insert(index, "-");

              path.VirtualPath = path.VirtualPath.ToLowerInvariant();
          }

          return path;
     }
}

alors quand en ajoutant des routes, vous pouvez soit créer des extensions RouteCollection ou simplement utiliser ce qui suit dans vos déclarations globales de routage

routes.Add(
        new SeoFriendlyRoute("{controller}/{action}/{id}", 
            new RouteValueDictionary(
                new { controller = "Default", action = "Index", id = "" }),
                new HyphenatedRouteHandler())
    );

Merci dsteuernol pour cette réponse - exactement ce que je cherchais. Cependant, j'ai trouvé que j'avais besoin d'améliorer le coupleur de traits D'Union pour couvrir le scénario où le contrôleur ou la zone était implicite à partir de la page courante. Par exemple, en utilisant @Html.ActionLink ("Mon Lien"," Index")

j'ai changé la méthode GetHttpHandler pour la suivante:

public class HyphenatedRouteHandler : MvcRouteHandler
    {
        /// <summary>
        /// Returns the HTTP handler by using the specified HTTP context.
        /// </summary>
        /// <param name="requestContext">The request context.</param>
        /// <returns>
        /// The HTTP handler.
        /// </returns>
        protected override IHttpHandler GetHttpHandler(RequestContext requestContext)
        {

            requestContext.RouteData.Values["controller"] = ReFormatString(requestContext.RouteData.Values["controller"].ToString());
            requestContext.RouteData.Values["action"] = ReFormatString(requestContext.RouteData.Values["action"].ToString());

            // is there an area
            if (requestContext.RouteData.DataTokens.ContainsKey("area"))
            {
                requestContext.RouteData.DataTokens["area"] = ReFormatString(requestContext.RouteData.DataTokens["area"].ToString());
            }

            return base.GetHttpHandler(requestContext);
        }


        private string ReFormatString(string hyphenedString)
        {
            // lets put capitals back in

            // change dashes to spaces
            hyphenedString = hyphenedString.Replace("-", " ");

            // change to title case
            hyphenedString = CultureInfo.InvariantCulture.TextInfo.ToTitleCase(hyphenedString);

            // remove spaces
            hyphenedString = hyphenedString.Replace(" ", "");

            return hyphenedString;
        }
    }

la remise des majuscules signifiait que le contrôleur implicite ou la zone était alors les mots correctement.

j'ai développé un open source NuGet library pour ce problème qui convertit implicitement EveryMvc/Url en every-mvc/url.

sont beaucoup plus conviviales pour le référencement et plus faciles à lire. ( plus sur mon blog )

paquet NuGet: https://www.nuget.org/packages/LowercaseDashedRoute /

pour l'installer, il suffit d'ouvrir la fenêtre NuGet Visual Studio en cliquant avec le bouton droit de la souris sur le projet et en sélectionnant NuGet Package Manager, et sur l'onglet "Online" tapez "Lowercase Dashed Route", et il devrait apparaître.

alternativement, vous pouvez exécuter ce code dans la Console du Gestionnaire de paquets:

Install-Package LowercaseDashedRoute

après cela, vous devez ouvrir App_Start/RouteConfig.cs et commenter route existante.MapRoute(...) appelez et ajoutez ceci à la place:

routes.Add(new LowercaseDashedRoute("{controller}/{action}/{id}",
  new RouteValueDictionary(
    new { controller = "Home", action = "Index", id = UrlParameter.Optional }),
    new DashedRouteHandler()
  )
);

C'est ça. Toutes les urls sont minuscules, tiretées et converties implicitement sans que vous fassiez quoi que ce soit de plus.

Open Source Url du projet: https://github.com/AtaS/lowercase-dashed-route

Ne sait pas d'une manière sans écrire une carte pour chaque url:

routes.MapRoute("EditDetails", "test-page/edit-details/{id}", new { controller = "test_page", action = "edit_details" });

si vous mettez à jour votre projet en MVC5, vous pouvez utiliser l'acheminement des attributs.

[Route("controller/my-action")]
public ActionResult MyAction() {
    return View();
}

je préfère de loin cette approche à la solution acceptée, qui vous laisse avec les underscores dans les noms d'action de votre contrôleur et les noms de fichiers de vue, et les traits d'Union dans L'Url de votre vue.Les aides d'Action. Je préfère la cohérence, et ne pas avoir à me rappeler comment les noms sont convertis.