URL සඳහා Path.Combine?

Path.Combine පහසුය , නමුත් URL සඳහා .NET රාමුව තුළ සමාන කාර්යයක් තිබේද?

මම මේ වගේ සින්ටැක්ස් සොයනවා:

Url.Combine("http://MyUrl.com/", "/Images/Image.jpg")

එය නැවත පැමිණේ:

"http://MyUrl.com/Images/Image.jpg"

එහි වූ ටොඩ් Menier ගේ අදහස් ඉහත වේ බව Flurl ඇතුලත් වේ Url.Combine.

වැඩිපුර විස්තර:

Url.Combine යනු මූලික වශයෙන් URL සඳහා වන Path.Combine ය, කොටස් අතර එක හා එකම බෙදුම්කරු චරිතයක් සහතික කරයි:

var url = Url.Combine(
    "http://MyUrl.com/",
    "/too/", "/many/", "/slashes/",
    "too", "few?",
    "x=1", "y=2"
// result: "http://www.MyUrl.com/too/many/slashes/too/few?x=1&y=2" 

NuGet හි Flurl.Http ලබා ගන්න :

PM> ස්ථාපනය-පැකේජය Flurl.Http

හෝ HTTP විශේෂාංග නොමැතිව තනිවම URL තනන්නා ලබා ගන්න:

PM> Install-Package Flurl

Uri ඔබ වෙනුවෙන් මෙය කළ යුතු ඉදිකිරීම්කරුවෙකු ඇත: new Uri(Uri baseUri, string relativeUri)

මෙන්න උදාහරණයක්:

Uri baseUri = new Uri("http://www.contoso.com");
Uri myUri = new Uri(baseUri, "catalog/shownew.htm");

සංස්කාරකයෙන් සටහන: පරෙස්සම් වන්න, මෙම ක්‍රමය අපේක්ෂිත පරිදි ක්‍රියාත්මක නොවේ. සමහර අවස්ථාවල එය baseUri හි කොටසක් කපා ගත හැකිය. අදහස් සහ වෙනත් පිළිතුරු බලන්න.

මෙය සුදුසු සරල විසඳුමක් විය හැකිය:

public static string Combine(string uri1, string uri2)
{
    uri1 = uri1.TrimEnd('/');
    uri2 = uri2.TrimStart('/');
    return string.Format("{0}/{1}", uri1, uri2);
}

ඔබ භාවිතා කරන්නේ Uri.TryCreate( ... ):

Uri result = null;

if (Uri.TryCreate(new Uri("http://msdn.microsoft.com/en-us/library/"), "/en-us/library/system.uri.trycreate.aspx", out result))
{
    Console.WriteLine(result);
}

නැවත පැමිණේ:

http://msdn.microsoft.com/en-us/library/system.uri.trycreate.aspx

දැනටමත් මෙහි හොඳ පිළිතුරු කිහිපයක් තිබේ. Mdsharpe යෝජනාව මත පදනම්ව, ඔබට යූරි සිද්ධීන් සමඟ කටයුතු කිරීමට අවශ්‍ය විට පහසුවෙන් භාවිතා කළ හැකි දිගු ක්‍රමයක් මෙන්න:

using System;
using System.Linq;

public static class UriExtensions
{
    public static Uri Append(this Uri uri, params string[] paths)
    {
        return new Uri(paths.Aggregate(uri.AbsoluteUri, (current, path) => string.Format("{0}/{1}", current.TrimEnd('/'), path.TrimStart('/'))));
    }
}

සහ භාවිත උදාහරණය:

var url = new Uri("http://example.com/subpath/").Append("/part1/", "part2").AbsoluteUri;

මෙය http://example.com/subpath/part1/part2 නිපදවනු ඇත

රයන් කුක්ගේ පිළිතුර මා පසු වූ දෙයට සමීප වන අතර අනෙක් සංවර්ධකයින් සඳහා වඩාත් සුදුසු විය හැකිය. කෙසේ වෙතත්, එය නූල් ආරම්භයට http: // එකතු කරන අතර පොදුවේ එය මට පසුව වඩා හැඩතල ගැන්වීමක් කරයි.

එසේම, මගේ භාවිත අවස්ථා සඳහා, සාපේක්ෂ මාර්ග නිරාකරණය කිරීම වැදගත් නොවේ.

mdsharp ගේ පිළිතුරෙහි හොඳ අදහසක බීජ ද අඩංගු වේ, නමුත් එම සත්‍ය ක්‍රියාවට නැංවීම සඳහා තවත් විස්තර කිහිපයක් අවශ්‍ය විය. මෙය මස් මාංශ ඉවත් කිරීමේ උත්සාහයකි (මම මෙය නිෂ්පාදනයේදී භාවිතා කරමි):

සී #

public string UrlCombine(string url1, string url2)
{
    if (url1.Length == 0) {
        return url2;
    }

    if (url2.Length == 0) {
        return url1;
    }

    url1 = url1.TrimEnd('/', '\\');
    url2 = url2.TrimStart('/', '\\');

    return string.Format("{0}/{1}", url1, url2);
}

VB.NET

Public Function UrlCombine(ByVal url1 As String, ByVal url2 As String) As String
    If url1.Length = 0 Then
        Return url2
    End If

    If url2.Length = 0 Then
        Return url1
    End If

    url1 = url1.TrimEnd("/"c, "\"c)
    url2 = url2.TrimStart("/"c, "\"c)

    Return String.Format("{0}/{1}", url1, url2)
End Function

මෙම කේතය VB හි සිදු වන පහත පරීක්ෂණය සමත් වේ:

<TestMethod()> Public Sub UrlCombineTest()
    Dim target As StringHelpers = New StringHelpers()

    Assert.IsTrue(target.UrlCombine("test1", "test2") = "test1/test2")
    Assert.IsTrue(target.UrlCombine("test1/", "test2") = "test1/test2")
    Assert.IsTrue(target.UrlCombine("test1", "/test2") = "test1/test2")
    Assert.IsTrue(target.UrlCombine("test1/", "/test2") = "test1/test2")
    Assert.IsTrue(target.UrlCombine("/test1/", "/test2/") = "/test1/test2/")
    Assert.IsTrue(target.UrlCombine("", "/test2/") = "/test2/")
    Assert.IsTrue(target.UrlCombine("/test1/", "") = "/test1/")
End Sub

Path.Combine මා වෙනුවෙන් ක්‍රියා නොකරන්නේ "|" වැනි අක්ෂර තිබිය හැකි බැවිනි QueryString තර්ක වල සහ එම නිසා URL ය, එහි ප්‍රති Ar ලයක් ලෙස ArgumentException.

මම මුලින්ම නව Uri(Uri baseUri, string relativeUri)ප්‍රවේශය අත්හදා බැලුවෙමි , එය යූආර්අයි වැනි නිසා මට අසමත් විය http://www.mediawiki.org/wiki/Special:SpecialPages:

new Uri(new Uri("http://www.mediawiki.org/wiki/"), "Special:SpecialPages")

එහි ප්‍රති result ලය වනුයේ විශේෂ: විශේෂ පිටු, ඊට පසු මහා බඩවැල් නිසා Specialයෝජනා ක්‍රමයක් දක්වයි.

ඒ නිසා මට අවසානයේදී mdsharpe / බ්‍රයන් මැකේස් මාර්ගයෙන් ගමන් කිරීමට සිදු වූ අතර එය යූආර්අයි කොටස් කිහිපයක් සමඟ වැඩ කිරීම සඳහා තව ටිකක් දියුණු විය:

public static string CombineUri(params string[] uriParts)
{
    string uri = string.Empty;
    if (uriParts != null && uriParts.Length > 0)
    {
        char[] trims = new char[] { '\\', '/' };
        uri = (uriParts[0] ?? string.Empty).TrimEnd(trims);
        for (int i = 1; i < uriParts.Length; i++)
        {
            uri = string.Format("{0}/{1}", uri.TrimEnd(trims), (uriParts[i] ?? string.Empty).TrimStart(trims));
        }
    }
    return uri;
}

භාවිතය: CombineUri("http://www.mediawiki.org/", "wiki", "Special:SpecialPages")

ඔබ ලබා දුන් නියැදි URL මත පදනම්ව , ඔබේ වෙබ් අඩවියට සාපේක්ෂව URL ඒකාබද්ධ කිරීමට ඔබට අවශ්‍ය යැයි මම සිතමි.

මෙම උපකල්පනය මත පදනම්ව, ඔබේ ප්‍රශ්නයට වඩාත්ම උචිත ප්‍රතිචාරය ලෙස මම මෙම විසඳුම යෝජනා කරමි: "Path.Combine පහසුය, URL සඳහා රාමුව තුළ සමාන කාර්යයක් තිබේද?"

එහි සිට වන්නේ සමානව ක්රියාත්මක "VirtualPathUtility.Combine" ක්රමය: මම නිවැරදි ද මා යෝජනා කරනවා URL ලිපින සඳහා රාමුවක් තුළ. මෙන්න MSDN යොමු සබැඳිය: VirtualPathUtility.Combine Method

එක් අවවාදයක් ඇත: මෙය ක්‍රියාත්මක වන්නේ ඔබේ වෙබ් අඩවියට සාපේක්ෂව URL සඳහා පමණක් බව මම විශ්වාස කරමි (එනම්, වෙනත් වෙබ් අඩවියකට සබැඳි ජනනය කිරීමට ඔබට එය භාවිතා කළ නොහැක. උදාහරණයක් ලෙස var url = VirtualPathUtility.Combine("www.google.com", "accounts/widgets");).

Path.Combine("Http://MyUrl.com/", "/Images/Image.jpg").Replace("\\", "/")

මම දැන් කුඩා ව්‍යාප්ති ක්‍රමයක් එක් කළෙමි:

public static string UriCombine (this string val, string append)
        {
            if (String.IsNullOrEmpty(val)) return append;
            if (String.IsNullOrEmpty(append)) return val;
            return val.TrimEnd('/') + "/" + append.TrimStart('/');
        }

එය මේ ආකාරයෙන් භාවිතා කළ හැකිය:

"www.example.com/".UriCombine("/images").UriCombine("first.jpeg");

විට්ටි උදාහරණය, ​​රයන්, ශ්‍රිතයට සබැඳියකින් අවසන් කිරීමට. හොඳට කලා.

එක් නිර්දේශයක් බ්‍රයන්: ඔබ මෙම කේතය ශ්‍රිතයක් තුළට ඔතා ඇත්නම්, ට්‍රයික්‍රීට් ඇමතුමට පෙර මූලික URL එක එතීමට යූරිබිල්ඩර් භාවිතා කිරීමට ඔබට අවශ්‍ය විය හැකිය.

එසේ නොමැතිනම්, මූලික URL එකෙහි යෝජනා ක්‍රමය ඇතුළත් විය යුතුය (එහිදී යූරිබිල්ඩර් http: // උපකල්පනය කරයි). සිතුවිල්ලක් පමණි:

public string CombineUrl(string baseUrl, string relativeUrl) {
    UriBuilder baseUri = new UriBuilder(baseUrl);
    Uri newUri;

    if (Uri.TryCreate(baseUri.Uri, relativeUrl, out newUri))
        return newUri.ToString();
    else
        throw new ArgumentException("Unable to combine specified url values");
}

ඒවා ඒකාබද්ධ කර එය සැමවිටම නිවැරදි බව සහතික කිරීමට පහසු ක්‍රමයක් නම්:

string.Format("{0}/{1}", Url1.Trim('/'), Url2);

URL එකක කොටස් කිහිපයක් ඒකාබද්ධ කිරීම ටිකක් උපක්‍රමශීලී විය හැකිය. ඔබට පරාමිති දෙකේ ඉදිකිරීම්කරු Uri(baseUri, relativeUri)භාවිතා කළ හැකිය, නැතහොත් ඔබට Uri.TryCreate()උපයෝගිතා ශ්‍රිතය භාවිතා කළ හැකිය .

එක්කෝ නඩුවේ, මෙම ක්රම පළමු පරාමිතිය සාපේක්ෂ කොටස් ගලවා truncating දිගටම නිසා ඔබ වැරදි ප්රතිඵලයක් නැවත අවසන් විය baseUriවගේ දෙයක් සිට, එනම්, http://google.com/some/thingකිරීමට http://google.com.

අවසාන URL එකකට කොටස් කිහිපයක් ඒකාබද්ධ කිරීමට ඔබට පහත කාර්යයන් දෙක පිටපත් කළ හැකිය:

    public static string Combine(params string[] parts)
    {
        if (parts == null || parts.Length == 0) return string.Empty;

        var urlBuilder = new StringBuilder();
        foreach (var part in parts)
        {
            var tempUrl = tryCreateRelativeOrAbsolute(part);
            urlBuilder.Append(tempUrl);
        }
        return VirtualPathUtility.RemoveTrailingSlash(urlBuilder.ToString());
    }

    private static string tryCreateRelativeOrAbsolute(string s)
    {
        System.Uri uri;
        System.Uri.TryCreate(s, UriKind.RelativeOrAbsolute, out uri);
        string tempUrl = VirtualPathUtility.AppendTrailingSlash(uri.ToString());
        return tempUrl;
    }

භාවිතය නිරූපණය කිරීම සඳහා ඒකක පරීක්ෂණ සහිත සම්පූර්ණ කේතය https://uricombine.codeplex.com/SourceControl/latest#UriCombine/Uri.cs වෙතින් සොයාගත හැකිය.

වඩාත් පොදු අවස්ථා තුන ආවරණය කිරීම සඳහා මට ඒකක පරීක්ෂණ තිබේ:

UriBuilderමේ වගේ දෙයක් සඳහා මම හොඳින් වැඩ කළ බව මට පෙනී ගියේය:

UriBuilder urlb = new UriBuilder("http", _serverAddress, _webPort, _filePath);
Uri url = urlb.Uri;
return url.AbsoluteUri;

වැඩි ඉදිකිරීම්කරුවන් සහ ප්‍රලේඛන සඳහා යූරිබිල්ඩර් පන්තිය - එම්එස්ඩීඑන් බලන්න .

මම පහත සඳහන් දෑ ප්‍රයෝජනවත් වන අතර පහත ලක්ෂණ ඇත:

• ශුන්‍ය හෝ සුදු අවකාශය මතට විසි කරයි
• paramsබහු Url කොටස් සඳහා බහු පරාමිතියක් ගනී
• ශුන්‍ය හෝ හිස් මත විසි කරයි

පන්තිය

public static class UrlPath
{
   private static string InternalCombine(string source, string dest)
   {
      if (string.IsNullOrWhiteSpace(source))
         throw new ArgumentException("Cannot be null or white space", nameof(source));

      if (string.IsNullOrWhiteSpace(dest))
         throw new ArgumentException("Cannot be null or white space", nameof(dest));

      return $"{source.TrimEnd('/', '\\')}/{dest.TrimStart('/', '\\')}";
   }

   public static string Combine(string source, params string[] args) 
       => args.Aggregate(source, InternalCombine);
}

පරීක්ෂණ

UrlPath.Combine("test1", "test2");
UrlPath.Combine("test1//", "test2");
UrlPath.Combine("test1", "/test2");

// Result = test1/test2

UrlPath.Combine(@"test1\/\/\/", @"\/\/\\\\\//test2", @"\/\/\\\\\//test3\") ;

// Result = test1/test2/test3

UrlPath.Combine("/test1/", "/test2/", null);
UrlPath.Combine("", "/test2/");
UrlPath.Combine("/test1/", null);

// Throws an ArgumentException

මෙන්න මයික්‍රොසොෆ්ට් හි (OfficeDev PnP) ක්‍රමය UrlUtility.Combine :

    const char PATH_DELIMITER = '/';

    /// <summary>
    /// Combines a path and a relative path.
    /// </summary>
    /// <param name="path"></param>
    /// <param name="relative"></param>
    /// <returns></returns>
    public static string Combine(string path, string relative) 
    {
        if(relative == null)
            relative = String.Empty;

        if(path == null)
            path = String.Empty;

        if(relative.Length == 0 && path.Length == 0)
            return String.Empty;

        if(relative.Length == 0)
            return path;

        if(path.Length == 0)
            return relative;

        path = path.Replace('\\', PATH_DELIMITER);
        relative = relative.Replace('\\', PATH_DELIMITER);

        return path.TrimEnd(PATH_DELIMITER) + PATH_DELIMITER + relative.TrimStart(PATH_DELIMITER);
    }

මුලාශ්‍රය: GitHub

මගේ සාමාන්‍ය විසඳුම:

public static string Combine(params string[] uriParts)
{
    string uri = string.Empty;
    if (uriParts != null && uriParts.Any())
    {
        char[] trims = new char[] { '\\', '/' };
        uri = (uriParts[0] ?? string.Empty).TrimEnd(trims);

        for (int i = 1; i < uriParts.Length; i++)
        {
            uri = string.Format("{0}/{1}", uri.TrimEnd(trims), (uriParts[i] ?? string.Empty).TrimStart(trims));
        }
    }

    return uri;
}

මම මෙම ක්‍රියාව නිර්මාණය කළේ ඔබේ ජීවිතය පහසු කරවන අයුරිනි:

    /// <summary>
    /// The ultimate Path combiner of all time
    /// </summary>
    /// <param name="IsURL">
    /// true - if the paths are Internet URLs, false - if the paths are local URLs, this is very important as this will be used to decide which separator will be used.
    /// </param>
    /// <param name="IsRelative">Just adds the separator at the beginning</param>
    /// <param name="IsFixInternal">Fix the paths from within (by removing duplicate separators and correcting the separators)</param>
    /// <param name="parts">The paths to combine</param>
    /// <returns>the combined path</returns>
    public static string PathCombine(bool IsURL , bool IsRelative , bool IsFixInternal , params string[] parts)
    {
        if (parts == null || parts.Length == 0) return string.Empty;
        char separator = IsURL ? '/' : '\\';

        if (parts.Length == 1 && IsFixInternal)
        {
            string validsingle;
            if (IsURL)
            {
                validsingle = parts[0].Replace('\\' , '/');
            }
            else
            {
                validsingle = parts[0].Replace('/' , '\\');
            }
            validsingle = validsingle.Trim(separator);
            return (IsRelative ? separator.ToString() : string.Empty) + validsingle;
        }

        string final = parts
            .Aggregate
            (
            (string first , string second) =>
            {
                string validfirst;
                string validsecond;
                if (IsURL)
                {
                    validfirst = first.Replace('\\' , '/');
                    validsecond = second.Replace('\\' , '/');
                }
                else
                {
                    validfirst = first.Replace('/' , '\\');
                    validsecond = second.Replace('/' , '\\');
                }
                var prefix = string.Empty;
                if (IsFixInternal)
                {
                    if (IsURL)
                    {
                        if (validfirst.Contains("://"))
                        {
                            var tofix = validfirst.Substring(validfirst.IndexOf("://") + 3);
                            prefix = validfirst.Replace(tofix , string.Empty).TrimStart(separator);

                            var tofixlist = tofix.Split(new[] { separator } , StringSplitOptions.RemoveEmptyEntries);

                            validfirst = separator + string.Join(separator.ToString() , tofixlist);
                        }
                        else
                        {
                            var firstlist = validfirst.Split(new[] { separator } , StringSplitOptions.RemoveEmptyEntries);
                            validfirst = string.Join(separator.ToString() , firstlist);
                        }

                        var secondlist = validsecond.Split(new[] { separator } , StringSplitOptions.RemoveEmptyEntries);
                        validsecond = string.Join(separator.ToString() , secondlist);
                    }
                    else
                    {
                        var firstlist = validfirst.Split(new[] { separator } , StringSplitOptions.RemoveEmptyEntries);
                        var secondlist = validsecond.Split(new[] { separator } , StringSplitOptions.RemoveEmptyEntries);

                        validfirst = string.Join(separator.ToString() , firstlist);
                        validsecond = string.Join(separator.ToString() , secondlist);
                    }
                }
                return prefix + validfirst.Trim(separator) + separator + validsecond.Trim(separator);
            }
            );
        return (IsRelative ? separator.ToString() : string.Empty) + final;
    }

එය URL සඳහා මෙන්ම සාමාන්‍ය මාර්ග සඳහාද ක්‍රියා කරයි.

භාවිතය:

    // Fixes internal paths
    Console.WriteLine(PathCombine(true , true , true , @"\/\/folder 1\/\/\/\\/\folder2\///folder3\\/" , @"/\somefile.ext\/\//\"));
    // Result: /folder 1/folder2/folder3/somefile.ext

    // Doesn't fix internal paths
    Console.WriteLine(PathCombine(true , true , false , @"\/\/folder 1\/\/\/\\/\folder2\///folder3\\/" , @"/\somefile.ext\/\//\"));
    //result : /folder 1//////////folder2////folder3/somefile.ext

    // Don't worry about URL prefixes when fixing internal paths
    Console.WriteLine(PathCombine(true , false , true , @"/\/\/https:/\/\/\lul.com\/\/\/\\/\folder2\///folder3\\/" , @"/\somefile.ext\/\//\"));
    // Result: https://lul.com/folder2/folder3/somefile.ext

    Console.WriteLine(PathCombine(false , true , true , @"../../../\\..\...\./../somepath" , @"anotherpath"));
    // Result: \..\..\..\..\...\.\..\somepath\anotherpath

පහත සඳහන් දේ පමණක් භාවිතා නොකරන්නේ ඇයි?

System.IO.Path.Combine(rootUrl, subPath).Replace(@"\", "/")

යූආර්අයි සමඟ URL ඒකාබද්ධ කරන අතරතුර නීති

අමුතු හැසිරීම් වලක්වා ගැනීම සඳහා අනුගමනය කළ යුතු එක් රීතියක් තිබේ:

• මාර්ගය (නාමාවලිය) '/' සමඟ අවසන් විය යුතුය. '/' නොමැතිව මාර්ගය අවසන් වුවහොත්, අවසාන කොටස ගොනු නාමයක් ලෙස සලකනු ලබන අතර, ඊළඟ URL කොටස සමඟ සංයුක්ත කිරීමට උත්සාහ කරන විට එය සංයුක්ත වේ.
• එක් ව්‍යතිරේකයක් ඇත: මූලික URL ලිපිනය (නාමාවලි තොරතුරු නොමැතිව) '/' සමඟ අවසන් නොවිය යුතුය
• මාර්ග කොටස '/' සමඟ ආරම්භ නොවිය යුතුය. එය '/' සමඟ ආරම්භ වුවහොත්, URL වෙතින් දැනට පවතින සෑම සාපේක්ෂ තොරතුරක්ම අතහැර දමනු ලැබේ ... string.Emptyකොටස් මාර්ගයක් එක් කිරීමෙන් URL වෙතින් සාපේක්ෂ නාමාවලියද ඉවත් වේ!

ඔබ ඉහත නීති රීති අනුගමනය කරන්නේ නම්, ඔබට පහත කේතය සමඟ URL ඒකාබද්ධ කළ හැකිය. ඔබගේ තත්වය අනුව, ඔබට URL වෙත 'ඩිරෙක්ටරි' කොටස් කිහිපයක් එකතු කළ හැකිය ...

        var pathParts = new string[] { destinationBaseUrl, destinationFolderUrl, fileName };

        var destination = pathParts.Aggregate((left, right) =>
        {
            if (string.IsNullOrWhiteSpace(right))
                return left;

            return new Uri(new Uri(left), right).ToString();
        });

ASP.NET Core (Microsoft.Owin හි ද ඇත) හි Flurl වැනි තෙවන පාර්ශවීය යැපීමක් එක් කිරීමට හෝ අභිරුචි දිගු කිරීමේ ක්‍රමයක් නිර්මාණය කිරීමට ඔබට අවශ්‍ය නැතිනම්, ඔබට PathStringURI ගොඩනැගීම සඳහා අදහස් කරන භාවිතා කළ හැකිය. මාර්ග. එවිට ඔබට මෙම සංයෝජනයෙන් ඔබේ සම්පූර්ණ යූආර්අයි නිර්මාණය කළ හැකිය, Uriසහ UriBuilder.

මෙම අවස්ථාවේ දී, එය වනුයේ:

new Uri(new UriBuilder("http", "MyUrl.com").Uri, new PathString("/Images").Add("/Image.jpg").ToString())

මූලික URL හි බෙදුම්කරුවන් සඳහන් නොකර මෙය ඔබට සියලුම සං parts ටක කොටස් ලබා දෙයි. අවාසනාවකට මෙන්, එක් එක් නූලට පෙර සූදානමක් PathStringඅවශ්‍ය වේ නම් /එය ඇත්ත වශයෙන්ම විසි කරයි ArgumentException! නමුත් අවම වශයෙන් ඔබට පහසුවෙන් පරීක්ෂා කළ හැකි ආකාරයකින් ඔබේ යූආර්අයි නිර්ණායක ලෙස ගොඩනගා ගත හැකිය.

එබැවින් මට යූරිබිල්ඩර් භාවිතා කළ සෑම කෙනෙකුටම සමාන තවත් ප්‍රවේශයක් ඇත.

ජාවාජවජවාජවාජාව කළාක් මෙන් මගේ BaseUrl (මාර්ගයේ කොටසක් අඩංගු විය හැකිය - උදා: http://mybaseurl.com/dev/ ) බෙදීමට මට අවශ්‍ය නොවීය.

පහත දැක්වෙන ස්නිපටයේ + ටෙස්ට් කේතය පෙන්වයි.

පරෙස්සම් වන්න: මෙම විසඳුම ධාරකය පහත් කොට වරායක් එකතු කරයි. මෙය අපේක්‍ෂා නොකරන්නේ නම්, යමෙකුට Uriදේපල උත්තේජනය කිරීමෙන් නූල් නිරූපණයක් ලිවිය හැකිය UriBuilder.

  public class Tests
  {
         public static string CombineUrl (string baseUrl, string path)
         {
           var uriBuilder = new UriBuilder (baseUrl);
           uriBuilder.Path = Path.Combine (uriBuilder.Path, path);
           return uriBuilder.ToString();
         }

         [TestCase("http://MyUrl.com/", "/Images/Image.jpg", "http://myurl.com:80/Images/Image.jpg")]
         [TestCase("http://MyUrl.com/basePath", "/Images/Image.jpg", "http://myurl.com:80/Images/Image.jpg")]
         [TestCase("http://MyUrl.com/basePath", "Images/Image.jpg", "http://myurl.com:80/basePath/Images/Image.jpg")]
         [TestCase("http://MyUrl.com/basePath/", "Images/Image.jpg", "http://myurl.com:80/basePath/Images/Image.jpg")]
         public void Test1 (string baseUrl, string path, string expected)
         {
           var result = CombineUrl (baseUrl, path);

           Assert.That (result, Is.EqualTo (expected));
         }
  }

වින්ඩෝස් 10 හි .NET Core 2.1 සමඟ පරීක්ෂා කර ඇත.

මෙය ක්‍රියාත්මක වන්නේ ඇයි?

වුවත් Path.CombineBackslashes ආපසු (වින්ඩෝස් කටවත් මත), එම UriBuilder වන පන්දු ඔසවන්නා ලෙස මෙම නඩුව හසුරුවන Path.

Https://github.com/dotnet/corefx/blob/master/src/System.Private.Uri/src/System/UriBuilder.cs වෙතින් ලබා ගත් (ඇමතුම මතක තබා ගන්න string.Replace)

[AllowNull]
public string Path
{
      get
      {
          return _path;
      }
      set
      {
          if ((value == null) || (value.Length == 0))
          {
              value = "/";
          }
          _path = Uri.InternalEscapeString(value.Replace('\\', '/'));
          _changed = true;
      }
 }

මෙය හොඳම ප්‍රවේශයද?

නිසැකවම මෙම විසඳුම ස්වයං විස්තර කිරීමකි (අවම වශයෙන් මගේ මතය අනුව). නමුත් ඔබ ලේඛනගත නොකළ (අවම වශයෙන් ඉක්මන් ගූගල් සෙවුමක් සමඟ කිසිවක් සොයා ගත්තේ නැත) .NET API වෙතින් "විශේෂාංගය" මත විශ්වාසය තබයි. අනාගත නිකුතුවක් සමඟ මෙය වෙනස් විය හැකි බැවින් කරුණාකර ටෙස්ට් සමඟ ක්‍රමය ආවරණය කරන්න.

දී පරීක්ෂණ ඇත https://github.com/dotnet/corefx/blob/master/src/System.Private.Uri/tests/FunctionalTests/UriBuilderTests.cs ( Path_Get_Setමෙම නම්, පරීක්ෂා කරන) \නිවැරදිව පරිවර්තනය වී ඇත.

පැති සටහන: යූරි කෝටරයක් UriBuilder.Uriසඳහා භාවිතා කරන්නේ නම් System.Uriයමෙකුට දේපල සමඟ කෙලින්ම වැඩ කළ හැකිය.

එක්-ලයිනර් එකක් සොයන සහ නව ක්‍රමයක් නිර්මාණය නොකර හෝ නව පුස්තකාලයක් යොමු නොකර හෝ යූආර්අයි අගයක් ගොඩනඟා එය නූලක් බවට පරිවර්තනය නොකර මාර්ගයක කොටස් වලට සම්බන්ධ වීමට කැමති ඕනෑම කෙනෙකුට, එසේ නම් ...

string urlToImage = String.Join("/", "websiteUrl", "folder1", "folder2", "folder3", "item");

එය ඉතා මූලික ය, නමුත් ඔබට තවත් අවශ්‍ය දේ මම නොදනිමි. '/' දෙගුණ කිරීමට ඔබ බිය වන්නේ නම් ඔබට පසුව කළ හැකිය .Replace("//", "/"). 'Https: //' හි දෙගුණ කළ '//' ප්‍රතිස්ථාපනය කිරීමට ඔබ බිය වන්නේ නම්, ඒ වෙනුවට එක් සම්බන්ධතාවයක් කරන්න, දෙගුණ කළ '/' ආදේශ කරන්න, ඉන්පසු වෙබ් අඩවි url වෙත සම්බන්ධ වන්න (කෙසේ වෙතත් බොහෝ බ්‍රව්සර් ස්වයංක්‍රීයව සිදුවනු ඇතැයි මට විශ්වාසයි ඕනෑම දෙයක් නිවැරදි ආකෘතියෙන් කියවීමට එහි ඉදිරිපස ඇති 'https:' සමඟ පරිවර්තනය කරන්න). මෙය මෙසේ වනු ඇත:

string urlToImage = String.Join("/","websiteUrl", String.Join("/", "folder1", "folder2", "folder3", "item").Replace("//","/"));

ඉහත සඳහන් සියල්ලම හැසිරවිය හැකි පිළිතුරු ඕනෑ තරම් තිබේ, නමුත් මගේ නඩුවේදී, මට එය අවශ්‍ය වූයේ එක් ස්ථානයකට එක් වරක් පමණක් වන අතර ඒ මත දැඩි ලෙස විශ්වාසය තැබීමට අවශ්‍ය නොවනු ඇත. එසේම, මෙහි සිදුවන්නේ කුමක්ද යන්න බැලීම පහසුය.

බලන්න: https://docs.microsoft.com/en-us/dotnet/api/system.string.join?view=netframework-4.8

වෙනත් පිළිතුරු වලින් සොයා ගත් පරිදි, නව Uri()හෝ TryCreate()ටික් කළ හැකිය. කෙසේ වෙතත්, යූරි පදනම අවසන් විය යුතු /අතර relative ාතියෙකු සමඟ ආරම්භ විය යුතු නැත /; එසේ නොවුවහොත් එය යූආර්එල් පාදමේ පසුපස කොටස ඉවත් කරයි

මම හිතන්නේ මෙය වඩාත් සුදුසු වන්නේ ව්‍යාප්ති ක්‍රමයක් ලෙස ය, එනම්

public static Uri Append(this Uri uri, string relativePath)
{
    var baseUri = uri.AbsoluteUri.EndsWith('/') ? uri : new Uri(uri.AbsoluteUri + '/');
    var relative = relativePath.StartsWith('/') ? relativePath.Substring(1) : relativePath;
    return new Uri(baseUri, relative);
}

සහ එය භාවිතා කිරීමට:

var baseUri = new Uri("http://test.com/test/");
var combinedUri =  baseUri.Append("/Do/Something");

කාර්ය සාධනය සම්බන්ධයෙන් ගත් කල, මෙය අවශ්‍ය ප්‍රමාණයට වඩා වැඩි සම්පත් ප්‍රමාණයක් පරිභෝජනය කරයි, යූරි පන්තිය නිසා විග්‍රහ කිරීම සහ වලංගු කිරීම සිදු කරයි; ඉතා රළු පැතිකඩක් (නිදොස් කිරීම) තත්පර 2 කින් මිලියනයක මෙහෙයුම් සිදු කළේය. මෙය බොහෝ අවස්ථාවන් සඳහා ක්‍රියා කරනු ඇත, කෙසේ වෙතත් වඩා කාර්යක්ෂම වීමට, සෑම දෙයක්ම නූල් ලෙස හැසිරවීම වඩා හොඳය, මෙය මෙහෙයුම් මිලියනයකට මිලි තත්පර 125 ක් ගතවේ. එනම්

public static string Append(this Uri uri, string relativePath)
{
    //avoid the use of Uri as it's not needed, and adds a bit of overhead.
    var absoluteUri = uri.AbsoluteUri; //a calculated property, better cache it
    var baseUri = absoluteUri.EndsWith('/') ? absoluteUri : absoluteUri + '/';
    var relative = relativePath.StartsWith('/') ? relativePath.Substring(1) : relativePath;
    return baseUri + relative;
}

ඔබට තවමත් යූආර්අයි එකක් ආපසු ලබා දීමට අවශ්‍ය නම්, මෙහෙයුම් මිලියනයක් සඳහා මිලි තත්පර 600 ක් පමණ ගත වේ.

public static Uri AppendUri(this Uri uri, string relativePath)
{
    //avoid the use of Uri as it's not needed, and adds a bit of overhead.
    var absoluteUri = uri.AbsoluteUri; //a calculated property, better cache it
    var baseUri = absoluteUri.EndsWith('/') ? absoluteUri : absoluteUri + '/';
    var relative = relativePath.StartsWith('/') ? relativePath.Substring(1) : relativePath;
    return new Uri(baseUri + relative);
}

මම හිතනවා මේක උදව් වෙයි කියලා.

ඔබට අවශ්‍ය තරම් මාර්ග කොටස් සමඟ කටයුතු කළ හැකි බැවින් මෙය ඔබට වඩාත් නම්‍යශීලී බවක් ලබා දෙනු ඇතැයි මම සිතමි:

public static string UrlCombine(this string baseUrl, params string[] segments)
=> string.Join("/", new[] { baseUrl.TrimEnd('/') }.Concat(segments.Select(s => s.Trim('/'))));

භාවිත:

    private Uri UriCombine(string path1, string path2, string path3 = "", string path4 = "")
    {
        string path = System.IO.Path.Combine(path1, path2.TrimStart('\\', '/'), path3.TrimStart('\\', '/'), path4.TrimStart('\\', '/'));
        string url = path.Replace('\\','/');
        return new Uri(url);
    }

හරියටම හැසිරීමේ වාසිය එයට ඇත Path.Combine.

මෙන්න මගේ ප්‍රවේශය වන අතර මම එය මා වෙනුවෙන්ම භාවිතා කරමි:

public static string UrlCombine(string part1, string part2)
{
    string newPart1 = string.Empty;
    string newPart2 = string.Empty;
    string seperator = "/";

    // If either part1 or part 2 is empty,
    // we don't need to combine with seperator
    if (string.IsNullOrEmpty(part1) || string.IsNullOrEmpty(part2))
    {
        seperator = string.Empty;
    }

    // If part1 is not empty,
    // remove '/' at last
    if (!string.IsNullOrEmpty(part1))
    {
        newPart1 = part1.TrimEnd('/');
    }

    // If part2 is not empty,
    // remove '/' at first
    if (!string.IsNullOrEmpty(part2))
    {
        newPart2 = part2.TrimStart('/');
    }

    // Now finally combine
    return string.Format("{0}{1}{2}", newPart1, seperator, newPart2);
}

මෙය භාවිතා කරන්න:

public static class WebPath
{
    public static string Combine(params string[] args)
    {
        var prefixAdjusted = args.Select(x => x.StartsWith("/") && !x.StartsWith("http") ? x.Substring(1) : x);
        return string.Join("/", prefixAdjusted);
    }
}

Uriඉදිකිරීම්කරු '\' වෙත '/' පෙරළෙන බව මට පෙනී ගියේය. ඒ නිසා ඔබ ද භාවිතා කළ හැකිය Path.Combineසමග, Uriඉදිකිරීමටත්.

 Uri baseUri = new Uri("http://MyUrl.com");
 string path = Path.Combine("Images", "Image.jpg");
 Uri myUri = new Uri(baseUri, path);

එය වටින දේ සඳහා, මෙහි දිගු කිරීමේ ක්‍රම කිහිපයක්. පළමුවැන්න මාර්ග ඒකාබද්ධ කරන අතර දෙවැන්න URL වෙත පරාමිතීන් එක් කරයි.

    public static string CombineUrl(this string root, string path, params string[] paths)
    {
        if (string.IsNullOrWhiteSpace(path))
        {
            return root;
        }

        Uri baseUri = new Uri(root);
        Uri combinedPaths = new Uri(baseUri, path);

        foreach (string extendedPath in paths)
        {
           combinedPaths = new Uri(combinedPaths, extendedPath);
        }

        return combinedPaths.AbsoluteUri;
    }

    public static string AddUrlParams(this string url, Dictionary<string, string> parameters)
    {
        if (parameters == null || !parameters.Keys.Any())
        {
            return url;
        }

        var tempUrl = new StringBuilder($"{url}?");
        int count = 0;

        foreach (KeyValuePair<string, string> parameter in parameters)
        {
            if (count > 0)
            {
                tempUrl.Append("&");
            }

            tempUrl.Append($"{WebUtility.UrlEncode(parameter.Key)}={WebUtility.UrlEncode(parameter.Value)}");
            count++;
        }

        return tempUrl.ToString();
    }