Asp.net mvc 3 在URL中使controllername可见，但不显示参数

有没有办法在MVC3中创建一个只包含控制器名称而不包含其参数的URL 我做了一个

@url.Action（“Action”，“controller”，模型）

我想让用户看到； “/controller/action”不是“/controller/action？…&&…”

---

我不知道该怎么做。

您可以使用MVC contrlib。我做了类似的事情，不需要控制

public static class UrlExtensions
{
    public static string Action<TController>(this UrlHelper urlHelper, Expression<Action<TController>> expression) where TController : Controller
    {
        return BuildUrlFromExpression(urlHelper.RequestContext, urlHelper.RouteCollection, expression);
    }

    public static string ActionWithParameters<TController>(this UrlHelper urlHelper, Expression<Action<TController>> expression) where TController : Controller
    {
        return BuildUrlFromExpressionWithParameters(urlHelper.RequestContext, urlHelper.RouteCollection, expression);
    }

    public static RedirectToRouteResult Redirect<TController>(this TController controller, Expression<Action<TController>> expression) where TController : Controller
    {
        var valuesFromExpression = ExpressionHelper.GetRouteValuesFromExpressionWithParameters(expression);

        return new RedirectToRouteResult(valuesFromExpression);

    }

    private static string BuildUrlFromExpression<TController>(RequestContext context, RouteCollection routeCollection, Expression<Action<TController>> action) where TController : Controller
    {
        var valuesFromExpression = ExpressionHelper.GetRouteValuesFromExpression(action);
        var virtualPathForArea = RouteCollectionExtensions.GetVirtualPathForArea(routeCollection, context, valuesFromExpression);
        if (virtualPathForArea != null)
            return virtualPathForArea.VirtualPath;
        return null;
    }

    private static string BuildUrlFromExpressionWithParameters<TController>(RequestContext context, RouteCollection routeCollection, Expression<Action<TController>> action) where TController : Controller
    {
        var valuesFromExpression = ExpressionHelper.GetRouteValuesFromExpressionWithParameters(action);
        var virtualPathForArea = RouteCollectionExtensions.GetVirtualPathForArea(routeCollection, context, valuesFromExpression);
        if (virtualPathForArea != null)
            return virtualPathForArea.VirtualPath;
        return null;
    }
}

public static class ExpressionHelper
{
    public static RouteValueDictionary GetRouteValuesFromExpression<TController>(Expression<Action<TController>> action) where TController : Controller
    {
        MethodCallExpression call;
        return GetRouteValuesFromExpression(action, out call);
    }

    public static RouteValueDictionary GetRouteValuesFromExpressionWithParameters<TController>(Expression<Action<TController>> action) where TController : Controller
    {
        MethodCallExpression call;
        var rvd = GetRouteValuesFromExpression(action, out call);
        AddParameterValuesFromExpressionToDictionary(rvd, call);
        return rvd;
    }

    private static RouteValueDictionary GetRouteValuesFromExpression<TController>(Expression<Action<TController>> action, out MethodCallExpression call) where TController : Controller
    {
        if (action == null)
            throw new ArgumentNullException("action");
        call = action.Body as MethodCallExpression;
        if (call == null)
            throw new ArgumentException("MustBeMethodCall", "action");
        string name = typeof(TController).Name;
        if (!name.EndsWith("Controller", StringComparison.OrdinalIgnoreCase))
            throw new ArgumentException("TargetMustEndInController", "action");
        string str = name.Substring(0, name.Length - "Controller".Length);
        if (str.Length == 0)
            throw new ArgumentException("CannotRouteToController", "action");
        string targetActionName = GetTargetActionName(call.Method);
        var rvd = new RouteValueDictionary();
        rvd.Add("Controller", (object)str);
        rvd.Add("Action", (object)targetActionName);
        var linkAreaAttribute = typeof(TController).GetCustomAttributes(typeof(ActionLinkAreaAttribute), true).FirstOrDefault() as ActionLinkAreaAttribute;
        if (linkAreaAttribute != null)
        {
            string area = linkAreaAttribute.Area;
            rvd.Add("Area", (object)area);
        }
        return rvd;
    }

