it-swarm.com.de

Wie wandle ich eine relative URL in eine vollständige URL um?

Dies lässt sich wahrscheinlich leichter an einem Beispiel erklären. Ich versuche eine Möglichkeit zu finden, eine relative URL zu ändern, z. "/Foo.aspx" oder "~/Foo.aspx" in eine vollständige URL, z. http: //localhost/Foo.aspx . Auf diese Weise erhalte ich beim Bereitstellen zum Testen oder Bereitstellen, wenn die Domain, unter der die Site ausgeführt wird, unterschiedlich ist, http: //test/Foo.aspx und http: // stage) /Foo.aspx .

Irgendwelche Ideen?

65
gilles27

Spielen Sie damit (geändert von hier )

public string ConvertRelativeUrlToAbsoluteUrl(string relativeUrl) {
    return string.Format("http{0}://{1}{2}",
        (Request.IsSecureConnection) ? "s" : "", 
        Request.Url.Host,
        Page.ResolveUrl(relativeUrl)
    );
}
59
Oli

Dieser ist zu Tode geprügelt worden, aber ich dachte, ich würde meine eigene Lösung posten, die meiner Meinung nach sauberer ist als viele der anderen Antworten.

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

public static string AbsoluteContent(this UrlHelper url, string path)
{
    Uri uri = new Uri(path, UriKind.RelativeOrAbsolute);

    //If the URI is not already absolute, rebuild it based on the current request.
    if (!uri.IsAbsoluteUri)
    {
        Uri requestUrl = url.RequestContext.HttpContext.Request.Url;
        UriBuilder builder = new UriBuilder(requestUrl.Scheme, requestUrl.Host, requestUrl.Port);

        builder.Path = VirtualPathUtility.ToAbsolute(path);
        uri = builder.Uri;
    }

    return uri.ToString();
}
39
Josh M.

Sie müssen nur einen neuen URI mit dem page.request.url Erstellen und erhalten dann den AbsoluteUri davon:

New System.Uri(Page.Request.Url, "Foo.aspx").AbsoluteUri
34
Marcus

Dies ist meine Hilfsfunktion, um dies zu tun

public string GetFullUrl(string relativeUrl) {
    string root = Request.Url.GetLeftPart(UriPartial.Authority);
    return root + Page.ResolveUrl("~/" + relativeUrl) ;
}
5
StocksR

Ich dachte, ich würde meinen Ansatz dazu in ASP.NET MVC mit der Klasse Uri und etwas Erweiterungsmagie teilen.

public static class UrlHelperExtensions
{
    public static string AbsolutePath(this UrlHelper urlHelper, 
                                      string relativePath)
    {
        return new Uri(urlHelper.RequestContext.HttpContext.Request.Url,
                       relativePath).ToString();
    }
}

Sie können dann einen absoluten Pfad ausgeben mit:

// gives absolute path, e.g. https://example.com/customers
Url.AbsolutePath(Url.Action("Index", "Customers"));

Es sieht ein bisschen hässlich aus, wenn ich die verschachtelten Methodenaufrufe habe, daher bevorzuge ich es, UrlHelper mit allgemeinen Aktionsmethoden zu erweitern, damit ich Folgendes tun kann:

// gives absolute path, e.g. https://example.com/customers
Url.AbsoluteAction("Index", "Customers");

oder

Url.AbsoluteAction("Details", "Customers", new{id = 123});

Die vollständige Erweiterungsklasse lautet wie folgt:

public static class UrlHelperExtensions
{
    public static string AbsolutePath(this UrlHelper urlHelper, 
                                      string relativePath)
    {
        return new Uri(urlHelper.RequestContext.HttpContext.Request.Url,
                       relativePath).ToString();
    }

    public static string AbsoluteAction(this UrlHelper urlHelper, 
                                        string actionName, 
                                        string controllerName)
    {
        return AbsolutePath(urlHelper, 
                            urlHelper.Action(actionName, controllerName));
    }

    public static string AbsoluteAction(this UrlHelper urlHelper, 
                                        string actionName, 
                                        string controllerName, 
                                        object routeValues)
    {
        return AbsolutePath(urlHelper, 
                            urlHelper.Action(actionName, 
                                             controllerName, routeValues));
    }
}
4
stucampbell

Verwenden Sie die .NET Uri-Klasse, um Ihren relativen Pfad und den Hostnamen zu kombinieren.
http://msdn.Microsoft.com/en-us/library/system.uri.aspx

2
user19264

Dies ist die Hilfsfunktion, die ich für die Konvertierung erstellt habe.

//"~/SomeFolder/SomePage.aspx"
public static string GetFullURL(string relativePath)
{
   string sRelative=Page.ResolveUrl(relativePath);
   string sAbsolute=Request.Url.AbsoluteUri.Replace(Request.Url.PathAndQuery,sRelative);
   return sAbsolute;
}
2
Joshua Grippo

