URL üçün Path.Combine?

Path.Combine rahatdır, amma bir URL üçün .NET platformasında bənzər bir xüsusiyyət varmı?

Bu kimi bir sintaksis axtarıram:

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

qayıdacaq:

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

1079
17 дек. Dekabr 17-də Brian MacKay tərəfindən təyin olundu 2008-12-17 00:42 '08 at 0:42 2008-12-17 00:42
@ 33 cavab
  • 1
  • 2

Üstəgəl Todd Meniere'nin Flurl'un Url.Combine'i ehtiva etdiyi yorumudur.

Daha çox məlumat:

Url.Combine, əsasən, bir URL üçün Path.Combine, parçaları arasında bir və bir ayırıcı xarakter təmin edir:

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

NuGet haqqında Flurl.Http alın:

PM> Install-Package Flurl.Http

HTTP funksiyaları olmadan bağımsız URL qurucusunu əldə edin :

PM> Flurl quraşdırma paketi

7
13 апр. Cavab Michael Freidgeim Apr 13 2018-04-13 09:00 '18 saat 9:00 'da 2018-04-13 09:00' də

Uri bunu sizin üçün edəcəyi bir konstruktur: new Uri(Uri baseUri, string relativeUri)

Burada bir nümunə:

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

Redaktorun Qeydləri: Diqqətli olun, bu üsul düzgün işləmir. Bəzi hallarda, baza əsas hissəsini kəsə bilər. Şərhləri və digər cavabları baxın.

1045
06 окт. Cavab Joel Beckham Oktyabr 6 2009-10-06 22:37 '09 saat 22:37 'da 2009-10-06 22:37

Uri.TryCreate( ... ) istifadə 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); } 

Qayıdacaqlar:

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

135
17 дек. cavab 17 dekabrda Ryan Kuk tərəfindən verilir . 2008-12-17 00:49 '08 at 12:49 2008-12-17 00:49

Bu olduqca sadə bir həll ola bilər:

 public static string Combine(string uri1, string uri2) { uri1 = uri1.TrimEnd('/'); uri2 = uri2.TrimStart('/'); return string.Format("{0}/{1}", uri1, uri2); } 
129
25 сент. Mətn Sharpe tərəfindən verilmiş cavab 25 sentyabr 2009-09-25 13:29 '09 'da 13:29' də 2009-09-25 13:29

Burada çox əla cavablar var. Mdsharpe bəndinə əsasən, Uri nümunələri ilə məşğul olmaq istədiyiniz zaman asanlıqla istifadə edilə bilən bir uzantı metodu istifadə edir:

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

Istifadə nümunəsi:

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

Bu, http://example.com/subpath/part1/part2 saytına gətirib çıxaracaq

110
03 нояб. Cavab Ales Potocnik Hahonina tərəfindən verilir 03 noyabr. 2011-11-03 13:20 '11 'da 13:20' də 2011-11-03 13:20

Ryan Kukun cavabı mənə lazım olan yaxındır və digər developers üçün daha uyğun ola bilər. Ancaq, xəttin başlanğıcına http: // əlavə edir və ümumiyyətlə, daha sonra məndən daha çox formatlaşır.

Mənim istifadə etdiyim hallarda, nisbi yolların müəyyən edilməsi vacib deyil.

Mdsharp'ın cavabı da yaxşı bir fikir fikri içərisindədir, baxmayaraq ki, onun gerçək icrası üçün bir neçə daha ətraflı məlumat aldı. Bu bunu aydınlaşdırmaq cəhdi (və mən istehsalatda istifadə edirəm):

#

 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

 <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 
81
11 мая '10 в 0:53 2010-05-11 00:53 Brian MacKay 11 May '10 'da 0:53 2010-05-11 00:53 cavab verdi

Verdiyiniz nümunənin URL'sinə əsasən, sitenizle əlaqəli URL'leri birləşdirmək istəyirik.

Bu fərziyyəyə əsasən, mən bu suala sualınızın ən uyğun cavabı olaraq təklif edəcəyəm: "Path.Combine rahatdır, URL-lər üçün strukturda oxşar funksiya varmı?"

URL strukturu oxşar funksiyaya sahib olduğundan doğru üsul təklif edirəm: "VirtualPathUtility.Combine". Burada MSDN: VirtualPathUtility.Combine Metodu bağlantısıdır

