¿Cómo puedo resolver ASP.NET “~” caminos de aplicaciones a la raíz del sitio web sin estar presente el Control?

Question

Quiero Resolve "~ / lo que sea" desde el interior de la no-Página contextos como Global.asax (HttpApplication), HttpModule, HttpHandler, etc, pero sólo se puede encontrar tales métodos de resolución específica con los controles (y la página).

Creo que la aplicación debe tener suficiente conocimiento para ser capaz de asignar esta fuera del contexto de la página. ¿No? O al menos tiene sentido para mí que debería poder resolverse en otras circunstancias, siempre que se conoce la raíz aplicación.

Actualizar . La razón es que me quedo "~" caminos en los archivos web.configuration, y quiere resolverlos a partir de los escenarios mencionados no de control

Actualización 2:. Estoy tratando de resolverlos a la raíz del sitio web como Control.Resolve (..) URL del comportamiento, no a una ruta del sistema de archivos

Answer 1

Aquí está la respuesta: ASP.Net: Usando el Sistema de .Web.UI.Control.ResolveUrl () en una función compartida / estática

string absoluteUrl = VirtualPathUtility.ToAbsolute("~/SomePage.aspx");

Answer 2

Puede hacerlo accediendo al objeto HttpContext.Current directamente:

var resolved = HttpContext.Current.Server.MapPath("~/whatever")

Un punto a destacar es que, HttpContext.Current sólo va a ser no null en el contexto de una solicitud real. No está disponible en caso Application_Stop, por ejemplo.

Answer 3

En Global.asax añadir lo siguiente:

private static string ServerPath { get; set; }

protected void Application_BeginRequest(Object sender, EventArgs e)
{
    ServerPath = BaseSiteUrl;
}

protected static string BaseSiteUrl
{
    get
    {
        var context = HttpContext.Current;
        if (context.Request.ApplicationPath != null)
        {
            var baseUrl = context.Request.Url.Scheme + "://" + context.Request.Url.Authority + context.Request.ApplicationPath.TrimEnd('/') + '/';
            return baseUrl;
        }
        return string.Empty;
    }
}

Answer 4

No he depurado este lechón pero estoy lanzándolo nuestra allí como una solución manual para la falta de encontrar un método de resolución en el exterior de .NET Framework de control.

Esto hizo trabajar en un "~ / lo que sea" para mí.

/// <summary>
/// Try to resolve a web path to the current website, including the special "~/" app path.
/// This method be used outside the context of a Control (aka Page).
/// </summary>
/// <param name="strWebpath">The path to try to resolve.</param>
/// <param name="strResultUrl">The stringified resolved url (upon success).</param>
/// <returns>true if resolution was successful in which case the out param contains a valid url, otherwise false</returns>
/// <remarks>
/// If a valid URL is given the same will be returned as a successful resolution.
/// </remarks>
/// 
static public bool TryResolveUrl(string strWebpath, out string strResultUrl) {

    Uri uriMade = null;
    Uri baseRequestUri = new Uri(HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Authority));

    // Resolve "~" to app root;
    // and create http://currentRequest.com/webroot/formerlyTildeStuff
    if (strWebpath.StartsWith("~")) {
        string strWebrootRelativePath = string.Format("{0}{1}", 
            HttpContext.Current.Request.ApplicationPath, 
            strWebpath.Substring(1));

        if (Uri.TryCreate(baseRequestUri, strWebrootRelativePath, out uriMade)) {
            strResultUrl = uriMade.ToString();
            return true;
        }
    }

    // or, maybe turn given "/stuff" into http://currentRequest.com/stuff
    if (Uri.TryCreate(baseRequestUri, strWebpath, out uriMade)) {
        strResultUrl = uriMade.ToString();
        return true;
    }

    // or, maybe leave given valid "http://something.com/whatever" as itself
    if (Uri.TryCreate(strWebpath, UriKind.RelativeOrAbsolute, out uriMade)) {
        strResultUrl = uriMade.ToString();
        return true;
    }

    // otherwise, fail elegantly by returning given path unaltered.    
    strResultUrl = strWebpath;
    return false;
}

Answer 5

public static string ResolveUrl(string url)
{
    if (string.IsNullOrEmpty(url))
    {
        throw new ArgumentException("url", "url can not be null or empty");
    }
    if (url[0] != '~')
    {
        return url;
    }
    string applicationPath = HttpContext.Current.Request.ApplicationPath;
    if (url.Length == 1)
    {
        return applicationPath;
    }
    int startIndex = 1;
    string str2 = (applicationPath.Length > 1) ? "/" : string.Empty;
    if ((url[1] == '/') || (url[1] == '\\'))
    {
        startIndex = 2;
    }
    return (applicationPath + str2 + url.Substring(startIndex));
}

Answer 6

En lugar de utilizar MapPath, trate de usar System.AppDomain.BaseDirectory. Para un sitio web, esta debe ser la raíz de su sitio web. A continuación, realice una System.IO.Path.Combine con lo que iba a pasar a MapPath sin el "~".