CODEWITHSUNDEEP
.netasp.netasp.net-mvciis
Benjamin Pollack
Benjamin Pollack

Reputation: 28402

How can I get my webapp's base URL in ASP.NET MVC?

How can I quickly determine what the root URL is for my ASP.NET MVC application? I.e., if IIS is set to serve my application at http://example.com/foo/bar, then I'd like to be able to get that URL in a reliable way that doesn't involve getting the current URL from the request and chopping it up in some fragile way that breaks if I re-route my action.

The reason that I need the base URL is that this web application calls another one that needs the root to the caller web application for callback purposes.

Upvotes: 344

Views: 395913

Answers (27)

Krzysztof Madej
Krzysztof Madej

Reputation: 40533

In .net core 3.1 I used this approach:

$"{Request.Scheme}://{Request.Host}{Url.Content("~/")}"

Upvotes: 4

Barnebyte
Barnebyte

Reputation: 161

This was my solution (using .net core 3.1, in an api controller):

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

Upvotes: 3

D.L.MAN
D.L.MAN

Reputation: 1093

add this function in static class in project like utility class:

utility.cs content:

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 this code any where and enjoy it:

var baseUrl = Utility.GetBaseUrl();

Upvotes: 2

Jackdon Wang
Jackdon Wang

Reputation: 407

@{
    var baseurl = Request.Url.Scheme + "://" + Request.Url.Host + ":" + Request.Url.Port + Url.Content("~");
}
@baseurl

--output http://localhost:49626/TEST/

Upvotes: 2

Mahmut EFE
Mahmut EFE

Reputation: 5248

Also you can use this. For the razor pages, it is better to use it than the others.

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>

Upvotes: 1

Zahid Tanveer
Zahid Tanveer

Reputation: 60

Simply in one line get BaseUrl

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

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

Upvotes: 1

venu
venu

Reputation: 147

The following worked solidly for 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");

Upvotes: 1

ms_devel
ms_devel

Reputation: 492

Maybe it is a better solution.

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

using

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

Upvotes: 2

Andrew Day
Andrew Day

Reputation: 607

On the webpage itself:

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

In the javascript:

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

This works for my MVC project, hope it helps

Upvotes: 3

cineam mispelt
cineam mispelt

Reputation: 423

I put this in the head of my _Layout.cshtml

 <base href="~/" />

Upvotes: 3

Serj Sagan
Serj Sagan

Reputation: 30178

So none of the ones listed here worked for me, but using a few of the answers, I got something working:

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

Update for ASP.NET Core / MVC 6:

ASP.NET Core makes this process a bit more painful, especially if you are deep in your code. You have 2 options to get at the HttpContext

1) Pass it in from your controller:

var model = new MyClass(HttpContext);

then in model:

private HttpContext currentContext;

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

2) Perhaps the cleaner way is to inject it into your class, which starts with registering the types in your Startup:

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

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

then have it injected for you like this:

private HttpContext currentContext;

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

in either case, here is the updated for .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}";
}

Upvotes: 142

Jacek Gzel
Jacek Gzel

Reputation: 480

For url with aplication alias like http://example.com/appAlias/... You can try this:

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

Upvotes: 3

Bronek
Bronek

Reputation: 11235

Maybe it is extension or modification of the answers posted here but I use simply the following line and it works:

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

When my path is: http://host/iis_foldername/controller/action
then I receive : http://host/iis_foldername/

Upvotes: 46

Ravi Anand
Ravi Anand

Reputation: 5514

in simple html and ASP.NET or ASP.NET MVC if you are using tag:

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

Upvotes: 3

Muhammad Ashikuzzaman
Muhammad Ashikuzzaman

Reputation: 3143

This is working in ASP .NET MVC 4 In any controller action you can write: 1stline gets the whole url+Query String. 2nd line remove local path & query ,last '/' symbol. 3rd line add '/' symbol at last position.

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

Upvotes: 3

user666142
user666142

Reputation: 299

The following snippet works nicely for me in MVC4, and doesn't need an HttpContext available:

System.Web.HttpRuntime.AppDomainAppVirtualPath

Upvotes: 29

BLoB
BLoB

Reputation: 9725

This is a conversion of an asp.net property to MVC . It's a pretty much all singing all dancing get root url method.

Declare a helper class:

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:

To use from a controller:

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

To use in a view:

@using MyTestProject.Helpers

PathHelper.FullyQualifiedApplicationPath(Request)

Upvotes: 16

katesky8
katesky8

Reputation: 582

In MVC _Layout.cshtml:

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

Thats what we use!

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

Upvotes: 12

Remigijus Pankevičius
Remigijus Pankevičius

Reputation: 1132

For MVC 4:

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

Upvotes: 2

arni
arni

Reputation: 2397

For an absolute base URL use this. Works with both HTTP and HTTPS.

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

Upvotes: 21

tghw
tghw

Reputation: 25303

Assuming you have a Request object available, you can use:

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

If it's not available, you can get to it via the context:

var request = HttpContext.Current.Request

Upvotes: 437

Fernando Vezzali
Fernando Vezzali

Reputation: 2319

For ASP.NET MVC 4 it is a bit different:

string url = HttpContext.Request.Url.AbsoluteUri;

Upvotes: 3

Andrus
Andrus

Reputation: 27899

You can use the following script in view:

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

Upvotes: 3

Tadej Gregorcic
Tadej Gregorcic

Reputation: 51

This works fine for me (also with a load balancer):

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

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

Especially if you are using non-standard port numbers, using Request.Url.Authority appears like a good lead at first, but fails in a LB environment.

Upvotes: 5

mxasim
mxasim

Reputation: 2193

In Code:

Url.Content("~/");

MVC3 Razor Syntax:

@Url.Content("~/")

Upvotes: 76

Wyatt Barnett
Wyatt Barnett

Reputation: 15673

The trick with relying upon IIS is that IIS bindings can be different from your public URLs (WCF I'm looking at you), especially with multi-homed production machines. I tend to vector toward using configuration to explicitly define the "base" url for external purposes as that tends to be a bit more successful than extracting it from the Request object.

Upvotes: 25

Adrian Grigore
Adrian Grigore

Reputation: 33318

You could have a static method that looks at HttpContext.Current and decides which URL to use (development or live server) depending on the host ID. HttpContext might even offer some easier way to do it, but this is the first option I found and it works fine.

Upvotes: 3

Related Questions