Wie kann ich die Basis-URL meiner Webanwendung in ASP.NET MVC abrufen?

Wie kann ich schnell feststellen, wie die Stamm-URL für meine ASP.NET MVC-Anwendung lautet? Das heißt, wenn IIS so eingestellt ist, dass es meine Anwendung unter http://example.com/foo/bar bereitstellt , möchte ich in der Lage sein, diese URL auf zuverlässige Weise abzurufen, ohne die aktuelle URL von der abzurufen fordern Sie es an und zerhacken Sie es auf eine fragile Art und Weise, die kaputt geht, wenn ich meine Aktion umleitung.

Der Grund, warum ich die Basis-URL benötige, ist, dass diese Webanwendung eine andere aufruft, die den Stamm der Anrufer-Webanwendung für Rückrufzwecke benötigt.

Angenommen, Sie haben ein Anforderungsobjekt zur Verfügung, können Sie Folgendes verwenden:

string.Format("{0}://{1}{2}", Request.Url.Scheme, Request.Url.Authority, Url.Content("~"));

Wenn es nicht verfügbar ist, können Sie es über den Kontext aufrufen:

var request = HttpContext.Current.Request

Also hat keiner der hier aufgeführten für mich funktioniert, aber mit ein paar der Antworten habe ich etwas zum Laufen gebracht:

public string GetBaseUrl()
{
    var request = HttpContext.Current.Request;
    var appUrl = HttpRuntime.AppDomainAppVirtualPath;

    if (appUrl != "/") 
        appUrl = "/" + appUrl;

    var baseUrl = string.Format("{0}://{1}{2}", request.Url.Scheme, request.Url.Authority, appUrl);

    return baseUrl;
}

Update für ASP.NET Core / MVC 6:

ASP.NET Coremacht diesen Prozess etwas schmerzhafter, besonders wenn Sie tief in Ihrem Code sind. Sie haben 2 Möglichkeiten, um an derHttpContext

1) Geben Sie es von Ihrem controller:

var model = new MyClass(HttpContext);

dann in model:

private HttpContext currentContext;

public MyClass(HttpContext currentContext)
{
    this.currentContext = currentContext;
}

2) Vielleicht ist der sauberere Weg, es in Ihre Klasse zu injizieren, was mit der Registrierung der Typen in Ihrer Klasse beginnt Startup:

public void ConfigureServices(IServiceCollection services)
{
    // Add framework services.
    services.AddMvc();

    services.AddTransient<MyClass, MyClass>();
    services.TryAddSingleton<IHttpContextAccessor, HttpContextAccessor>();
}

dann lass es dir so spritzen:

private HttpContext currentContext;

public MyClass(IHttpContextAccessor httpContextAccessor)
{
    currentContext = httpContextAccessor.HttpContext;
}

In beiden Fällen ist hier die Aktualisierung für .NET Core GetBaseUrl():

public string GetBaseUrl()
{
    var request = currentContext.Request;

    var host = request.Host.ToUriComponent();

    var pathBase = request.PathBase.ToUriComponent();

    return $"{request.Scheme}://{host}{pathBase}";
}

In Code:

Url.Content("~/");

MVC3 Razor Syntax:

@Url.Content("~/")

Vielleicht ist es eine Erweiterung oder Änderung der hier veröffentlichten Antworten, aber ich benutze einfach die folgende Zeile und es funktioniert:

Request.Url.GetLeftPart(UriPartial.Authority) + Url.Content("~")

Wenn mein Weg ist: http://host/iis_foldername/controller/action
dann erhalte ich:http://host/iis_foldername/

Das folgende Snippet funktioniert gut für mich in MVC4 und benötigt kein HttpContextverfügbares:

System.Web.HttpRuntime.AppDomainAppVirtualPath

Der Trick beim Verlassen auf IIS besteht darin, dass sich IIS-Bindungen von Ihren öffentlichen URLs (WCF, die ich Ihnen ansehe) unterscheiden können, insbesondere bei Produktionsmaschinen mit mehreren Standorten. Ich tendiere dazu, die Konfiguration zu verwenden, um die "Basis" -URL explizit für externe Zwecke zu definieren, da dies tendenziell etwas erfolgreicher ist als das Extrahieren aus dem Request-Objekt.

Verwenden Sie dies für eine absolute Basis-URL. Funktioniert sowohl mit HTTP als auch mit HTTPS.

new Uri(Request.Url, Url.Content("~"))

Dies ist eine Konvertierung einer asp.net-Eigenschaft in MVC . Es ist so ziemlich alles, was singt und tanzt.

Deklarieren Sie eine Helferklasse:

namespace MyTestProject.Helpers
{
    using System.Web;

    public static class PathHelper
    {
        public static string FullyQualifiedApplicationPath(HttpRequestBase httpRequestBase)
        {
            string appPath = string.Empty;

            if (httpRequestBase != null)
            {
                //Formatting the fully qualified website url/name
                appPath = string.Format("{0}://{1}{2}{3}",
                            httpRequestBase.Url.Scheme,
                            httpRequestBase.Url.Host,
                            httpRequestBase.Url.Port == 80 ? string.Empty : ":" + httpRequestBase.Url.Port,
                            httpRequestBase.ApplicationPath);
            }

            if (!appPath.EndsWith("/"))
            {
                appPath += "/";
            }

            return appPath;
        }
    }
}

Verwendungszweck:

So verwenden Sie eine Steuerung:

PathHelper.FullyQualifiedApplicationPath(ControllerContext.RequestContext.HttpContext.Request)

So verwenden Sie eine Ansicht:

@using MyTestProject.Helpers

