Come posso ottenere l'URL di base della mia webapp in ASP.NET MVC?

Come posso determinare rapidamente qual è l'URL radice per la mia applicazione MVC ASP.NET? Vale a dire, se IIS è impostato per servire la mia applicazione su http://example.com/foo/bar , mi piacerebbe essere in grado di ottenere quell'URL in un modo affidabile che non implichi ottenere l'URL corrente dal richiesta e troncandolo in qualche modo fragile che si rompe se reindirizzo la mia azione.

Il motivo per cui ho bisogno dell'URL di base è che questa applicazione Web ne chiama un'altra che ha bisogno del root per l'applicazione Web del chiamante ai fini della richiamata.

Supponendo che tu abbia un oggetto Request disponibile, puoi usare:

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

Se non è disponibile, puoi accedervi tramite il contesto:

var request = HttpContext.Current.Request

Quindi nessuno di quelli elencati qui ha funzionato per me, ma usando alcune delle risposte, ho ottenuto qualcosa che funzionava:

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

Aggiornamento per ASP.NET Core / MVC 6:

ASP.NET Corerende questo processo un po 'più doloroso, specialmente se sei profondamente nel tuo codice. Hai 2 opzioni per accedere alHttpContext

1) Passalo dal tuo controller:

var model = new MyClass(HttpContext);

quindi in model:

private HttpContext currentContext;

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

2) Forse il modo più pulito è iniettarlo nella tua classe, che inizia con la registrazione dei tipi nella tua Startup:

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

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

allora ti viene iniettato in questo modo:

private HttpContext currentContext;

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

in entrambi i casi, ecco l'aggiornamento per .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}";
}

Nel codice:

Url.Content("~/");

Sintassi del rasoio MVC3:

@Url.Content("~/")

Forse è l'estensione o la modifica delle risposte pubblicate qui ma io uso semplicemente la seguente riga e funziona:

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

Quando il mio percorso è: http://host/iis_foldername/controller/action
quindi ricevo:http://host/iis_foldername/

Il seguente frammento funziona bene per me in MVC4 e non ha bisogno di un HttpContextdisponibile:

System.Web.HttpRuntime.AppDomainAppVirtualPath

Il trucco di fare affidamento su IIS è che i collegamenti IIS possono essere diversi dai tuoi URL pubblici (WCF ti sto guardando), specialmente con macchine di produzione multi-homed. Tendo a utilizzare la configurazione per definire esplicitamente l'URL "base" per scopi esterni, poiché tende ad avere un po 'più successo rispetto all'estrazione dall'oggetto Request.

Per un URL di base assoluto utilizzare questo. Funziona con HTTP e HTTPS.

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

Questa è una conversione di una proprietà asp.net in MVC . È praticamente tutto cantando tutto ballando ottenere il metodo url di root.

Dichiarare una classe di supporto:

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

Uso:

Per utilizzare da un controller:

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

Per utilizzare in una vista:

@using MyTestProject.Helpers

PathHelper.FullyQualifiedApplicationPath(Request)

In MVC _Layout.cshtml:

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

Questo è quello che usiamo!

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("~/");
        }
}

Questo funziona bene per me (anche con un bilanciamento del carico):

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

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

Soprattutto se si utilizzano numeri di porta non standard, l'utilizzo di Request.Url.Authority appare inizialmente come un buon vantaggio, ma non riesce in un ambiente LB.

Potresti avere un metodo statico che esamina HttpContext.Current e decide quale URL utilizzare (server di sviluppo o live) in base all'ID host. HttpContext potrebbe anche offrire un modo più semplice per farlo, ma questa è la prima opzione che ho trovato e funziona bene.

È possibile utilizzare il seguente script in vista:

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

Per ASP.NET MVC 4 è un po 'diverso:

string url = HttpContext.Request.Url.AbsoluteUri;

Questo funziona in ASP .NET MVC 4 In qualsiasi azione del controller puoi scrivere: 1stline ottiene l'intero url + Query String. 2a riga rimuove percorso e query locali, ultimo simbolo '/'. La terza riga aggiunge il simbolo '/' all'ultima posizione.

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

in html semplice e ASP.NET o ASP.NET MVC se si utilizza il tag:

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

Per l'URL con alias di applicazione come http://example.com/appAlias/ ... Puoi provare questo:

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

Sulla stessa pagina Web:

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

Nel javascript:

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

Questo funziona per il mio progetto MVC, spero che sia d'aiuto

L'ho messo nella testa del mio _Layout.cshtml

 <base href="~/" />

Forse è una soluzione migliore.

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

utilizzando

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

Per MVC 4:

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

Quanto segue ha funzionato perfettamente per me

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 /

Questa era la mia soluzione (utilizzando .net core 3.1, in un controller api):

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

Semplicemente in una riga ottieni BaseUrl

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

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

Inoltre puoi usare questo. Per le pagine del rasoio, è meglio usarlo rispetto alle altre.

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>

aggiungi questa funzione nella classe statica nel progetto come la classe di utilità:

contenuto utility.cs :

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

usa questo codice ovunque e divertiti:

var baseUrl = Utility.GetBaseUrl();