Como posso obter o URL base do meu aplicativo da web no ASP.NET MVC?

Como posso determinar rapidamente qual é o URL raiz do meu aplicativo ASP.NET MVC? Ou seja, se o IIS estiver configurado para atender meu aplicativo em http://example.com/foo/bar , eu gostaria de obter esse URL de uma maneira confiável, que não envolva a obtenção do URL atual do solicitar e desmembrá-lo de alguma maneira frágil que quebre se eu redirecionar minha ação.

O motivo pelo qual eu preciso da URL base é que esse aplicativo Web chama outro que precisa da raiz do aplicativo Web chamador para fins de retorno de chamada.

Supondo que você tenha um objeto Request disponível, você pode usar:

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

Se não estiver disponível, você poderá acessá-lo através do contexto:

var request = HttpContext.Current.Request

Portanto, nenhum dos listados aqui funcionou para mim, mas usando algumas das respostas, obtive algo funcionando:

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

Atualização para o ASP.NET Core / MVC 6:

ASP.NET Coretorna esse processo um pouco mais doloroso, especialmente se você está profundamente envolvido no seu código. Você tem 2 opções para chegar aoHttpContext

1) Passe do seu controller:

var model = new MyClass(HttpContext);

então em model:

private HttpContext currentContext;

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

2) Talvez a maneira mais limpa seja injetá-lo na sua turma, que começa com o registro dos tipos no seu Startup:

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

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

injete-o assim:

private HttpContext currentContext;

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

nos dois casos, eis a atualização para .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}";
}

Em código:

Url.Content("~/");

Sintaxe do MVC3 Razor:

@Url.Content("~/")

Talvez seja extensão ou modificação das respostas postadas aqui, mas eu uso simplesmente a seguinte linha e funciona:

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

Quando meu caminho é: http://host/iis_foldername/controller/action
então eu recebo:http://host/iis_foldername/

O seguinte snippet funciona muito bem para mim no MVC4 e não precisa de um HttpContextdisponível:

System.Web.HttpRuntime.AppDomainAppVirtualPath

O truque para confiar no IIS é que as ligações do IIS podem ser diferentes dos seus URLs públicos (WCF, estou olhando para você), especialmente com máquinas de produção com hospedagem múltipla. Eu costumo usar vetor de configuração para definir explicitamente o URL "base" para fins externos, pois isso tende a ser um pouco mais bem-sucedido do que extraí-lo do objeto Request.

Para um URL base absoluto, use isso. Funciona com HTTP e HTTPS.

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

Esta é uma conversão de uma propriedade asp.net para MVC . É um método praticamente todo de cantar e dançar.

Declare uma classe auxiliar:

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:

Para usar de um controlador:

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

Para usar em uma exibição:

@using MyTestProject.Helpers

PathHelper.FullyQualifiedApplicationPath(Request)

No MVC _Layout.cshtml:

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

É isso que usamos!

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

Isso funciona bem para mim (também com um balanceador de carga):

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

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

Especialmente se você estiver usando números de porta não padrão, usar Request.Url.Authority parecerá um bom lead no início, mas falhará em um ambiente LB.

Você pode ter um método estático que analise HttpContext.Current e decida qual URL usar (servidor de desenvolvimento ou ativo), dependendo do ID do host. O HttpContext pode até oferecer uma maneira mais fácil de fazer isso, mas esta é a primeira opção que encontrei e funciona bem.

Você pode usar o seguinte script na exibição:

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

Para o ASP.NET MVC 4, é um pouco diferente:

string url = HttpContext.Request.Url.AbsoluteUri;

Isso está funcionando no ASP .NET MVC 4 Em qualquer ação do controlador, você pode escrever: 1stline obtém o URL inteiro + Query String. 2a linha remover caminho local e consulta, último símbolo '/'. Terceira linha, adicione o símbolo '/' na última posição.

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

em html simples e ASP.NET ou ASP.NET MVC, se você estiver usando a tag:

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

Para URLs com alias de aplicação como http://example.com/appAlias/ ... Você pode tentar o seguinte:

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

Na própria página da web:

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

No javascript:

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

Isso funciona para o meu projeto MVC, espero que ajude

Coloquei isso na cabeça do meu _Layout.cshtml

 <base href="~/" />

Talvez seja uma solução melhor.

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

usando

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

Para MVC 4:

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

O seguinte funcionou solidamente para mim

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 /

Esta foi a minha solução (usando o .net core 3.1, em um controlador api):

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

Simplesmente em uma linha, obtenha o BaseUrl

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

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

Também você pode usar isso. Para as páginas de barbear, é melhor usá-lo do que os outros.

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>

adicione esta função na classe estática no projeto como classe de utilitário:

conteúdo 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;
    }
}

use este código em qualquer lugar e divirta-se:

var baseUrl = Utility.GetBaseUrl();