/// <summary>
    /// Returns a site relative HTTP path from a partial path starting out with a ~.
    /// Same syntax that ASP.Net internally supports but this method can be used
    /// outside of the Page framework.
    /// 
    /// Works like Control.ResolveUrl including support for ~ syntax
    /// but returns an absolute URL.
    /// </summary>
    /// <param name="originalUrl">Any Url including those starting with ~</param>
    /// <returns>relative url</returns>
    public static string ResolveUrl(string originalUrl)
    {
        if (string.IsNullOrEmpty(originalUrl))
            return originalUrl;

        // *** Absolute path - just return
        if (IsAbsolutePath(originalUrl))
            return originalUrl;

        // *** We don't start with the '~' -> we don't process the Url
        if (!originalUrl.StartsWith("~"))
            return originalUrl;

        // *** Fix up path for ~ root app dir directory
        // VirtualPathUtility blows up if there is a 
        // query string, so we have to account for this.
        int queryStringStartIndex = originalUrl.IndexOf('?');
        if (queryStringStartIndex != -1)
        {
            string queryString = originalUrl.Substring(queryStringStartIndex);
            string baseUrl = originalUrl.Substring(0, queryStringStartIndex);

            return string.Concat(
                VirtualPathUtility.ToAbsolute(baseUrl),
                queryString);
        }
        else
        {
            return VirtualPathUtility.ToAbsolute(originalUrl);
        }

    }

    /// <summary>
    /// This method returns a fully qualified absolute server Url which includes
    /// the protocol, server, port in addition to the server relative Url.
    /// 
    /// Works like Control.ResolveUrl including support for ~ syntax
    /// but returns an absolute URL.
    /// </summary>
    /// <param name="ServerUrl">Any Url, either App relative or fully qualified</param>
    /// <param name="forceHttps">if true forces the url to use https</param>
    /// <returns></returns>
    public static string ResolveServerUrl(string serverUrl, bool forceHttps)
    {
        if (string.IsNullOrEmpty(serverUrl))
            return serverUrl;

        // *** Is it already an absolute Url?
        if(IsAbsolutePath(serverUrl))
            return serverUrl;

        string newServerUrl = ResolveUrl(serverUrl);
        Uri result = new Uri(HttpContext.Current.Request.Url, newServerUrl);

        if (!forceHttps)
            return result.ToString();
        else
            return ForceUriToHttps(result).ToString();

    }

    /// <summary>
    /// This method returns a fully qualified absolute server Url which includes
    /// the protocol, server, port in addition to the server relative Url.
    /// 
    /// It work like Page.ResolveUrl, but adds these to the beginning.
    /// This method is useful for generating Urls for AJAX methods
    /// </summary>
    /// <param name="ServerUrl">Any Url, either App relative or fully qualified</param>
    /// <returns></returns>
    public static string ResolveServerUrl(string serverUrl)
    {
        return ResolveServerUrl(serverUrl, false);
    }

    /// <summary>
    /// Forces the Uri to use https
    /// </summary>
    private static Uri ForceUriToHttps(Uri uri)
    {
        // ** Re-write Url using builder.
        UriBuilder builder = new UriBuilder(uri);
        builder.Scheme = Uri.UriSchemeHttps;
        builder.Port = 443;

        return builder.Uri;
    }

    private static bool IsAbsolutePath(string originalUrl)
    {
        // *** Absolute path - just return
        int IndexOfSlashes = originalUrl.IndexOf("://");
        int IndexOfQuestionMarks = originalUrl.IndexOf("?");

        if (IndexOfSlashes > -1 &&
             (IndexOfQuestionMarks < 0 ||
              (IndexOfQuestionMarks > -1 && IndexOfQuestionMarks > IndexOfSlashes)
              )
            )
            return true;

        return false;
    }