¿Cómo puedo obtener la URL base de mi aplicación web en ASP.NET MVC?

¿Cómo puedo determinar rápidamente cuál es la URL raíz para mi aplicación ASP.NET MVC? Es decir, si IIS está configurado para servir mi aplicación en http://example.com/foo/bar , entonces me gustaría poder obtener esa URL de manera confiable que no implique obtener la URL actual del solicitar y cortarlo de una manera frágil que se rompe si cambio la ruta de mi acción.

La razón por la que necesito la URL base es que esta aplicación web llama a otra que necesita la raíz de la aplicación web de la persona que llama para fines de devolución de llamada.

Suponiendo que tiene un objeto Solicitud disponible, puede usar:

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

Si no está disponible, puede acceder a él a través del contexto:

var request = HttpContext.Current.Request

Así que ninguno de los enumerados aquí funcionó para mí, pero usando algunas de las respuestas, obtuve algo que funciona:

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

Actualización para ASP.NET Core / MVC 6:

ASP.NET Corehace que este proceso sea un poco más doloroso, especialmente si eres profundo en tu código. Tienes 2 opciones para llegar alHttpContext

1) Pásalo desde tu controller:

var model = new MyClass(HttpContext);

luego en model:

private HttpContext currentContext;

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

2) Quizás la forma más limpia es inyectarlo en su clase, que comienza con el registro de los tipos en su Startup:

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

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

entonces haz que te lo inyecten así:

private HttpContext currentContext;

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

en cualquier caso, aquí está la actualización 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}";
}

En codigo:

Url.Content("~/");

MVC3 Razor Sintaxis:

@Url.Content("~/")

Tal vez sea una extensión o modificación de las respuestas publicadas aquí, pero uso simplemente la siguiente línea y funciona:

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

Cuando mi camino es: http://host/iis_foldername/controller/action
entonces recibo:http://host/iis_foldername/

El siguiente fragmento me funciona muy bien en MVC4, y no necesita un HttpContextdisponible:

System.Web.HttpRuntime.AppDomainAppVirtualPath

El truco para confiar en IIS es que los enlaces de IIS pueden ser diferentes de sus URL públicas (WCF lo estoy mirando a usted), especialmente con máquinas de producción multi-homed. Tiendo a vectorizar hacia el uso de la configuración para definir explícitamente la url "base" para fines externos, ya que tiende a ser un poco más exitosa que extraerla del objeto Request.

Para una URL base absoluta, use esto. Funciona con HTTP y HTTPS.

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

Esta es una conversión de una propiedad asp.net a MVC . Es un método de url de raíz que canta y baila.

Declarar una clase 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 desde un controlador:

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

Para usar en una vista:

@using MyTestProject.Helpers

PathHelper.FullyQualifiedApplicationPath(Request)

En MVC _Layout.cshtml:

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

¡Eso es lo 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("~/");
        }
}

Esto funciona bien para mí (también con un equilibrador de carga):

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

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

Especialmente si está utilizando números de puerto no estándar, el uso de Request.Url.Authority aparece como un buen lead al principio, pero falla en un entorno LB.

Podría tener un método estático que examine HttpContext.Current y decida qué URL usar (servidor de desarrollo o en vivo) según la ID del host. HttpContext podría incluso ofrecer una forma más fácil de hacerlo, pero esta es la primera opción que encontré y funciona bien.

Puede usar el siguiente script a la vista:

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

Para ASP.NET MVC 4 es un poco diferente:

string url = HttpContext.Request.Url.AbsoluteUri;

Esto está funcionando en ASP .NET MVC 4. En cualquier acción del controlador puede escribir: 1stline obtiene toda la url + Cadena de consulta. La segunda línea elimina la ruta local y la consulta, el último símbolo '/'. La tercera línea agrega el símbolo '/' en la última posición.

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

en html simple y ASP.NET o ASP.NET MVC si está usando la etiqueta:

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

Para url con alias de aplicación como http://example.com/appAlias/ ... Puedes probar esto:

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

En la página web en sí:

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

En el javascript:

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

Esto funciona para mi proyecto MVC, espero que ayude

Puse esto en la cabeza de mi _Layout.cshtml

 <base href="~/" />

Quizás sea una mejor solución.

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

utilizando

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

Lo siguiente funcionó sólidamente para mí

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

- salida http: // localhost: 49626 / TEST /

Esta fue mi solución (usando .net core 3.1, en un controlador api):

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

Simplemente en una línea obtenga BaseUrl

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

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

También puedes usar esto. Para las páginas de afeitar, es mejor usarlo que los demás.

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>

agregue esta función en clase estática en proyecto como clase de utilidad:

contenido de 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 este código en cualquier lugar y disfrútalo:

var baseUrl = Utility.GetBaseUrl();