Path.Combine for URL?

Path.Combine yra patogu, tačiau ar yra panašios funkcijos .NET platformoje?

Ieško tokios sintaksės:

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

kuris grąžins:

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

1079
17 дек. Nustatė Brian MacKay gruodžio 17 d 2008-12-17 00:42 '08 0:42 2008-12-17 00:42
@ 33 atsakymai
  • 1
  • 2

Aukščiau yra Todd Meniere komentaras, kad Flurl apima Url.Combine.

Daugiau informacijos:

„Url.Combine“ iš esmės yra „Path.Combine“ URL, kuriame vienas ir tik vienas atskyrimo simbolis tarp dalių:

 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> 

Gaukite „ Flurl.Http“ svetainėje „NuGet“ :

PM> Įdiekite paketą Flurl.Http

Arba galite gauti atskirą URL konstruktorių be HTTP funkcijų:

PM> „Flurl“ diegimo paketas

7
13 апр. Atsakyti Michael Freidgeim Bal 13 2018-04-13 09:00 '18, 9:00, 2018-04-13 09:00

Uri yra konstruktorius, kuris turėtų tai padaryti už jus: new Uri(Uri baseUri, string relativeUri)

Štai pavyzdys:

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

Redaktoriaus pastaba: būkite atsargūs, šis metodas neveikia tinkamai. Kai kuriais atvejais jis gali iškirpti pagrindinę dalį. Žr. Komentarus ir kitus atsakymus.

1045
06 окт. Atsakyti Joel Beckham Oct 6 2009-10-06 22:37 '09, 10:37 pm 2009-10-06 22:37

Jūs naudojate 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); } 

Grįš:

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

135
17 дек. atsakymą pateikė „ Ryan Cook “ 17 d. 2008-12-17 00:49 '08 at 12:49 2008-12-17 00:49

Tai gali būti gana paprastas sprendimas:

 public static string Combine(string uri1, string uri2) { uri1 = uri1.TrimEnd('/'); uri2 = uri2.TrimStart('/'); return string.Format("{0}/{1}", uri1, uri2); } 
129
25 сент. Matthew Sharpe atsakymas, rugsėjo 25 d 2009-09-25 13:29 '09, 13:29, 2009-09-25 13:29

Čia jau yra puikių atsakymų. Remiantis mdsharpe išlyga, jis naudoja išplėtimo metodą, kuris gali būti lengvai naudojamas, kai norite tvarkyti „Uri“ atvejus:

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

Ir naudojimo pavyzdys:

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

Tai sukurs http://example.com/subpath/part1/part2

110
03 нояб. atsakymą pateikė Ales Potocnik Hahonina 03.11 . 2011-11-03 13:20 '11, 13:20, 2011-11-03 13:20

Ryan Cook atsakymas yra artimas tai, ko man reikia, ir gali būti tinkamesnis kitiems kūrėjams. Tačiau linijos pradžioje jis prideda http: //, o apskritai jis šiek tiek labiau formatuojasi nei po.

Be to, mano naudojimo atvejais santykinių takų apibrėžimas nėra svarbus.

„Mdsharp“ atsakyme taip pat pateikiama gera idėja, nors, įgyvendindama ją, ji užtruko dar keletą detalių. Tai yra bandymas tai paaiškinti (ir aš jį naudoju gamyboje):

Su #

 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 atsakė Brian MacKay gegužės 11 d., 10 val. 0:53 2010-05-11 00:53

Remdamiesi pateiktu pavyzdžio URL , manau, kad norite sujungti su jūsų svetaine susijusius URL.

Remdamasi šia prielaida, pasiūlysiu šį sprendimą kaip tinkamiausią atsakymą į jūsų klausimą: „Path.Combine yra patogu, ar yra panaši funkcija URL struktūroje?“

Kadangi URL struktūra yra panaši, siūlau teisingą metodą: „VirtualPathUtility.Combine“. Čia yra nuoroda į MSDN: VirtualPathUtility.Combine metodas

Yra vienas įspėjimas: manau, kad tai veikia tik su jūsų svetaine susietais URL (tai yra, jūs negalite naudoti jos kurti nuorodas į kitą svetainę. Pavyzdžiui, var url = VirtualPathUtility.Combine("www.google.com", "accounts/widgets"); ).

32
28 марта '10 в 3:21 2010-03-28 03:21 atsakymą pateikė Jeronimo Kolonas III kovo 28 d. 10 val. 03:21 2010-03-28 03:21