PathHelper.FullyQualifiedApplicationPath(Request)

In MVC _Layout.cshtml:

<base href="@Request.GetBaseUrl()" />

Das verwenden wir!

public static class ExtensionMethods
{
public static string GetBaseUrl(this HttpRequestBase request)
        {
          if (request.Url == (Uri) null)
            return string.Empty;
          else
            return request.Url.Scheme + "://" + request.Url.Authority + VirtualPathUtility.ToAbsolute("~/");
        }
}

Dies funktioniert gut für mich (auch mit einem Load Balancer):

@{
    var urlHelper = new UrlHelper(Html.ViewContext.RequestContext);
    var baseurl = urlHelper.Content(“~”);
}

<script>
    var base_url = "@baseurl";
</script>

Insbesondere wenn Sie nicht standardmäßige Portnummern verwenden, erscheint die Verwendung von Request.Url.Authority zunächst als guter Hinweis, schlägt jedoch in einer LB-Umgebung fehl.

Sie könnten eine statische Methode haben, die HttpContext.Current betrachtet und abhängig von der Host-ID entscheidet, welche URL (Entwicklungs- oder Live-Server) verwendet werden soll. HttpContext bietet vielleicht sogar eine einfachere Möglichkeit, dies zu tun, aber dies ist die erste Option, die ich gefunden habe, und sie funktioniert einwandfrei.

Sie können das folgende Skript in der Ansicht verwenden:

<script type="text/javascript">
    var BASE_URL = '<%= ResolveUrl("~/") %>';
</script>

Für ASP.NET MVC 4 ist das etwas anders:

string url = HttpContext.Request.Url.AbsoluteUri;

Dies funktioniert in ASP .NET MVC 4 In jeder Controller-Aktion, die Sie schreiben können: 1stline erhält die gesamte URL + Abfragezeichenfolge. 2. Zeile lokalen Pfad & Abfrage entfernen, letztes '/' Symbol. 3. Zeile '/' Symbol an letzter Stelle hinzufügen.

Uri url = System.Web.HttpContext.Current.Request.Url;
string UrlLink = url.OriginalString.Replace(url.PathAndQuery,"");
UrlLink = String.Concat(UrlLink,"/" );

in einfachem HTML und ASP.NET oder ASP.NET MVC, wenn Sie Tag verwenden:

<a href="~/#about">About us</a>

Für URLs mit Anwendungsalias wie http://example.com/appAlias/ ... Sie können dies versuchen:

var req = HttpContext.Current.Request;
string baseUrl = string.Format("{0}://{1}/{2}", req.Url.Scheme, req.Url.Authority, req.ApplicationPath);

Auf der Webseite selbst:

<input type="hidden" id="basePath" value="@string.Format("{0}://{1}{2}",
  HttpContext.Current.Request.Url.Scheme,
  HttpContext.Current.Request.Url.Authority,
  Url.Content("~"))" />

Im Javascript:

function getReportFormGeneratorPath() {
  var formPath = $('#reportForm').attr('action');
  var newPath = $("#basePath").val() + formPath;
  return newPath;
}

Das funktioniert für mein MVC-Projekt, hoffe es hilft

Ich habe dies in den Kopf meiner _Layout.cshtml eingefügt

 <base href="~/" />

Vielleicht ist es eine bessere Lösung.

@{
   var baseUrl = @Request.Host("/");
}

mit

<a href="@baseUrl" class="link">Base URL</a>

Für MVC 4:

String.Format("{0}://{1}{2}", Url.Request.RequestUri.Scheme, Url.Request.RequestUri.Authority, ControllerContext.Configuration.VirtualPathRoot);

Das Folgende hat für mich solide funktioniert

var request = HttpContext.Request;
                        var appUrl = System.Web.HttpRuntime.AppDomainAppVirtualPath;

                        if (appUrl != "/")
                            appUrl = "/" + appUrl + "/";

                        var newUrl = string.Format("{0}://{1}{2}{3}/{4}", request.Url.Scheme, request.UrlReferrer.Host, appUrl, "Controller", "Action");

@{
    var baseurl = Request.Url.Scheme + "://" + Request.Url.Host + ":" + Request.Url.Port + Url.Content("~");
}
@baseurl

--output http: // localhost: 49626 / TEST /

Dies war meine Lösung (mit .net Core 3.1 in einem API-Controller):

string baseUrl = $"{Request.Scheme}://{Request.Headers.Where(h => h.Key == "Host").First().Value}";

Einfach in einer Zeile BaseUrl erhalten

string baseUrl = new Uri(Request.Url, Url.Content("~")).AbsoluteUri;

//output example: https://stackoverflow.com

Auch Sie können dies verwenden. Für die Rasierseiten ist es besser, sie zu verwenden als die anderen.

https://ml-software.ch/posts/getting-the-base-url-for-an-asp-net-core-mvc-web-application-in-your-static-javascript-files

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <base href='@Url.AbsoluteContent("~/")'>
    <title>@ViewBag.Title - ASP.NET Core Web Application</title>
    <!-- ... -->
</head>
<body>

Fügen Sie diese Funktion in der statischen Klasse in einem Projekt wie der Utility-Klasse hinzu:

Dienstprogramm.cs Inhalt:

public static class Utility
{
    public static string GetBaseUrl()
    {
        var request = HttpContext.Current.Request;
        var urlHelper = new UrlHelper(request.RequestContext);
        var baseUrl = $"{request.Url.Scheme}://{request.Url.Authority}{urlHelper.Content("~")}";
        return baseUrl;
    }
}

Verwenden Sie diesen Code überall und genießen Sie ihn:

var baseUrl = Utility.GetBaseUrl();