Bir xəbərdarlıq var: İnanıram ki, bu yalnız saytınıza aid URL-lər üçün işləyir (yəni, başqa bir veb-sayta keçid yaratmaq üçün istifadə edə bilməzsiniz. Məsələn, var url = VirtualPathUtility.Combine("www.google.com", "accounts/widgets"); ).

32
28 марта '10 в 3:21 2010-03-28 03:21 Cavab Jeronimo Colon III tərəfindən 28 Mart 'da 3:21' də verildi 2010-03-28 03:21

Path.Combine mənim üçün işləmir, çünki "|" kimi simvollar ola bilər query parametrinin arqumentləri və, buna görə də URL-də bir ArgumentException ilə nəticələnəcək.

Birincisi, yeni Uri(Uri baseUri, string relativeUri) yaklaşımını Uri(Uri baseUri, string relativeUri) , bu da http://www.mediawiki.org/wiki/Special:SpecialPages kimi URI'ler nedeniyle uğursuz oldu:

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

xüsusi bir nəticə verəcəkdir: Special bir şemanın göstərildikdən sonra Special bir nöqtəyə görə.

Mən nəhayət mdsharpe / Brian MacKays marşrutunu seçmək məcburiyyətində qaldım və bir az daha URI-nin bir neçə hissəsi ilə işləyib hazırladım:

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

İstifadəçi: CombineUri("http://www.mediawiki.org/", "wiki", "Special:SpecialPages")

28
15 июля '11 в 11:17 2011-07-15 11:17 cavab Mike Fuchs tərəfindən 15 iyul '11, 11:17 'də verilir
 Path.Combine("Http://MyUrl.com/", "/Images/Image.jpg").Replace("\\", "/") 
22
12 янв. Cavab Jeremy Weir tərəfindən verilir 12 yanvar 2011-01-12 00:41 '11 at 0:41 2011-01-12 00:41

Yalnız kiçik bir uzatma üsulunu bir araya gətirdim:

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

Bu kimi istifadə edilə bilər:

 "www.example.com/".UriCombine("/images").UriCombine("first.jpeg"); 
15
25 нояб. Cavab verildi 25 noyabr. 2010-11-25 11:43 '10 at 11:43 2010-11-25 11:43

Bir ağıllı nümunə, Ryan, funksiyaya istinad edərək bitir. Bəli.

Brian-dən bir təklif: bu kodu bir funksiyaya bağladığınızda, TryCreate-ə zəng etmədən əvvəl əsas URL-i bağlamaq üçün UriBuilder istifadə edə bilərsiniz.

Əks təqdirdə, əsas URL sxemi (UriBuilder http: // oxuyacaq) daxil etməlidir. Yalnız bir düşüncə:

 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"); } 
11
30 июля '09 в 18:08 2009-07-30 18:08 Cavab 30 iyul 2009 -cu il saat 18 : 00 -da mtazva tərəfindən verilmişdir

URL'nin birdən çox hissəsini birləşdirmək bir az daha mürəkkəb ola bilər. Siz iki parametrli Uri(baseUri, relativeUri) konstruktorunu Uri(baseUri, relativeUri) və ya Uri.TryCreate() kommunal funksiyasından istifadə edə bilərsiniz.

Hər halda, yanlış bir nəticə baseUri nəticələnə bilər, çünki bu üsullar əsas baseUri parametrlərdən, yəni http://google.com/some/thing ünvanında http://google.com kimi bir şeydən, .

Bir neçə hissəni yekun URL birləşdirmək üçün aşağıda iki funksiyanı kopyalaya bilərsiniz:

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

Nümunə istifadə üçün vahid sınaqları olan tam kod https://uricombine.codeplex.com/SourceControl/latest#UriCombine/Uri.cs ünvanından əldə edilə bilər .

Üç ən ümumi halları əhatə edən vahid testlərim var:

2019

8
01 мая '14 в 1:21 2014-05-01 01:21 Cavab verilir Believe2014 01 May '14 da 1:21 2014-05-01 01:21

UriBuilder bu cür bir şey üçün həqiqətən yaxşı UriBuilder tapdım:

UriBuilder Class - MSDN- ə baxın. 

7
22 мая '13 в 15:19 2013-05-22 15:19 cavab javajavajavajavajava 22 may '13 saat 15:19 2013-05-22 15:19 verilir

Onları birləşdirmək və düzgün olduğundan əmin olmaq üçün sadə bir yol:

 string.Format("{0}/{1}", Url1.Trim('/'), Url2); 
6
13 мая '10 в 0:42 2010-05-13 00:42 cavab 13 may 2010 tarixində 0:42 da verildi

İşdə Microsoft (OfficeDev PnP) UrlUtility.Combine metodu :

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

Mənbə: GitHub

4
01 нояб. User3638471 Nov 01 tərəfindən verilmiş cavab 2015-11-01 21:34 '15 'da 21:34' de, 2015-11-01 21:34

Aşağıdakı xüsusiyyətləri tapdım və aşağıdakı xüsusiyyətlərə sahib oldum:

  • Sıfır və ya yerə atır
  • Bir neçə URL seqmenti üçün bir neçə parametrdən params qəbul edir.
  • sıfıra və ya boşa dönür

Təlim kursu

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

testlər

 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 
3
28 февр. Cavab, The Ümumi 28 Fevralda verilir. 2017-02-28 05:11 '17 də 5:11 'də 2017-02-28 05:11' də

Həyatınızı daha asanlaşdıracaq bu funksiyanı yaratdım:

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

Həm URL-lər, həm də adi yollar üçün işləyir.

İstifadə edin:

  // 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 
3
21 июля '16 в 21:19 2016-07-21 21:19 cavabı bigworld12 tərəfindən verilir 21 İyun 21 'da 21:19 2016-07-21 21:19

Mənim ümumi həllim:

 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; } 
