Wie finde ich die absolute URL einer Aktion in ASP.NET MVC?

Question

Ich brauche so etwas wie dies zu tun:

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

ich die Beta-Version von MVC, aber ich kann nicht herausfinden, wie die absolute URL einer Aktion zu bekommen. Ich möchte etwas in der Art machen:

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

Gibt es dafür eine Hilfs- oder Page-Methode?

Answer 1

Klicken Sie here für weitere Informationen, aber esentially gibt es keine Notwendigkeit für Erweiterungsmethoden. Es ist bereits gebacken, nur nicht auf eine sehr intuitive Art und Weise.

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

Answer 2

Ich bin mir nicht sicher, ob es eine eingebaute Möglichkeit dafür gibt, aber Sie könnten Ihre eigene HtmlHelper-Methode erstellen.

So etwas wie die folgenden

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; 
     } 
    } 
} 

Dann nennen es ähnliche

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

HTHS, Charles

Answer 3

Erweitere 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; 
     } 
    } 
} 

Dann nennen wie diese

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

EDIT - ReSharper ANNOTATIONS

Die upvoted Kommentar über die akzeptierte Antwort ist This answer is the better one, this way Resharper can still validate that the Action and Controller exists. So, hier ist ein Beispiel, wie Sie das gleiche Verhalten zu bekommen.

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; 
     } 
    } 
} 

Supporting Info:

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

Answer 4

gleiches Ergebnis, aber ein wenig saubere (keine String-Verkettung/Formatierung):

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

Mit @Charlino ‚s Antwort als Leitfaden, ich kam auf diese Idee.

Die ASP.NET MVC documentation for UrlHelper zeigt, dass Url.Action eine voll qualifizierte URL zurückgibt, wenn ein Hostname und ein Protokoll übergeben werden. Ich erstellte diese Helfer, um den Hostnamen und das Protokoll zu erzwingen. Die mehrfachen Überlastungen spiegeln die Überlastung für 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

Vielleicht (?):

<%= 
    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 Core-Version 1.0.4

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

Answer 9

Vollständige Antwort mit Argumenten wäre:

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

und das wird eine absolute URL produziert