Comment puis-je obtenir L'URL de base de mon webapp ASP.NET MVC?

donc aucun de ceux énumérés ici n'a travaillé pour moi, mais en utilisant quelques-unes des réponses, j'ai obtenu quelque chose de travail:

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 Core rend ce processus un peu plus douloureuses, surtout si vous êtes profondément dans votre code. Vous avez 2 options pour obtenir à la HttpContext

1) Passez-le de votre controller :

var model = new MyClass(HttpContext);

puis dans model :

private HttpContext currentContext;

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

2) peut-être que le moyen le plus propre est de l'injecter dans votre classe, 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>();
}

alors faites-le injecter pour vous comme ceci:

private HttpContext currentContext;

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

dans tous les 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 Le Code:

Url.Content("~/");

MVC3 Razor syntaxe:

@Url.Content("~/")

peut-être est-ce une extension ou une modification des réponses posté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

puis je reçois: http://host/iis_foldername/

le truc avec la confiance sur IIS est que les fixations IIS peuvent être différentes de vos URLs publiques (WCF je vous regarde), surtout avec les machines de production multi-homed. J'ai tendance à me diriger vers l'utilisation de 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 de la requête.

l'extrait suivant fonctionne bien pour moi dans MVC4, et n'a pas besoin d'un HttpContext disponible:

System.Web.HttpRuntime.AppDomainAppVirtualPath

pour une URL de base absolue utilisez ceci. Fonctionne avec les protocoles HTTP et HTTPS.

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

il s'agit d'une conversion d'un asp.net propriété à MVC . C'est à peu près tout en chantant tout en dansant la méthode de l'url racine.

Déclarer une classe helper:

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

Utilisation:

À utiliser à partir d'un contrôleur:

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

à 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 très bien pour moi (aussi 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, en utilisant Request.URL.L'autorité apparaît d'abord comme une bonne avance, mais elle échoue dans un environnement de LB.

vous pouvez avoir une méthode statique qui regarde HttpContext.Courant et décide de L'URL à utiliser (développement ou serveur en direct) en fonction de l'ID de l'hôte. HttpContext pourrait même offrir un moyen plus simple de le faire, mais c'est la première option que j'ai trouvée et ça fonctionne très 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;

ça marche dans ASP .NET MVC 4 Dans n'importe quelle action de controller vous pouvez écrire: 1stline obtient la totalité de l'url+chaîne de requête. Deuxième ligne supprimer le chemin local et la requête ,dernier symbole'/'. 3e ligne, ajouter 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 tag:

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

pour MVC 4:

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

c'est Peut-être une meilleure solution.

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

utilisant

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

Pour url avec application alias 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;
}

ça marche pour mon projet MVC, j'espère que ça aide

j'ai mis ceci dans la tête de mon _Layout.CSHTML

 <base href="~/" />