3
17 мая '15 в 10:52 2015-05-17 10:52 Cavab Alex Titarenko tərəfindən 17 may tarixində saat 10:52 da verilir 2015-05-17 10:52

İstifadə edin:

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

Üstünlük, Path.Combine kimi davranır.

1
18 февр. TruthOf42 18 fevral göndərdi 2014-02-18 18:31 '14 də 18:31 2014-02-18 18:31

İşdə mənim yanımdır və mən özüm üçün istifadə edəcəyəm:

 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); } 
1
03 авг. Amit Bhagat 03 Aug. 2013-08-03 06:39 '13 'da 6:39' da 2013-08-03 06:39

Bir URI ilə URL birləşdirmək qaydaları

Qəribə davranışın qarşısını almaq üçün bir qayda var:

  • Yol (kataloq) '/' ilə bitməlidir. Yolu "/" olmadan bitirsə, son hissə bir fayl adı kimi qəbul edilir və URL'nin növbəti hissəsi ilə birləşməyə çalışarkən birləşəcək.
  • Bir istisna var: əsas URL (kataloq məlumatı olmadan) '/'
  • yolun bir hissəsi '/' ilə başlamamalıdır. '/' string.Empty başlayırsa, string.Empty olan string.Empty varolan nisbi məlumat silinir. string.Empty Path əlavə string.Empty bölmə də URL-dən nisbi kataloq aradan qaldırılması olacaq!

Yuxarıda göstərilən qaydalara əməl etsəniz, URL-i aşağıdakı kodla birləşdirə bilərsiniz. Vəziyyətinizə bağlı olaraq, URL-də "qovluğun" bir neçə hissəsini əlavə edə bilərsiniz ...

  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(); }); 
1
05 апр. Cavab verilir baHI 05 Apr 2016-04-05 08:04 '16 at 8:04 2016-04-05 08:04

Niyə yalnız aşağıdakıları istifadə etməyin.

 System.IO.Path.Combine(rootUrl, subPath).Replace(@"\", "/") 
1
17 нояб. Cavab 17 noyabrda Andreas tərəfindən verilir. 2017-11-17 16:11 '17 at 16:11 2017-11-17 16:11

Bunu istifadə edin:

 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); } } 
1
10 дек. Martin Murphy tərəfindən verilmiş cavab 10 dekabr. 2012-12-10 18:31 '12 saat 06:31 'da 2012-12-10 18:31

Mən əvvəlki bütün cavabları birləşdirirdim:

  public static string UrlPathCombine(string path1, string path2) { path1 = path1.TrimEnd('/') + "/"; path2 = path2.TrimStart('/'); return Path.Combine(path1, path2) .Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar); } [TestMethod] public void TestUrl() { const string P1 = "http://msdn.microsoft.com/slash/library//"; Assert.AreEqual("http://msdn.microsoft.com/slash/library/site.aspx", UrlPathCombine(P1, "//site.aspx")); var path = UrlPathCombine("Http://MyUrl.com/", "Images/Image.jpg"); Assert.AreEqual( "Http://MyUrl.com/Images/Image.jpg", path); } 