    public static string GetInputName<TModel, TProperty>(Expression<Func<TModel, TProperty>> expression)
    {
        if (expression.Body.NodeType == ExpressionType.Call)
            return GetInputName((MethodCallExpression)expression.Body).Substring(expression.Parameters[0].Name.Length + 1);
        else
            return expression.Body.ToString().Substring(expression.Parameters[0].Name.Length + 1);
    }

    public static PropertyInfo GetPropertyInfo<TModel, TValue>(Expression<Func<TModel, TValue>> expression)
    {
        var member = expression.Body as MemberExpression;
        if (member == null)
            return null;
        var propInfo = member.Member as PropertyInfo;

        return propInfo;
    }


    private static string GetInputName(MethodCallExpression expression)
    {
        var expression1 = expression.Object as MethodCallExpression;
        if (expression1 != null)
            return GetInputName(expression1);
        else
            return expression.Object.ToString();
    }

    private static string GetTargetActionName(MethodInfo methodInfo)
    {
        if (methodInfo == null) throw new ArgumentNullException("methodInfo");
        var name = methodInfo.Name;
        if (methodInfo.IsDefined(typeof (NonActionAttribute), true))
        {
            throw new InvalidOperationException(string.Format(Helpers.MyFormat, "CannotCallNonAction {0}", name));
        }

        var actionNameAttribute = methodInfo.GetCustomAttributes(typeof (ActionNameAttribute), true).OfType<ActionNameAttribute>().FirstOrDefault();
        if (actionNameAttribute != null)
            return actionNameAttribute.Name;
        if (methodInfo.DeclaringType.IsSubclassOf(typeof (AsyncController)))
        {
            if (name.EndsWith("Async", StringComparison.OrdinalIgnoreCase))
                return name.Substring(0, name.Length - "Async".Length);
            if (name.EndsWith("Completed", StringComparison.OrdinalIgnoreCase))
                throw new InvalidOperationException(string.Format(Helpers.MyFormat, "CannotCallCompletedMethod: {0}", name));
        }
        return name;
    }

    private static void AddParameterValuesFromExpressionToDictionary(RouteValueDictionary rvd, MethodCallExpression call)
    {
        var parameters = call.Method.GetParameters();
        if (parameters.Length <= 0)
            return;
        for (int index = 0; index < parameters.Length; ++index)
        {
            var expression = call.Arguments[index];
            var constantExpression = expression as ConstantExpression;
            var obj = constantExpression == null ? CachedExpressionCompiler.Evaluate(expression) : constantExpression.Value;
            rvd.Add(parameters[index].Name, obj);
        }
    }
}

