Emulate the behavior from "nameof" in a custom ASP.NET Core method

Question

The nameof construct is a really great feature of C# 6.0, especially in ASP.NET Core: It avoids the usage of hard coded strings, like for action names. Instead we refer to a class/method, and get compining errors, if their naming changes.

Example:

public async IActionResult Home() {
    return RedirectToAction(nameof(PageController.Index), GetControllerName(nameof(PageController)), new { Area = KnownAreas.Content });
 }

Compared to the old version without nameof

public async IActionResult Home() {
    return RedirectToAction("Index", "Page", new { Area = KnownAreas.Content });
}

As this is great, it blow up the code: For example I had to define a base controller class with GetControllerName. This method removes the Controller prefix, cause the controller is named Page, not PageController (the last case would result in a 404 because we double the Controller suffix.

Since this is a common use case and I want to keep the code as clean as possible, I would like to reduce that call to something like this:

public async IActionResult Home() {
    return RedirectToActionClean(PageController.Index, PageController, new { Area = KnownAreas.Content });
 }

Or even the following (which seems not possible)

public async IActionResult Home() {
    return RedirectToActionClean(PageController.Index, new { Area = KnownAreas.Content });
 }

Internally, I want to use nameof. So I pass PageController.Index to my method, and I internally have this value as string. But this seems difficult, since nameof seems to be a language construct, which can't be set as a type like generics.

To make it clear, lets have a look at my RedirectToActionClean header:

void RedirectToActionClean(??????) {

}

The question is: What type can be used for the qestion marks, that I can pass any type without instance like on nameof?

I think this is not possible since nameof seems to be a language construct and not a type. But maybe I understood something wrong and there is a way to do this. I'm using ASP.NET Core 1.1 on the latest Visual Studio 2017 with C# 7.

Answer 1

I've used expressions in the past with good results:

//within a controller or base controller
private void SetRouteValues(string action, string controller, RouteValueDictionary routeValues)
{
    if (routeValues != null)
    {
        foreach (var key in routeValues.Keys)
        {
            RouteData.Values[key] = routeValues[key];
        }
    }

    RouteData.Values["action"] = action;
    RouteData.Values["controller"] = controller;
}

protected RedirectToRouteResult RedirectToAction<TController>(Expression<Func<TController, object>> actionExpression) where TController : Controller
{
    var controllerName = typeof(TController).GetControllerName();
    var actionName = actionExpression.GetActionName();
    var routeValues = actionExpression.GetRouteValues();

    SetRouteValues(actionName, controllerName, routeValues);

    return new RedirectToRouteResult("Default", RouteData.Values);
}

//a few helper methods
public static class AdditionUrlHelperExtensions
{
    public static string GetControllerName(this Type controllerType)
    {
        var controllerName = controllerType.Name.Replace("Controller", string.Empty);
        return controllerName;
    }

    public static string GetActionName<TController>(this Expression<Func<TController, object>> actionExpression)
    {
        var actionName = ((MethodCallExpression)actionExpression.Body).Method.Name;

        return actionName;
    }

    public static RouteValueDictionary GetRouteValues<TController>(this Expression<Func<TController, object>> actionExpression)
    {
        var result = new RouteValueDictionary();
        var expressionBody = (MethodCallExpression)actionExpression.Body;

        var parameters = expressionBody.Method.GetParameters();

        //expression tree cannot represent a call with optional params
        //so our method param count and should match the expression body arg count
        //but just the same, let's check...
        if (parameters.Length != expressionBody.Arguments.Count)
            throw new InvalidOperationException("Mismatched parameter/argument count");

        for (var i = 0; i < expressionBody.Arguments.Count; ++i)
        {
            var parameter = parameters[i];
            var argument = expressionBody.Arguments[i];

            var parameterName = parameter.Name;
            var argumentValue = argument.GetValue();

            result.Add(parameterName, argumentValue);
        }

        return result;
    }

    private static object GetValue(this Expression exp)
    {
        var objectMember = Expression.Convert(exp, typeof(object));
        var getterLambda = Expression.Lambda<Func<object>>(objectMember);
        var getter = getterLambda.Compile();

        return getter();
    }
}

Usage: RedirectToAction<HomeController>(c => c.Index("param1", 2, false))

You get the nice compile time safety net of ensuring you are redirecting to valid controller actions, along with correct argument types.