Path.Combine man neveikia, nes gali būti simbolių, pvz. užklausos argumento argumentuose ir, t. y., URL, kuris bus „ArgumentException“.

Pirma, bandžiau naudoti naująjį „ Uri(Uri baseUri, string relativeUri) metodą Uri(Uri baseUri, string relativeUri) , kurio nepavyko dėl URI, pvz., http://www.mediawiki.org/wiki/Special:SpecialPages :

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

dėl Specialiųjų: Specialūs puslapiai, atsiradę po dvitaškio po Special žymėjimo schemos.

Taigi pagaliau turėjau pasirinkti maršrutą mdsharpe / Brian MacKays, ir aš šiek tiek toliau sukūriau, kad galėčiau dirbti su keliomis URI dalimis:

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

Naudojimas: „ CombineUri("http://www.mediawiki.org/", "wiki", "Special:SpecialPages")

28
15 июля '11 в 11:17 2011-07-15 11:17 atsakymą pateikė Mike Fuchs liepos 15 d. 11 val. 11:17 2011-07-15 11:17
 Path.Combine("Http://MyUrl.com/", "/Images/Image.jpg").Replace("\\", "/") 
22
12 янв. Atsakymą pateikė JeremyWeir 12 sausis 2011-01-12 00:41 '11 prie 0:41 2011-01-12 00:41

Aš tiesiog sudėjau nedidelį išplėtimo būdą:

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

Jis gali būti naudojamas taip:

 "www.example.com/".UriCombine("/images").UriCombine("first.jpeg"); 
15
25 нояб. atsakymas duotas urza 25 lapkričio. 2010-11-25 11:43 '10, 11:43, 2010-11-25 11:43

Išmintingas pavyzdys, Ryanas, baigdamas nuorodą į funkciją. Gerai padaryta.

Viena „Brian“ rekomendacija: jei uždarote šį kodą funkcijoje, galite naudoti „UriBuilder“, kad susietumėte pagrindinį URL, prieš skambindami „TryCreate“.

