Comment puis-je obtenir l'URL de base de mon application Web dans ASP.NET MVC?

Comment puis-je déterminer rapidement l'URL racine de mon application ASP.NET MVC? C'est-à-dire, si IIS est configuré pour servir mon application sur http://example.com/foo/bar , alors j'aimerais pouvoir obtenir cette URL de manière fiable, ce qui n'implique pas d'obtenir l'URL actuelle à partir du demander et le découper d'une manière fragile qui se brise si je réachemine mon action.

La raison pour laquelle j'ai besoin de l'URL de base est que cette application Web en appelle une autre qui a besoin de la racine de l'application Web de l'appelant à des fins de rappel.

En supposant que vous disposez d'un objet Request, vous pouvez utiliser:

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

S'il n'est pas disponible, vous pouvez y accéder via le contexte:

var request = HttpContext.Current.Request

Donc, aucune de celles énumérées ici n'a fonctionné pour moi, mais en utilisant quelques-unes des réponses, j'ai obtenu que quelque chose fonctionne:

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

Mise à jour pour ASP.NET Core / MVC 6:

ASP.NET Corerend ce processus un peu plus pénible, surtout si vous êtes au fond de votre code. Vous avez 2 options pour accéder auHttpContext

1) Remettez-le depuis votre controller:

var model = new MyClass(HttpContext);

puis dans model:

private HttpContext currentContext;

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

2) Peut-être que la façon la plus propre est de l'injecter dans votre classe, ce qui commence par enregistrer les types dans votre Startup:

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

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

puis faites-le injecter pour vous comme ceci:

private HttpContext currentContext;

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

dans les deux cas, voici la mise à jour pour .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}";
}

Dans du code:

Url.Content("~/");

Syntaxe du rasoir MVC3:

@Url.Content("~/")

C'est peut-être une extension ou une modification des réponses publiées ici, mais j'utilise simplement la ligne suivante et cela fonctionne:

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

Quand mon chemin est: http://host/iis_foldername/controller/action
alors je reçois:http://host/iis_foldername/

L'extrait suivant fonctionne bien pour moi dans MVC4 et n'a pas besoin d'un HttpContextdisponible:

System.Web.HttpRuntime.AppDomainAppVirtualPath

L'astuce pour s'appuyer sur IIS est que les liaisons IIS peuvent être différentes de vos URL publiques (WCF, je vous regarde), en particulier avec les machines de production multi-hébergées. J'ai tendance à utiliser la configuration pour définir explicitement l'url "de base" à des fins externes car cela a tendance à être un peu plus efficace que de l'extraire de l'objet Request.

Pour une URL de base absolue, utilisez ceci. Fonctionne avec HTTP et HTTPS.

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

Il s'agit d'une conversion d'une propriété asp.net en MVC . C'est une méthode à peu près tout en chantant et en dansant pour obtenir l'URL racine.

Déclarez une classe auxiliaire:

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

Usage:

Pour utiliser à partir d'un contrôleur:

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

Pour utiliser dans une vue:

@using MyTestProject.Helpers

PathHelper.FullyQualifiedApplicationPath(Request)

Dans MVC _Layout.cshtml:

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

C'est ce que nous utilisons!

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

Cela fonctionne bien pour moi (également avec un équilibreur de charge):

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

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

Surtout si vous utilisez des numéros de port non standard, l'utilisation de Request.Url.Authority apparaît comme une bonne piste au début, mais échoue dans un environnement LB.

Vous pouvez avoir une méthode statique qui examine HttpContext.Current et décide quelle URL utiliser (développement ou serveur en direct) en fonction de l'ID d'hôte. HttpContext pourrait même offrir un moyen plus facile de le faire, mais c'est la première option que j'ai trouvée et cela fonctionne bien.

Vous pouvez utiliser le script suivant en vue:

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

Pour ASP.NET MVC 4, c'est un peu différent:

string url = HttpContext.Request.Url.AbsoluteUri;

Cela fonctionne dans ASP .NET MVC 4 Dans n'importe quelle action de contrôleur, vous pouvez écrire: 1stline obtient l'url entière + la chaîne de requête. La deuxième ligne supprime le chemin d'accès local et la requête, dernier symbole '/'. 3ème ligne, ajoutez le symbole «/» à la dernière position.

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

en html simple et ASP.NET ou ASP.NET MVC si vous utilisez la balise:

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

Pour une URL avec un alias d'application comme http://example.com/appAlias/ ... Vous pouvez essayer ceci:

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

Sur la page Web elle-même:

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

Dans le javascript:

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

Cela fonctionne pour mon projet MVC, j'espère que cela aide

Je mets ça dans la tête de mon _Layout.cshtml

 <base href="~/" />

C'est peut-être une meilleure solution.

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

en utilisant

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

Pour MVC 4:

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

Ce qui suit a fonctionné solidement pour moi

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

--sortie http: // localhost: 49626 / TEST /

C'était ma solution (en utilisant .net core 3.1, dans un contrôleur api):

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

Obtenez simplement BaseUrl en une seule ligne

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

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

Vous pouvez également l'utiliser. Pour les pages rasoir, il vaut mieux l'utiliser que les autres.

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>

ajoutez cette fonction dans une classe statique dans un projet comme une classe utilitaire:

Contenu d' utilitaire.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;
    }
}

utilisez ce code n'importe où et profitez-en:

var baseUrl = Utility.GetBaseUrl();