0
25 апр. Cavab Per G 25 apr verilir. 2013-04-25 13:51 '13 da 13:51 2013-04-25 13:51

Bəli, yalnız iki simli birləşdirmək və təmizləmək üçün müntəzəm ifadələr istifadə edirəm.

  public class UriTool { public static Uri Join(string path1, string path2) { string url = path1 + "/" + path2; url = Regex.Replace(url, "(?<!http:)/{2,}", "/"); return new Uri(url); } } 

Beləliklə bunu aşağıdakı kimi istifadə edə bilərsiniz:

  string path1 = "http://someaddress.com/something/"; string path2 = "/another/address.html"; Uri joinedUri = UriTool.Join(path1, path2); // joinedUri.ToString() returns "http://someaddress.com/something/another/address.html" 
0
16 мая '14 в 2:49 2014-05-16 02:49 Cavab Marcio Martins tərəfindən 16 May '14 'də 2:49 2014-05-16 02:49 ' də verilir

Problemi həll etmək üçün bu kodu istifadə etdim:

 string[] brokenBaseUrl = Context.Url.TrimEnd('/').Split('/'); string[] brokenRootFolderPath = RootFolderPath.Split('/'); for (int x = 0; x < brokenRootFolderPath.Length; x++) { //if url doesn't already contain member, append it to the end of the string with / in front if (!brokenBaseUrl.Contains(brokenRootFolderPath[x])) { if (x == 0) { RootLocationUrl = Context.Url.TrimEnd('/'); } else { RootLocationUrl += String.Format("/{0}", brokenRootFolderPath[x]); } } } 
0
04 дек. Cavab Joshua Smith tərəfindən verilir 04 Dekabr. 2015-12-04 02:17 '15 'da 2:17' de, 2015-12-04 02:17

Sadə bir liner:

 public static string Combine(this string uri1, string uri2) => $"{uri1.TrimEnd('/')}/{uri2.TrimStart('/')}"; 

Cavabdan ilhamlanan @Matt Sharpe.

0
06 нояб. Cavab Nick N 06 noyabr tarixində verilir. 2017-11-06 15:41 '17 at 15:41 2017-11-06 15:41

URL'nin kasıb sayıdakı hissəsini birləşdirmək üçün aşağıdakı sadə köməkçi metoddan istifadə edirik:

 public static string JoinUrlParts(params string[] urlParts) { return string.Join("/", urlParts.Where(up => !string.IsNullOrEmpty(up)).ToList().Select(up => up.Trim('/')).ToArray()); } 

'../../Something/page.htm' -style nisbi URL'leri dəstəkləməyəcəyini unutmayın!

0
22 марта '18 в 17:19 2018-03-22 17:19 cavab 22 mart 18: 18-də pharpar tərəfindən verilir

Bu əsərlərin hər ikisi:

  Uri final = new Uri(Regex.Replace(baseUrl + "/" + relativePath, "(?<!http:)/{2,}", "/")); 

Və ya

  Uri final =new Uri(string.Format("{0}/{1}", baseUrl.ToString().TrimEnd('/'), relativePath.ToString().TrimStart('/'))); 

Yəni əgər

 baseUrl = "http://tesrurl.test.com/Int18" 

və həmçinin

 relativePath = "To_Folder" output = http://tesrurl.test.com/Int18/To_Folder 

Aşağıdakı kod üçün bəzi səhvlər görünür:

  // If you use the below code, some issues will be there in the final URI Uri final = new Uri(baseUrl, relativePath); 
0
24 апр. Cavab DAre G 24 apr verilir. 2017-04-24 10:43 '17 'da 10:43' də 2017-04-24 10:43 'da

Qurucu Uri '\' ilə '/' çevirir. Beləliklə, Path.Combine Uri konstruktoru ilə də istifadə edə bilərsiniz.

  Uri baseUri = new Uri("http://MyUrl.com"); string path = Path.Combine("Images", "Image.jpg"); Uri myUri = new Uri(baseUri, path); 
0
30 сент. Cavab verilən skippy 30 Sep 2018-09-30 13:43 '18 saat 13:43 'da 2018-09-30 13:43
  • 1
  • 2

Tags ilə bağlı digər suallar və ya bir sual