Question

I really like the ASP.NET MVC 3 framework. Or at least, it sure is incomparably better than trying to fool with ASP.NET 3.5 or 4.0. However, I am just really confused about something. Why did they choose to specify routes with strings?

IOW, I am told to specify my routes like this (for instance):

... new { controller = "Products", action = "List", id = UrlParameter.Optional }

This route matches a ProductsController.List() method. Let’s say I’m in a refactoring mood and I want to rename my ProductsController to InventoryController. After using my renaming tool of choice, I have open up Global.aspx and go through all my routes and change all these stupid strings to “Inventory”. You might respond that I can do a find and replace… but come on! I feel like that is such a last-generation answer.

I love refactoring my code as I come to understand my domain better. I don’t want to use stupid (I say stupid because they have no significance to the compiler) strings to refer to symbolic/semantic code constructs that correspond exactly to type and method names that are ultimately stored in a symbol table. What is the point? Why bother with types at all? Let’s just go back to writing scripts using associative arrays and dictionaries to represent our domain model… it seems to me that the benefit of strong typing is greatly lessened when we mix it with string references.

Seriously, though, an option would be reflection. Would there be a performance hit for this? I suppose the MVC framework must be using reflection on that “Products” string to get my ProductsController, so… But also, you would have to remove the “Controller” portion of the type name, as follows:

= typeof(ProductsController).Name.Replace("Controller", string.Empty)

I could use the following helper function to make it a little DRYer:

public string GetControllerName(Type controller)
{
    return controller.Name.Replace("Controller", string.Empty);
}

Benchmarking is in order, if this is the only way to avoid those strings… Still, this is stupid. I’m using reflection on a type to get a string that MVC is going to use in conjunction with reflection to get the type I originally had in the first place.

Is there some reason not take the next (logical?) step and have the controller and action properties expect Types and Delegates directly? Wouldn’t this simply be cleaner and clearer? So far as I understand, a fundamental aspect of MVC is convention over configuration, but routing with those strings just seems to be a furtive form of configuration to me.

Is there another way around this? I am still new to MVC. I’ve read that we can replace these routing components. Does anyone know if it is possible to do what I’m talking about? And if it’s not possible, well… am I alone here? Am I missing something? Some overriding reason why it is essential that these routes be set by dumb strings? If not, could this maybe be something to lobby for?

Am I alone in hating it when strings are used in this way? I still think C# needs something akin to Ruby’s symbols and Lisp’s keywords that our refactoring tools could take advantage of. Sort of like “string enumerations” where the enumeration value name is at the same time the value.

I understand that parts of this question are subjective, but I am also looking for the objective answer on whether it is possible to directly use types and delegates to specify these routing configurations.

Thank you,
Jeromeyers

Answer 1

Personally I never had problems with the way routes are defined because I always unit test them. So if I am in a refactoring mood, my unit tests always guarantee me that the routes will behave as I want.

Of course if you are still not satisfied with the way the ASP.NET MVC team designed the framework (don’t hesitate to open a ticket and vote for improvement in future versions) you could always write a custom route:

public class IHateMagicStringsRoute<T> : Route where T : Controller
{
    public IHateMagicStringsRoute(
        string url,
        Expression<Func<T, ActionResult>> expression
    ) : base(url, Parse(expression), new MvcRouteHandler())
    { }

    private static RouteValueDictionary Parse(Expression<Func<T, ActionResult>> expression)
    {
        var mce = expression.Body as MethodCallExpression;
        if (mce != null)
        {
            return new RouteValueDictionary(new
            {
                controller = typeof(T).Name.Replace("Controller", ""),
                action = mce.Method.Name
            });
        }
        return null;
    }
}

and then instead of:

routes.MapRoute(
    "Default",
    "{controller}/{action}",
    new { controller = "Home", action = "Index" }
);

you could:

routes.Add(
    new IHateMagicStringsRoute<HomeController>(
        "{controller}/{action}",
        x => x.Index()
    )
);

Now you can rename your controllers and actions as much as you like.