MVC Extensions

From a SEO point of view, one of the top concerns of passing enumerated values (System.Enum instances) to MVC action methods has always been that routed enum values must match their enum fields names. This means that, in traditional ASP.NET MVC, a route that accepts enum values will have the underlying enum fields names in the URL itself, leading to potential ugly URLs and bad search engine ranking.

In traditional ASP.NET MVC, for example, the following

Foo

action would be reached using either

~/foo/FirstUglyValue

or

~/foo/SecondUglyValue

and this behavior can't be changed:

Excerpt from the controller class:

            public enum MyEnum
            {
                FirstUglyValue,
                SecondUglyValue
            }

            public class MyController : Controller
            {
                public ActionResult Foo(MyEnum bar)
                {
                    return Content("Baz!");
                }
            }
        

Excerpt from the application class (global.asax.cs):

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

            routes.MapRoute("MyUglyRoute",
                "{action}/{bar}",
                new {
                        controller = "MyController",
                    });

            // ...
        }
        

SEO Extensions takes a different approach and allows to easily map each enumerated value to a specific string, giving ASP.NET developers the full power to control how their routes are built and handled. In fact, you can easily control the URL segment of your enum values by decorating with the

EnumUrl

attribute the fields you wish to map, along with the URL segment itself.

To do that, the aforementioned route needs to be converted to a SEO route (remember, explicit route mapping in your application class is not needed anymore with this technique, as SEO Extensions automatically takes care of the routes registration on your behalf) and the enum needs a small revision to include the

EnumUrl

attribute:

            public enum MyEnum
            {
                [EnumUrl("first")]
                FirstUglyValue,

                [EnumUrl("second")]
                SecondUglyValue
            }

            public class MyController : Controller
            {
                [Route.Action("~/foo")]
                public ActionResult Foo([Route.Param] MyEnum bar)
                {
                    return Content("Baz!");
                }
            }
        

This way, the action shown above would be automatically reached by using either

~/foo/first

or

~/foo/second

, possibly with a much higher SEO ranking.

What if you don't have access to the enum source code? SEO Extensions includes a handy class named

EnumUrlMapperRegistry

which allows to easily define application-wide mappers for your enumerations, by way of implementations of the

IEnumUrlMapper

interface. The usage is very simple, as the

IEnumUrlMapper

interface has just two methods:

MapFieldNameToUrl()

and

MapUrlToFieldName()

, which do exactly what their names suggest. Furthermore, SEO Extensions comes with a useful

IEnumUrlMapper

implementation named

DictionaryEnumUrlMapper

that allows bidirectional links between URLs and field names (something you may wish most of the times).

Following the previous example and now supposing the

MyEnum

has been defined in assembly you can't modify to add the

EnumUrl

attributes, the next example shows how you would obtain the same results while adding an enum mapper to the

EnumUrlMapperRegistry

and leaving the action as it was:

Excerpt from the controller class (same as above):

            public class MyController : Controller
            {
                [Route.Action("~/foo")]
                public ActionResult Foo([Route.Param] MyEnum bar)
                {
                    return Content("Baz!");
                }
            }
        

Excerpt from the application class (global.asax.cs):

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

            var coolMapper = new DictionaryEnumUrlMapper<MyEnum>();
            
            coolMapper.Map(MyEnum.FirstUglyValue, "first")
            coolMapper.Map(MyEnum.SecondUglyValue, "second")

            EnumUrlMapperRegistry.Register(typeof(MyEnum), coolMapper);

            // ...
        }