Priešingu atveju pagrindiniame URL turi būti schema (kur UriBuilder skaitys http: //). Tik mintis:

 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 atsakymą pateikė mtazva, liepos 30 d. , 09:18, 2009-07-30 18:08

Daugelio URL dalių derinimas gali būti šiek tiek sudėtingesnis. Galite naudoti dviejų parametrų Uri(baseUri, relativeUri) konstruktorių Uri(baseUri, relativeUri) arba naudingumo funkciją Uri.TryCreate() .

Bet kokiu atveju, galiausiai galite grąžinti neteisingą rezultatą, nes šie metodai tęsia baseUri santykines dalis iš pirmojo parametro „ baseUri , ty iš kažko panašaus į http://google.com .

Kad galėtumėte sujungti kelias dalis į galutinį URL, galite kopijuoti dvi toliau nurodytas funkcijas:

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

Visą kodą su vienetiniais bandymų demonstravimo tikslais galima rasti https://uricombine.codeplex.com/SourceControl/latest#UriCombine/Uri.cs.

Turiu vieneto testus, kurie apima tris dažniausiai pasitaikančius atvejus:

2019

8
01 мая '14 в 1:21 2014-05-01 01:21 atsakymas pateikiamas Believe2014 01 Gegužės 14 d. 1:21 2014-05-01 01:21

Radau, kad „ UriBuilder tikrai gerai UriBuilder tokiam dalykui:

UriBuilder“ klasėje - MSDN . 

7
22 мая '13 в 15:19 2013-05-22 15:19 Atsakymas pateikiamas javajavajavajavajava gegužės 22 d., 13 val. 15:19 2013-05-22 15:19

Paprastas būdas juos sujungti ir įsitikinti, kad jie teisingi:

 string.Format("{0}/{1}", Url1.Trim('/'), Url2); 
6
13 мая '10 в 0:42 2010-05-13 00:42 atsakymas suteiktas Alex 13 d. 10 val. 0:42 2010-05-13 00:42

Čia yra „Microsoft“ („OfficeDev PnP“) „ UrlUtility.Combine“ metodas :

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

Šaltinis: GitHub

4
01 нояб. atsakymas pateiktas vartotojo3638471 lapkritis 01 2015-11-01 21:34 '15 - 21:34 2015-11-01 21:34

Manau, kad tai yra naudinga ir turi šias funkcijas:

  • Mesti į nulį arba erdvę
  • Priima kelių parametrų parametrus keliems URL segmentams.
  • sukasi į nulį arba tuščias

Mokymo klasė

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

bandymai

 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 февр. Atsakymą pateikė TheGeneral 28 Feb. 2017-02-28 05:11 '17, 5:11 am 2017-02-28 05:11

Sukūriau šią funkciją, kuri palengvins jūsų gyvenimą:

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

Jis veikia tiek URL, tiek paprastiems keliams.

Naudoti:

  // 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 atsakymą pateikė bigworld12 liepos 21 d. 16 , 19:19 2016-07-21 21:19

Mano bendras sprendimas yra:

 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 Atsakymą pateikė Alex Titarenko gegužės 17 d. 15 val. 10:52 2015-05-17 10:52

Naudoti:

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

Privalumas yra tas, kad jis elgiasi lygiai taip, kaip Path.Combine .

1
18 февр. TruthOf42 paskelbė vasario 18 d 2014-02-18 18:31 '14 at 18:31 2014-02-18 18:31

Štai mano požiūris, ir aš jį naudosiu sau:

 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 авг. Atsakyti Amit Bhagat 03 rug. 2013-08-03 06:39 '13, 6:39, 2013-08-03 06:39

Taisyklės, kai URL derinamas su URI

Kad būtų išvengta keisto elgesio, yra viena taisyklė:

  • Kelias (katalogas) turi baigtis „/“. Jei kelias baigiasi be „/“, paskutinė dalis bus traktuojama kaip failo pavadinimas ir bus sujungta bandant sujungti su kita URL dalimi.
  • Yra viena išimtis: bazinis URL (be informacijos apie katalogą) neturėtų baigtis „/“
  • dalis kelio neturi prasidėti „/“. Jei jis prasideda „/“, string.Empty esamą santykinę informaciją iš URL yra ištrinta ... pridedant string.Empty kelią į string.Empty dalis taip pat pašalins santykinį katalogą iš URL!

Jei laikotės anksčiau pateiktų taisyklių, galite sujungti URL su toliau pateiktu kodu. Priklausomai nuo jūsų situacijos, URL galite pridėti kelias „katalogo“ dalis.

  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 апр. atsakymas pateiktas baHI 05 balandžio 2016-04-05 08:04 '16 at 8:04 2016-04-05 08:04

Kodėl gi ne tik naudokite šiuos dalykus.

 System.IO.Path.Combine(rootUrl, subPath).Replace(@"\", "/") 
1
17 нояб. Atsakymą pateikė Andreas . 2017-11-17 16:11 '17 at 16:11 2017-11-17 16:11

Naudokite:

 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 дек. Atsakymas, kurį pateikė Martin Murphy Dec 10. 2012-12-10 18:31 '12 at 18:31 pm 2012-12-10 18:31

Sujungiau visus ankstesnius atsakymus:

  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 апр. atsakymas pateikiamas per G 25 balandį. 2013-04-25 13:51 '13, 13:51, 2013-04-25 13:51

Na, aš tiesiog sujungiu dvi eilutes ir naudoju reguliarias išraiškas.

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

Taigi galite jį naudoti taip:

  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 atsakymą pateikė Marcio Martins gegužės 16 d. 14:49 2014-05-16 02:49

Šį kodą naudoju problemai išspręsti:

 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 дек. Atsakymą pateikė Joshua Smith, gruodžio 4 d. 2015-12-04 02:17 '15 at 2:17 2015-12-04 02:17

Paprastas vienas įdėklas:

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

Įkvėptas atsakymu @ Mat Sharpe.

0
06 нояб. atsakymą pateikė Nick N. 06 lapkričio. 2017-11-06 15:41 '17 at 15:41 2017-11-06 15:41

Naudojame tokį paprastą pagalbininko metodą, kad galėtume susieti savavališką URL dalių skaičių:

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

Atkreipkite dėmesį, kad ji nepalaiko „../../something/page.htm'-style“ santykinių URL!

0
22 марта '18 в 17:19 2018-03-22 17:19 pholpar atsakymas buvo pateiktas kovo 22 d. 18 val. 17:19 2018-03-22 17:19

Abu šie darbai:

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

Or

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

Ty jei

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

ir taip pat

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

Kai kurios toliau nurodytos klaidos:

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

Radau, kad konstruktorius Uri atsiveria į „/“. Taip pat galite naudoti „ Path.Combine su Uri konstruktoriumi.

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

Kiti klausimai apie žymes arba Ask a question