Strongly typed url action

You can't do this:

c => c.MyMethod2

Because that is a method group. Any method in a method group can return void or anything else, so the compiler won't allow it:

Error CS0428  Cannot convert method group '...' to non-delegate type '...'

There may be a method in the group returning an ActionMethod, or none. You need to decide that.

But you don't have to provide a method group anyway. You can just use your existing signature, minus the object routeValues, and call it like this:

Url.Action<MyController>(c => c.MyMethod(99))

Then in your method, you can use the MethodInfo methodCallExpression.Method to obtain the method parameter names, and the methodCallExpression.Arguments to get the arguments.

Then your next problem is creating the anonymous object at runtime. Luckily you don't have to, as Url.Action() also has an overload accepting a RouteValueDictionary.

Zip the parameters and arguments together into a dictionary, create a RouteValueDictionary from that, and pass that to Url.Action():

var methodCallExpression = expression.Body as MethodCallExpression;
if (methodCallExpression == null)
{                
    throw new ArgumentException("Not a MethodCallExpression", "expression");
}

var methodParameters = methodCallExpression.Method.GetParameters();
var routeValueArguments = methodCallExpression.Arguments.Select(EvaluateExpression);

var rawRouteValueDictionary = methodParameters.Select(m => m.Name)
                            .Zip(routeValueArguments, (parameter, argument) => new
                            {
                                parameter,
                                argument
                            })
                            .ToDictionary(kvp => kvp.parameter, kvp => kvp.argument);

var routeValueDictionary = new RouteValueDictionary(rawRouteValueDictionary);

// action and controller obtained through your logic 

return url.Action(action, controller, routeValueDictionary);

The EvaluateExpression method very naively compiles and invokes every non-constant expression, so may prove to be horribly slow in practice:

private static object EvaluateExpression(Expression expression)
{
    var constExpr = expression as ConstantExpression;
    if (constExpr != null)
    {
        return constExpr.Value;
    }

    var lambda = Expression.Lambda(expression);
    var compiled = lambda.Compile();
    return compiled.DynamicInvoke();
}

---

However, in the Microsoft ASP.NET MVC Futures package there's the convenient ExpressionHelper.GetRouteValuesFromExpression(expr)‌​, which also handles routing and areas. Your entire method then can be replaced with:

var routeValues = Microsoft.Web.Mvc.Internal.ExpressionHelper.GetRouteValuesFromExpression<T>(expression);
return url.Action(routeValues["Action"], routeValues["Controller"], routeValues);

It uses a cached expression compiler internally, so it works for all use cases and you won't have to reinvent the wheel.