¿Cómo puedo encontrar la URL absoluta de una acción en ASP.NET MVC?

Question

tengo que hacer algo como esto:

<script type="text/javascript"> 
    token_url = "http://example.com/your_token_url"; 
</script> 

estoy usando la versión beta de MVC, pero no puedo encontrar la manera de obtener la URL absoluta de una acción. Me gustaría hacer algo como esto:

<%= Url.AbsoluteAction("Action","Controller")) %> 

¿Hay un ayudante o método de página para esto?

Answer 1

Haga clic here para obtener más información, pero absoluto se refiere a que no hay necesidad de métodos de extensión. Ya está preparado, solo que no de una manera muy intuitiva.

Url.Action("Action", null, null, Request.Url.Scheme); 

Answer 2

No estoy seguro de si hay una forma integrada para hacerlo, pero podría ejecutar su propio método HtmlHelper.

algo como lo siguiente

namespace System.Web.Mvc 
{ 
    public static class HtmlExtensions 
    { 
     public static string AbsoluteAction(this HtmlHelper html, string actionUrl) 
     { 
      Uri requestUrl = html.ViewContext.HttpContext.Request.Url; 

      string absoluteAction = string.Format("{0}://{1}{2}", 
                requestUrl.Scheme, 
                requestUrl.Authority, 
                actionUrl); 

      return absoluteAction; 
     } 
    } 
} 

Entonces llaman como éste

<%= Html.AbsoluteAction(Url.Action("Dashboard", "Account"))%> » 

HTHS, Charles

Answer 3

Extender el UrlHelper

namespace System.Web.Mvc 
{ 
    public static class HtmlExtensions 
    { 
     public static string AbsoluteAction(this UrlHelper url, string action, string controller) 
     { 
      Uri requestUrl = url.RequestContext.HttpContext.Request.Url; 

      string absoluteAction = string.Format(
       "{0}://{1}{2}", 
       requestUrl.Scheme, 
       requestUrl.Authority, 
       url.Action(action, controller)); 

      return absoluteAction; 
     } 
    } 
} 

A continuación, llamarlo como esto

<%= Url.AbsoluteAction("Dashboard", "Account")%> 

EDITAR - ANOTACIONES ReSharper

El comentario más upvoted en la respuesta aceptada es This answer is the better one, this way Resharper can still validate that the Action and Controller exists. Así que aquí es un ejemplo de cómo se puede conseguir el mismo comportamiento.

using JetBrains.Annotations 

namespace System.Web.Mvc 
{ 
    public static class HtmlExtensions 
    { 
     public static string AbsoluteAction(
      this UrlHelper url, 
      [AspMvcAction] 
      string action, 
      [AspMvcController] 
      string controller) 
     { 
      Uri requestUrl = url.RequestContext.HttpContext.Request.Url; 

      string absoluteAction = string.Format(
       "{0}://{1}{2}", 
       requestUrl.Scheme, 
       requestUrl.Authority, 
       url.Action(action, controller)); 

      return absoluteAction; 
     } 
    } 
} 

Apoyo Info:

• Providing Intellisense, Navigation and more for Custom Helpers in ASP.NET MVC

Answer 4

mismo resultado, pero un poco más limpio (sin concatenación de cadenas/formato):

public static Uri GetBaseUrl(this UrlHelper url) 
{ 
    Uri contextUri = new Uri(url.RequestContext.HttpContext.Request.Url, url.RequestContext.HttpContext.Request.RawUrl); 
    UriBuilder realmUri = new UriBuilder(contextUri) { Path = url.RequestContext.HttpContext.Request.ApplicationPath, Query = null, Fragment = null }; 
    return realmUri.Uri; 
} 

public static string ActionAbsolute(this UrlHelper url, string actionName, string controllerName) 
{ 
    return new Uri(GetBaseUrl(url), url.Action(actionName, controllerName)).AbsoluteUri; 
} 

Answer 5

Usando @Charlino 's respuesta como una guía, se me ocurrió esto.

El ASP.NET MVC documentation for UrlHelper muestra que Url.Action devolverá un Url totalmente calificado si se pasan un nombre de host y protocolo. Creé estos helpers para forzar que se proporcionen el nombre de host y el protocolo. Las múltiples sobrecargas reflejan las sobrecargas de Url.Action:

using System.Web.Routing; 

namespace System.Web.Mvc { 
    public static class HtmlExtensions { 

     public static string AbsoluteAction(this UrlHelper url, string actionName) { 
      Uri requestUrl = url.RequestContext.HttpContext.Request.Url; 
      return url.Action(actionName, null, (RouteValueDictionary)null, 
           requestUrl.Scheme, null); 
     } 

     public static string AbsoluteAction(this UrlHelper url, string actionName, 
              object routeValues) { 
      Uri requestUrl = url.RequestContext.HttpContext.Request.Url; 
      return url.Action(actionName, null, new RouteValueDictionary(routeValues), 
           requestUrl.Scheme, null); 
     } 

     public static string AbsoluteAction(this UrlHelper url, string actionName, 
              RouteValueDictionary routeValues) { 
      Uri requestUrl = url.RequestContext.HttpContext.Request.Url; 
      return url.Action(actionName, null, routeValues, requestUrl.Scheme, null); 
     } 

     public static string AbsoluteAction(this UrlHelper url, string actionName, 
              string controllerName) { 
      Uri requestUrl = url.RequestContext.HttpContext.Request.Url; 
      return url.Action(actionName, controllerName, (RouteValueDictionary)null, 
           requestUrl.Scheme, null); 
     } 

     public static string AbsoluteAction(this UrlHelper url, string actionName, 
              string controllerName, 
              object routeValues) { 
      Uri requestUrl = url.RequestContext.HttpContext.Request.Url; 
      return url.Action(actionName, controllerName, 
           new RouteValueDictionary(routeValues), requestUrl.Scheme, 
           null); 
     } 

     public static string AbsoluteAction(this UrlHelper url, string actionName, 
              string controllerName, 
              RouteValueDictionary routeValues) { 
      Uri requestUrl = url.RequestContext.HttpContext.Request.Url; 
      return url.Action(actionName, controllerName, routeValues, requestUrl.Scheme, 
           null); 
     } 

     public static string AbsoluteAction(this UrlHelper url, string actionName, 
              string controllerName, object routeValues, 
              string protocol) { 
      Uri requestUrl = url.RequestContext.HttpContext.Request.Url; 
      return url.Action(actionName, controllerName, 
           new RouteValueDictionary(routeValues), protocol, null); 
     } 

    } 
} 

Answer 6

Tal vez esto (?):

<%= 
    Request.Url.GetLeftPart(UriPartial.Authority) + 
    Url.Action("Action1", "Controller2", new {param1="bla", param2="blabla" }) 
%> 

Answer 7

<%= Url.Action("About", "Home", null, Request.Url.Scheme) %> 
<%= Url.RouteUrl("Default", new { Action = "About" }, Request.Url.Scheme) %> 

Answer 8

env: dotnet núcleo versión 1.0.4

Url.Action("Join",null, null,Context.Request.IsHttps?"https":"http"); 

Answer 9

La respuesta completa con argumentos sería:

var url = Url.Action("ActionName", "ControllerName", new { id = "arg_value" }, Request.Url.Scheme); 

y que producirá una URL absoluta