In ASP.NET MVC können Sie die Überladungen von HtmlHelper oder UrlHelper verwenden, die die Werte von protocol annehmen. oder Host Parameter. Wenn einer dieser Parameter nicht leer ist, generieren die Helfer eine absolute URL. Dies ist eine Erweiterungsmethode, die ich verwende:

public static MvcHtmlString ActionLinkAbsolute<TViewModel>(
    this HtmlHelper<TViewModel> html, 
    string linkText, 
    string actionName, 
    string controllerName, 
    object routeValues = null,
    object htmlAttributes = null)
{
    var request = html.ViewContext.HttpContext.Request;
    var url = new UriBuilder(request.Url);
    return html.ActionLink(linkText, actionName, controllerName, url.Scheme, url.Host, null, routeValues, htmlAttributes);
}

Und verwenden Sie es aus der Sicht eines Rasiermessers, z.

 @Html.ActionLinkAbsolute("Click here", "Action", "Controller", new { id = Model.Id }) 
1
Carl G

Einfach:

url = new Uri(baseUri, url);
1
Menelaos Vergis

Hier ist ein Ansatz. Dabei ist es egal, ob die Zeichenfolge relativ oder absolut ist, Sie müssen jedoch eine baseUri angeben, damit sie verwendet werden kann.

    /// <summary>
    /// This function turns arbitrary strings containing a 
    /// URI into an appropriate absolute URI.  
    /// </summary>
    /// <param name="input">A relative or absolute URI (as a string)</param>
    /// <param name="baseUri">The base URI to use if the input parameter is relative.</param>
    /// <returns>An absolute URI</returns>
    public static Uri MakeFullUri(string input, Uri baseUri)
    {
        var tmp = new Uri(input, UriKind.RelativeOrAbsolute);
        //if it's absolute, return that
        if (tmp.IsAbsoluteUri)
        {
            return tmp;
        }
        // build relative on top of the base one instead
        return new Uri(baseUri, tmp);
    }

In einem ASP.NET-Kontext können Sie dies tun:

Uri baseUri = new Uri("http://yahoo.com/folder");
Uri newUri = MakeFullUri("/some/path?abcd=123", baseUri);
//
//newUri will contain http://yahoo.com/some/path?abcd=123
//
Uri newUri2 = MakeFullUri("some/path?abcd=123", baseUri);
//
//newUri2 will contain http://yahoo.com/folder/some/path?abcd=123
//
Uri newUri3 = MakeFullUri("http://google.com", baseUri);
//
//newUri3 will contain http://google.com, and baseUri is not used at all.
//
0
Xavier J

Geändert von anderen Antworten für die Arbeit mit localhost und anderen Ports ... ich benutze zum Beispiel. E-Mail-Links. Sie können von jedem Teil der App aus aufrufen, nicht nur auf einer Seite oder in einer Benutzersteuerung. Ich habe dies in "Global" eingestellt, damit HttpContext.Current.Request nicht als Parameter übergeben werden muss

            /// <summary>
            ///  Return full URL from virtual relative path like ~/dir/subir/file.html
            ///  usefull in ex. external links
            /// </summary>
            /// <param name="rootVirtualPath"></param>
            /// <returns></returns>
            public static string GetAbsoluteFullURLFromRootVirtualPath(string rootVirtualPath)
            {

                return string.Format("http{0}://{1}{2}{3}",
                    (HttpContext.Current.Request.IsSecureConnection) ? "s" : ""
                    , HttpContext.Current.Request.Url.Host
                    , (HttpContext.Current.Request.Url.IsDefaultPort) ? "" : ":" + HttpContext.Current.Request.Url.Port
                    , VirtualPathUtility.ToAbsolute(rootVirtualPath)
                    );

            }

Alte Frage, aber ich dachte, ich würde sie beantworten, da viele der Antworten unvollständig sind.

public static string ResolveFullUrl(this System.Web.UI.Page page, string relativeUrl)
{
    if (string.IsNullOrEmpty(relativeUrl))
        return relativeUrl;

    if (relativeUrl.StartsWith("/"))
        relativeUrl = relativeUrl.Insert(0, "~");
    if (!relativeUrl.StartsWith("~/"))
        relativeUrl = relativeUrl.Insert(0, "~/");

    return $"{page.Request.Url.Scheme}{Uri.SchemeDelimiter}{page.Request.Url.Authority}{VirtualPathUtility.ToAbsolute(relativeUrl)}";
}

Dies funktioniert wie ResolveUrl und ResolveClientUrl für Webformulare als Erweiterung von off Page. Sie können es jederzeit in eine HttpResponse-Erweiterung konvertieren, wenn Sie es in einer Nicht-Webforms-Umgebung verwenden möchten oder müssen. Es verarbeitet sowohl http als auch https auf Standard- und Nicht-Standard-Ports und wenn eine Benutzername/Kennwort-Komponente vorhanden ist. Es werden auch keine fest codierten Zeichenfolgen verwendet (nämlich: //).

0
Robert McKee