In ASP.Net MVC (on top on .Net Framework) there was useful mechanism for generating actions urls from C# lambda expressions. Let's say we have controller UserController for managing users which has List action with 3 params:
- page number (in case if users list is large and we need to use pagination)
- sort by (first name, last name, etc)
- sort direction (asc or desc)
public enum SortDirection
{
Asc,
Desc
}
public class UserController : Controller
{
public ActionResult List(int pageNumber, string sortBy, SortDirection sortDirection)
{
...
}
}
In this case we could generate url for this action using generic ActionLink<T> method like this:
Html.ActionLink<UserController>(c => c.List(0, "FirstName", SortDirection.Asc), "All users")
which will generate the following url:
/user/list?pageNumber=0&sortBy=FirstName&sortDirection=SortDirection.Asc
That is convenient method since we have compile-time check for the code. Compare it with classic way:
Html.ActionLink("All users", "List", "Users", new { pageNumber = 0, sortBy = "FirstName", sortDirection = SortDirection.Asc })
In the last case if e.g. action name, parameters names or number of params will be changed we won't get any errors or warning during compilation. Instead we may get unexpected behavior or runtime error (e.g. if new parameter was added it will have default value if we won't explicitly add it to link generation code).
The problem is that strongly-typed method is not available in ASP.Net Core. Don't know what was the reason for not adding it there (except mentioned advantage of having compile-time check it may also be a problem during migration of old ASP.Net MVC app to ASP.Net Core) but fortunately it is possible to get it back there.
Lets check steps which are needed for generating action url from expression: we need to get controller name (/user), action name (/list), list action parameters names (or get route values from expression how it is called in ASP.Net MVC) and (most tricky one) get value of each parameter passed to expression. And then concatenate all parts to one string. First 3 steps are relatively easy: they can be done by basic reflection. But last step (get values of parameters passed to lambda expression) needs extra attention. In the past I already faced with that need in Camlex.NET (open source library for Sharepoint developers which I maintain in free time): Runtime evaluation of lambda expressions. We can use the same technique here as well. Also (as I found out during experiments) code for generating routing values from expression (list parameters names) can be reused with small changes from internal method of ASP.Net MVC Microsoft.Web.Mvc.Internal.ExpressionHelper.GetRouteValuesFromExpression in ASP.NET Core - it will help to save our time.
Now if we will combine all of this we may create helper class for generating urls from expressions in ASP.Net Core:
public static class HtmlHelperExtensions
{
public static string ActionLink<TController>(this IHtmlHelper html, Expression<Action<TController>> actionExpression)
{
return ActionLink(actionExpression, GetRouteValuesFromExpression(actionExpression));
}
public static string ActionLink<TController>(this IHtmlHelper html, Expression<Action<TController>> actionExpression, RouteValueDictionary routeValues)
{
return ActionLink(actionExpression, routeValues);
}
public static string ActionLink<TController>(Expression<Action<TController>> actionExpression, RouteValueDictionary routeValues)
{
string controllerName = typeof(TController).GetControllerName();
string actionName = actionExpression.GetActionName();
var sb = new StringBuilder($"/{controllerName}/{actionName}");
if (routeValues != null)
{
bool isFirst = true;
foreach (var routeValue in routeValues)
{
sb.Append(isFirst ? "?" : "&");
sb.Append($"{routeValue.Key}={routeValue.Value}");
isFirst = false;
}
}
return sb.ToString();
}
private static string GetControllerName(this Type controllerType)
{
return controllerType.Name.Replace("Controller", string.Empty);
}
private static string GetActionName(this LambdaExpression actionExpression)
{
return ((MethodCallExpression)actionExpression.Body).Method.Name;
}
// copy of Microsoft.Web.Mvc.Internal.ExpressionHelper.GetRouteValuesFromExpression
private static RouteValueDictionary GetRouteValuesFromExpression<TController>(
Expression<Action<TController>> action)
{
if (action == null)
throw new ArgumentNullException(nameof(action));
if (!(action.Body is MethodCallExpression body))
throw new ArgumentException("MustBeMethodCall");
string name = typeof(TController).Name;
string str = name.EndsWith("Controller", StringComparison.OrdinalIgnoreCase)
? name.Substring(0, name.Length - "Controller".Length)
: throw new ArgumentException("TargetMustEndInController");
if (str.Length == 0)
throw new ArgumentException("CannotRouteToController");
string targetActionName = GetTargetActionName(body.Method);
var rvd = new RouteValueDictionary();
AddParameterValuesFromExpressionToDictionary(rvd, body);
return rvd;
}
private static void AddParameterValuesFromExpressionToDictionary(
RouteValueDictionary rvd,
MethodCallExpression call)
{
ParameterInfo[] parameters = call.Method.GetParameters();
if (parameters.Length <= 0)
return;
for (int index = 0; index < parameters.Length; ++index)
{
Expression expression = call.Arguments[index];
object obj = !(expression is ConstantExpression constantExpression)
? Expression.Lambda<Func<object, object>>((Expression)Expression.Convert(expression, typeof(object)), Expression.Parameter(typeof(object), "_unused")).Compile().Invoke((object)null)
: constantExpression.Value;
rvd.Add(parameters[index].Name, obj);
}
}
private static string GetTargetActionName(MethodInfo methodInfo)
{
string name = methodInfo.Name;
ActionNameAttribute actionNameAttribute = !methodInfo.IsDefined(typeof(NonActionAttribute), true)
? methodInfo.GetCustomAttributes(typeof(ActionNameAttribute), true).OfType<ActionNameAttribute>().FirstOrDefault<ActionNameAttribute>()
: throw new InvalidOperationException("CannotCallNonAction");
if (actionNameAttribute != null)
return actionNameAttribute.Name;
return name;
}
}
Using this helper class we may again generate actions links from C# expressions in ASP.Net Core.