公共静态类URL扩展
{
公共静态字符串操作（此UrlHelper UrlHelper，表达式），其中TController:Controller
{
返回BuildUrlFromExpression（urlHelper.RequestContext，urlHelper.RouteCollection，expression）；
}
公共静态字符串ActionWithParameters（此UrlHelper UrlHelper，表达式），其中TController:Controller
{
返回BuildUrlFromExpressionWithParameters（urlHelper.RequestContext，urlHelper.RouteCollection，expression）；
}
公共静态重定向ToRouteResult重定向（此TController控制器，表达式），其中TController:controller
{
var valuesFromExpression=ExpressionHelper.GetRouteValuesFromExpressionWithParameters（表达式）；
返回新的RedirectToRouteResult（ValuesFroExpression）；
}
私有静态字符串BuildUrlFromExpression（RequestContext上下文、RouteCollection RouteCollection、Expression操作），其中TController:Controller
{
var valuesFromExpression=ExpressionHelper.GetRouteValuesFromExpression（操作）；
var virtualPathForArea=RouteCollectionExtensions.GetVirtualPathForArea（routeCollection，context，ValuesFroExpression）；
if（virtualPathForArea！=null）
返回VirtualPath for rea.VirtualPath；
返回null；
}
私有静态字符串BuildUrlFromExpressionWithParameters（RequestContext上下文、RouteCollection RouteCollection、Expression操作），其中TController:Controller
{
var valuesFromExpression=ExpressionHelper.GetRouteValuesFromExpressionWithParameters（操作）；
var virtualPathForArea=RouteCollectionExtensions.GetVirtualPathForArea（routeCollection，context，ValuesFroExpression）；
if（virtualPathForArea！=null）
返回VirtualPath for rea.VirtualPath；
返回null；
}
}
公共静态类ExpressionHelper
{
公共静态RouteValueDictionary GetRouteValuesFroExpression（表达式操作），其中TController:Controller
{
MethodCallExpression调用；
返回GetRouteValuesFroExpression（操作，out调用）；
}
公共静态RouteValueDictionary GetRouteValuesFroExpressionWithParameters（表达式操作），其中TController:Controller
{
MethodCallExpression调用；
var rvd=getRouteValuesFroExpression（操作，输出调用）；
AddParameterValuesFromexpressionDictionary（rvd，调用）；
返回差饷物业估价署；
}
私有静态RouteValueDictionary GetRouteValuesFroExpression（表达式操作，out MethodCallExpression调用），其中TController:Controller
{
if（action==null）
抛出新的异常（“操作”）；
call=action.Body作为MethodCallExpression；
if（call==null）
抛出新ArgumentException（“MustBeMethodCall”、“action”）；
字符串名称=typeof（TController）.name；
if（！name.EndsWith（“Controller”，StringComparison.OrdinalIgnoreCase））
抛出新的ArgumentException（“targetMustendInControl”，“操作”）；
string str=name.Substring（0，name.Length—“Controller.Length”）；
如果（str.Length==0）
抛出新的ArgumentException（“CannotRouteToController”、“action”）；
字符串targetActionName=GetTargetActionName（call.Method）；
var rvd=新的RouteValueDictionary（）；
rvd.添加（“控制器”、（对象）str）；
rvd.添加（“动作”，“对象”targetActionName）；
var linkAreaAttribute=typeof（TController）.GetCustomAttributes（typeof（ActionLinkAreaAttribute），true.FirstOrDefault（）作为ActionLinkAreaAttribute；
如果（linkAreaAttribute！=null）
{
字符串区域=linkAreaAttribute.area；
rvd.添加（“面积”，（对象）面积）；
}
返回差饷物业估价署；
}
公共静态字符串GetInputName（表达式）
{
if（expression.Body.NodeType==ExpressionType.Call）
返回GetInputName（（MethodCallExpression）expression.Body）.Substring（expression.Parameters[0].Name.Length+1）；
其他的
返回expression.Body.ToString（）.Substring（expression.Parameters[0].Name.Length+1）；
}
公共静态属性信息GetPropertyInfo（表达式）
{
var member=expression.Body作为MemberExpression；
if（成员==null）
返回null；
var propInfo=member.member作为PropertyInfo；
返回propInfo；
}
私有静态字符串GetInputName（MethodCallExpression表达式）
{
var expression1=expression.Object作为MethodCallExpression；
if（表达式1！=null）
返回GetInputName（表达式1）；
其他的
返回表达式.Object.ToString（）；
}
私有静态字符串GetTargetActionName（MethodInfo MethodInfo）
{
如果（methodInfo==null）抛出新的ArgumentNullException（“methodInfo”）；
var name=methodInfo.name；
if（methodInfo.IsDefined（typeof（NonActionAttribute），true））
{
抛出新的InvalidOperationException（string.Format（Helpers.MyFormat，“CannotCallNoAction{0}”，name））；
}
var actionNameAttribute=methodInfo.GetCustomAttributes（typeof（actionNameAttribute），true）.OfType（）.FirstOrDefault（）；
if（actionNameAttribute！=null）
返回actionNameAttribute.Name；
if（methodInfo.DeclaringType.IsSubclassOf（typeof（AsyncController）））
{
if（name.EndsWith（“Async”，StringComparison.OrdinalIgnoreCase））
返回name.Substring（0，name.Length-
@(Url.Action<MyController>(x => x.MethodName(null, 0, 0)))