Path.Combine URLs के लिए?


1243

Path.Combine आसान है, लेकिन क्या URL के लिए .NET फ्रेमवर्क में एक समान कार्य है ?

मैं इस तरह से वाक्यविन्यास की तलाश कर रहा हूं:

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

जो वापस आएगा:

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


14
Flurl में एक Url.Combineविधि शामिल है जो कि बस ऐसा करती है।
टोड मेनियर

2
दरअसल, // वेबसाइट या सर्वर के राउटिंग द्वारा नियंत्रित किया जाता है न कि ब्राउजर द्वारा। यह वह भेजेगा जो आप एड्रेस बार में रखते हैं। इसीलिए जब हम http: // की जगह htp टाइप करते हैं तो हमें प्रॉब्लम आती है: // तो // कुछ साइट्स पर बड़ी प्रॉब्लम हो सकती है। मैं एक क्रॉलर के लिए एक .dll लिख रहा हूं, जो एक विशेष वेबसाइट को संभालता है जो कि url में // 404 फेंकता है।
डेव गॉर्डन

जवाबों:


73

वहाँ ऊपर एक टोड 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" 

Flurl.Http प्राप्त करें NuGet पर :

पीएम> इंस्टाल-पैकेज फ्लर्ल.हॉट्प

या HTTP सुविधाओं के बिना स्टैंड-अलोन URL बिल्डर प्राप्त करें :

PM> इंस्टाल-पैकेज फ्लूरल


4
ठीक है, इस प्रश्न को बहुत अधिक ट्रैफ़िक मिलता है, और 1000+ अपवोट के साथ उत्तर वास्तव में सभी मामलों में काम नहीं करता है। वर्षों बाद, मैं वास्तव में इसके लिए फ्लूरल का उपयोग करता हूं, इसलिए मैं इसे स्वीकार कर रहा हूं। यह मेरे द्वारा सामना किए गए सभी मामलों में काम करता है। अगर लोग निर्भरता नहीं लेना चाहते हैं, तो मैंने एक जवाब पोस्ट किया है जो ठीक काम करता है।
ब्रायन मैकके

और अगर आप का उपयोग नहीं करते हैं Flurlऔर एक हल्के संस्करण, github.com/jean-lourenco/UrlCombine
lizzy91

1156

Uri एक निर्माणकर्ता को आपके लिए यह करना चाहिए: new Uri(Uri baseUri, string relativeUri)

यहाँ एक उदाहरण है:

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

संपादक से ध्यान दें: खबरदार, यह विधि अपेक्षा के अनुरूप काम नहीं करती है। यह कुछ मामलों में बेसयूरी का हिस्सा काट सकता है। टिप्पणियाँ और अन्य उत्तर देखें।


369
मुझे उरी वर्ग का उपयोग पसंद है, दुर्भाग्य से यह पाथ की तरह व्यवहार नहीं करेगा। जैसा कि ओपी ने पूछा था। उदाहरण के लिए नई उरी (नई उरी (" test.com/mydirectory/" ), "/helloworld.xx")। ToString () आपको " test.com/helloworld.aspx " देता है ; यदि हम एक पाथ.कोम्बाइन शैली का परिणाम चाहते हैं तो यह गलत होगा।
डॉक्टर जोन्स

195
यह सभी स्लैश में है। यदि सापेक्ष पथ भाग स्लैश के साथ शुरू होता है, तो यह आपके द्वारा वर्णित के रूप में व्यवहार करता है। लेकिन, यदि आप स्लैश को छोड़ देते हैं, तो यह आपके काम करने के तरीके (दूसरे पैरामीटर पर लापता स्लैश को नोट करेगा): नया उरी (नया उरी (" test.com/mydirectory/" ), "helloworld.aspx" ) .ToString () " test.com/mydirectory/helloworld.aspx " में परिणाम । पथ.कम्बाइन समान व्यवहार करता है। यदि सापेक्ष पथ पैरामीटर स्लैश से शुरू होता है, तो यह केवल सापेक्ष पथ लौटाता है और उन्हें संयोजित नहीं करता है।
जोएल बेकहम

70
यदि आपका बेसयूरी "test.com/mydirectory/mysubdirectory" हुआ, तो परिणाम "test.com/mydirectory/helloworld.aspx" के बजाय "test.com/mydirectory/helloworld.aspx" होगा। सूक्ष्म अंतर पहले पैरामीटर पर अनुगामी स्लैश की कमी है। मैं सभी मौजूदा ढांचे के तरीकों का उपयोग करने के लिए हूं, अगर मुझे वहां पहले से ही पीछे चल रहा है तो मुझे लगता है कि partUrl1 + partUrl2 करने से बहुत कम बदबू आती है - मैं संभावित रूप से सभी के लिए उस अनुगामी स्लेश दौर का पीछा करते हुए हो सकता है स्ट्रिंग कॉन्फैट न करने की खातिर।
कार्ल

63
केवल एक ही कारण है कि मैं एक यूआरआई संयोजन विधि चाहता हूं ताकि मुझे अनुगामी स्लैश की जांच न करनी पड़े। यदि आपका एप्लिकेशन रूट पर है, लेकिन '/ foo' है, तो यह 'नहीं' है।
निक नेम

24
मैं -1 जवाब देता हूं क्योंकि यह समस्या का जवाब नहीं देता है। जब आप url को संयोजित करना चाहते हैं, जैसे जब आप Path.Combine का उपयोग करना चाहते हैं, तो आप अनुगामी / के बारे में परवाह नहीं करना चाहते हैं। और इसके साथ, आपको ध्यान रखना होगा। मैं ब्रायन मैकके के समाधान या ऊपर mdsharpe को पसंद करता हूं
बैपटिस्ट पेर्नेट

160

यह एक उपयुक्त सरल उपाय हो सकता है:

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

7
+1: हालाँकि यह सापेक्ष-शैली पथ (../../whatever.html) को संभालता नहीं है, मुझे इसकी सादगी पसंद है। मैं '\' वर्ण के लिए ट्रिम्स भी जोड़ूंगा।
ब्रायन मैकके

3
इस के एक और पूरी तरह से fleshed बाहर संस्करण के लिए मेरा जवाब देखें।
ब्रायन मैकके

149

आप उपयोग करें 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


53
+1: यह अच्छा है, हालांकि मुझे आउटपुट पैरामीटर के साथ एक तर्कहीन समस्या है। ;)
ब्रायन मैकके

10
@ ब्रायन: यदि यह मदद करता है, तो सभी एक्सएक्सएक्सएक्सएक्सएक्स तरीकों ( int.TryParse, DateTime.TryParseExact) में यह आउटपुट पैराम है , जिससे कि अगर-स्टेटमेंट में उनका उपयोग करना आसान हो। Btw, आपको वैरिएबल को इनिशियलाइज़ करने की ज़रूरत नहीं है क्योंकि रेयान ने इस उदाहरण में किया था।
हाबिल

41
यह जवाब जोएल के : जुड़ने के रूप में एक ही समस्या से ग्रस्त है test.com/mydirectory/और /helloworld.aspxइसके परिणामस्वरूप आप test.com/helloworld.aspxजो चाहते हैं वह प्रतीत नहीं होता है।
मैट कोकाज

3
नमस्ते, यह अनुसरण करने में विफल रहा: अगर (Uri.TryCreate (नया Uri (" लोकलहोस्ट / MyService /" ), "/ इवेंट / SomeMethod? Abc = 123", आउट परिणाम)) {Console.WritLine (परिणाम); } यह मुझे परिणाम के रूप में दिखा रहा है: लोकलहोस्ट / इवेंट / SomeMethod? Abc = 123 नोट: "http: //" को बेस उरई से
स्टैकओवरफ्लो

3
@FaisalMq यह सही व्यवहार है, क्योंकि आपने रूट-रिलेटिव सेकंड पैरामीटर पास किया है। यदि आपने दूसरे पैरामीटर पर अग्रणी / छोड़ दिया है, तो आपको वह परिणाम मिल जाएगा जिसकी आपको उम्मीद थी।
टॉम लिंट

127

यहाँ पहले से ही कुछ बेहतरीन जवाब हैं। मैड्राप सुझाव के आधार पर, यहां एक विस्तार विधि है जिसे आसानी से उपयोग किया जा सकता है जब आप उरी उदाहरणों से निपटना चाहते हैं:

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 का उत्पादन करेगा


2
यह समाधान एक UriUtils.Combine ("बेस url", "part1", "part2", ...) लिखने के लिए तुच्छ बनाता है स्थैतिक विधि जो Path.Combine () के समान है। अच्छा!
कोणीय

रिश्तेदार URI का समर्थन करने के लिए मुझे Uri कंस्ट्रक्टर में AbsoluteUri और UriKind.AbsoluteOrRelative के बजाय ToString () का उपयोग करना पड़ा।
कोणीयसेन

रिश्तेदार Uris के बारे में टिप के लिए धन्यवाद। दुर्भाग्य से उरी रिश्तेदार रास्तों से निपटना आसान नहीं बनाता है क्योंकि इसमें हमेशा अनुरोध के बारे में कुछ जानकारी होती है। शायद आप एक आधार के रूप में नए उड़ी (HttpContext.Current.Request.ApplicationPath) का उपयोग करने की कोशिश कर सकते हैं और इस पर सिर्फ एपेंड को बुला सकते हैं? यह आपको पूर्ण मार्ग देगा लेकिन साइट संरचना में कहीं भी काम करना चाहिए।
एल्स पोटोकनिक हाहोनिना

महान। खुशी है कि इसने किसी और की मदद की। पिछले कुछ समय से इसका उपयोग किया जा रहा है और इसमें कोई समस्या नहीं है।
एल्स पोटोकनिक हाहोनिना

मैंने यह भी कहा कि अगर कोई भी रास्ता नहीं है, तो चेक को शून्य या खाली स्ट्रिंग नहीं है।
n.podbielski

91

रेयान कुक का जवाब, जो मैं कर रहा हूं उसके करीब हूं और अन्य डेवलपर्स के लिए अधिक उपयुक्त हो सकता है। हालाँकि, यह स्ट्रिंग की शुरुआत में 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

4
विवरण की बात करना: ArgumentNullException("url1")यदि तर्क है तो अनिवार्य के बारे में क्या Nothing? क्षमा करें, बस picky ;-)। ध्यान दें कि एक बैकस्लैश का यूआरआई में कोई लेना-देना नहीं है (और अगर यह वहां है, तो इसे ट्रिम नहीं किया जाना चाहिए), इसलिए आप इसे अपने ट्राइमेक्सएक्सएक्सएक्सएक्स से हटा सकते हैं।
हाबिल

4
आप params string [] का उपयोग कर सकते हैं और 2 से अधिक संयोजनों की अनुमति देने के लिए उन्हें पुन: जोड़ सकते हैं
Jaider

4
मुझे यकीन है कि यह बेस क्लास लाइब्रेरी में पाथ.कॉम्बिन की तरह था।
Uriah Blatherwick

1
@MarkHurd मैंने कोड को फिर से संपादित किया, ताकि यह व्यवहारिक रूप से C # के समान हो, और वाक्यविन्यास समान हो।
JJS

1
@BrianMacKay मैंने इसे तोड़ दिया, मार्खर्ड ने मेरी गलती बताई और वापस लुढ़का, मैंने फिर से अपडेट किया ... चीयर्स
JJS

36

Path.Combine मेरे लिए काम नहीं करता है क्योंकि वहाँ वर्ण हो सकते हैं जैसे "|" QueryString तर्कों में और इसलिए URL, जिसके परिणामस्वरूप एक तर्क होगा।

मैंने पहली बार नए Uri(Uri baseUri, string relativeUri)दृष्टिकोण की कोशिश की , जो यूआरआई के कारण मेरे लिए असफल रहा जैसे http://www.mediawiki.org/wiki/Special:SpecialPages:

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

विशेष में परिणाम होगा: विशेष योजनाएं, क्योंकि इसके बाद बृहदान्त्र Specialएक योजना को दर्शाता है।

इसलिए मुझे आखिरकार mdsharpe / Brian MacKays मार्ग लेना पड़ा और इसे कई URI भागों के साथ काम करने के लिए थोड़ा और विकसित किया:

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")


1
+1: अब हम बात कर रहे हैं ... मैं इसे आज़माने जा रहा हूँ। यह नया स्वीकृत उत्तर होने के कारण भी समाप्त हो सकता है। नई उरी () विधि की कोशिश करने के बाद मुझे वास्तव में यह पसंद नहीं है। बहुत बारीक।
ब्रायन मैकके

मुझे ठीक इसी की आवश्यकता थी! देखभाल करने का कोई प्रशंसक नहीं था जहाँ मैंने ट्रेलिंग स्लैश वगैरह डाल दिए ...
Gromer

नल चेकिंग में रोल करने के लिए +1 करें ताकि वह फूले नहीं।
नाइटऑवल 88

काउंट () की लंबाई होनी चाहिए ताकि आपको उसके लिए सिर्फ अपनी लाइब्रेरी में लिनक को शामिल करने की जरूरत न पड़े।
PRMan

यह ठीक वही है जिसकी मुझे तलाश थी।
ThePeter

34

आपके द्वारा प्रदान किए गए नमूना URL के आधार पर , मैं मानने वाला हूं कि आप अपनी साइट के सापेक्ष URL जोड़ना चाहते हैं।

इस धारणा के आधार पर मैं इस समाधान को आपके प्रश्न के सबसे उपयुक्त उत्तर के रूप में प्रस्तावित करूंगा जो था: "Path.Combine आसान है, क्या URL के लिए ढांचे में एक समान कार्य है?"

चूंकि URL के लिए फ्रेमवर्क में समान कार्य है, मैं सही प्रस्तावित करता हूं: "VirtualPathUtility.Combine" विधि। यहाँ MSDN संदर्भ लिंक है: VirtualPathUtility.Combine विधि

एक चेतावनी है: मेरा मानना ​​है कि यह केवल आपकी साइट के सापेक्ष URL के लिए काम करता है (अर्थात, आप इसका उपयोग किसी अन्य वेब साइट के लिंक बनाने के लिए नहीं कर सकते। उदाहरण के लिए, var url = VirtualPathUtility.Combine("www.google.com", "accounts/widgets");)।


+1 क्योंकि यह वही है जो मैं देख रहा हूँ, हालाँकि यह आदर्श होगा यदि यह किसी पुराने यूआरएल के लिए काम करेगा। मैं दुहराता हूं कि यह जितना सुंदर होगा उतना ही ज्यादा सुंदर होगा।
ब्रायन मैकके

2
कैविट सही है, यह पूर्ण रूप से पेशाब के साथ काम नहीं कर सकता है और परिणाम हमेशा जड़ से सापेक्ष होता है। लेकिन इसका एक अतिरिक्त लाभ है, यह टिल्ड को संसाधित करता है, जैसे कि "~ /"। यह इसे Server.MapPathऔर संयोजन के लिए एक शॉर्टकट बनाता है ।
हाबिल

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

12
path.Replace(Path.DirectorySeparatorChar, '/');
22

5
path.Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)
स्लीवरनिंजा - MSFT

1
इसे करने के लिए wrk u को पहले / दूसरे arg अर्थात "/ Images" को हटाना होगा - / Path.Combine (" Http://MyUrl.com ", "Images / Image.jpg")
प्रति G

8
@SliverNinja यह सही नहीं है इस क्षेत्र का मान UNIX पर एक बैकस्लैश ('\') और विंडोज और मैकिन्टोश ऑपरेटिंग सिस्टम पर एक स्लैश ('/') है। लिनक्स सिस्टम पर मोनो का उपयोग करते समय, आपको गलत विभाजक मिलेगा।
user247702

6
डायरेक्ट्री सेपरेटर पर नज़र गड़ाए हुए सभी याल यह भूल रहे हैं कि स्ट्रिंग्स अब तक आप की तुलना में एक अलग ओएस से आ सकते हैं। बस आगे स्लैश के साथ बैकस्लैश बदलें और आप कवर किए गए हैं।
जेरेमी वीयर

17

मैंने बस एक छोटी सी विस्तार विधि लगाई है:

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

12

फ़ंक्शन के लिंक के साथ समाप्त करने के लिए मजाकिया उदाहरण, रयान। बहुत बढ़िया।

एक सिफारिश ब्रायन: यदि आप एक फ़ंक्शन में इस कोड को लपेटते हैं, तो आप TryCreate कॉल से पहले बेस URL को लपेटने के लिए एक UriBuilder का उपयोग करना चाह सकते हैं।

अन्यथा, आधार URL को योजना में शामिल होना चाहिए (जहां UriBuilder 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");
}

10

उन्हें संयोजित करने और यह हमेशा सही रखने का एक आसान तरीका है:

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

+1, हालाँकि यह mdsharpe के उत्तर के लिए बहुत ही अनुकरणीय है, जिसे मैंने अपने उत्तर में सुधार लिया है। यह संस्करण बहुत अच्छा काम करता है जब तक कि Url2 / या \ के साथ शुरू नहीं होता है, या Url1 गलती से \ _ में समाप्त हो जाता है, या तो एक खाली है! :)
ब्रायन मैकके

9

किसी URL के कई हिस्सों को मिलाना थोड़ा मुश्किल हो सकता है। आप दो-पैरामीटर निर्माता Uri(baseUri, relativeUri)का उपयोग कर सकते हैं, या आप उपयोग कर सकते हैंUri.TryCreate() उपयोगिता फ़ंक्शन का ।

किसी भी स्थिति में, आप एक गलत परिणाम लौटा सकते हैं क्योंकि ये विधियाँ पहले पैरामीटर के सापेक्ष भागों को काटती रहती हैं 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 पर देखे जा सकते हैं।

मेरे पास तीन सबसे आम मामलों को कवर करने के लिए यूनिट परीक्षण हैं:

यहां छवि विवरण दर्ज करें


2
मुझे बहुत अच्छा लग रहा है। हालांकि आप बेहतर स्पष्टता के लिए आई लूप को फॉरच लूप से बदल सकते हैं।
क्रिस मैरिसिक

धन्यवाद क्रिस। मैंने सिर्फ Foreach का उपयोग करने के लिए अपना कोड बदल दिया है।
Believe2014

1
अतिरिक्त सभी प्रयासों के लिए +1। मुझे कुछ उच्चतर वोटों के उत्तर के लिए इस प्रश्न को थोड़ा बनाए रखने की आवश्यकता है, आपने नीचे दिए गए गंटलेट को फेंक दिया है। ;)
ब्रायन मैकके

क्षमा करें, लेकिन पर्याप्त नहीं है। आपके द्वारा दिखाए गए कुछ मामलों में काम करता है, लेकिन अल संयोजन में प्रयोग करने योग्य नहीं है। उदाहरण के लिए, मार्ग में कॉलोन नुकसान पहुंचाएंगे।
गैबोर

क्या आप कृपया इसका उदाहरण दे सकते हैं? मुझे इस मुद्दे को ठीक करने और अगले उपयोगकर्ताओं की मदद करने में खुशी होगी।
Believe2014

7

मैंने पाया UriBuilderकि इस तरह की चीज़ के लिए वास्तव में अच्छी तरह से काम किया है:

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

अधिक निर्माण और प्रलेखन के लिए UriBuilder वर्ग - MSDN देखें ।


4

यहाँ Microsoft ( 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);
    }

स्रोत: गिटहब


ऐसा लगता है कि यह URL के बजाय पथ के लिए हो सकता है।
ब्रायन मैकके

@BrianMacKay इस बात से सहमत है कि यह ऐसा दिखता है, लेकिन यह UrlUtility वर्ग से है और इसका उपयोग URL के संयोजन के संदर्भ में किया जाता है

2
यह स्पष्ट करने के लिए संपादित किया गया कि यह किस वर्ग का है

इस वर्ग का उपयोग करते समय ध्यान रखें, शेष कक्षा में SharePoint विशिष्ट कलाकृतियाँ हैं।
हैरी बेरी

4

मुझे निम्नलिखित उपयोगी लगते हैं और निम्नलिखित विशेषताएं हैं:

  • अशक्त या सफेद स्थान पर फेंकता है
  • paramsकई यूआरएल सेगमेंट के लिए कई पैरामीटर लेता है
  • रिक्त या रिक्त पर फेंकता है

कक्षा

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

@PeterMortensen सम्पादन के लिए धन्यवाद
TheGeneral

परीक्षणों के साथ कुछ मुद्दे: // परिणाम = test1 / test2 / test3 \ 4 के लिए एक और फेंकता परीक्षणों के अंतिम तर्क के बजाय ArgumentNullException देता है
Moriya

3

मेरा सामान्य समाधान:

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

मैंने यह फ़ंक्शन बनाया है जो आपके जीवन को आसान बना देगा:

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

यह यूआरएल के साथ-साथ सामान्य रास्तों के लिए भी काम करता है।

उपयोग:

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

सिर्फ निम्नलिखित का उपयोग क्यों न करें

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

मैं इस के PowerShell संस्करण की तलाश कर रहा था जो कि होगा: [System.IO.Path]::Combine("http://MyUrl.com/","/Images/Image.jpg")हालाँकि यह इसके परिणाम में विफल रहता है /Images/Image.jpg:। /दूसरे सबपाथ से हटा दें और यह काम करता है:[System.IO.Path]::Combine("http://MyUrl.com/","Images/Image.jpg")
अंडर

अच्छा विचार है, लेकिन यह विफल रहता है, जब पैरामीटर में से एक शून्य है।
फोलपर

2

यूआरआई के साथ यूआरएल मिलाते समय नियम

अजीब व्यवहार से बचने के लिए एक नियम का पालन करना है:

  • पथ (निर्देशिका) '/' के साथ समाप्त होना चाहिए। यदि पथ '/' के बिना समाप्त होता है, तो अंतिम भाग को फ़ाइल-नाम की तरह माना जाता है, और जब इसे अगले 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();
        });

2

यदि आप एक तृतीय-पक्ष निर्भरता को जोड़ना नहीं चाहते हैं जैसे कि Flurl या ASP.NET Core (Microsoft.Owin में भी उपलब्ध है) में एक कस्टम एक्सटेंशन विधि बनाएं, तो आप PathStringURI के निर्माण के उद्देश्य से उपयोग कर सकते हैं पथ। आप इस के संयोजन का उपयोग करके अपना पूर्ण URI बना सकते हैं, Uriऔर UriBuilder

इस मामले में, यह होगा:

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

यह आधार URL में विभाजकों को निर्दिष्ट किए बिना आपको सभी घटक भागों को देता है। दुर्भाग्य से, PathStringआवश्यकता है कि /प्रत्येक स्ट्रिंग के लिए तैयार है अन्यथा यह वास्तव में फेंकता है ArgumentException! लेकिन कम से कम आप अपने यूआरआई को निर्दिष्‍ट रूप से एक ऐसे तरीके से निर्मित कर सकते हैं जो आसानी से इकाई-परीक्षण योग्य हो।


2

इसलिए मेरे पास एक और दृष्टिकोण है, जो हर किसी के लिए समान है जिन्होंने UriBuilder का उपयोग किया था।

मैं अपने बेसयूआरएल को विभाजित नहीं करना चाहता था (जिसमें पथ का एक हिस्सा हो सकता है - जैसे http://mybaseurl.com/dev/ ) जैसा कि javajavajavajavajava ने किया था।

निम्नलिखित स्निपेट कोड + टेस्ट दिखाता है।

खबरदार: यह समाधान मेजबान को कम करता है और एक बंदरगाह को जोड़ता है। यदि यह वांछित नहीं है, तो कोई 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 कोर 2.1 के साथ परीक्षण किया गया।

यह काम क्यों करता है?

भले ही Path.CombineBackslashes (Windows atleast पर) वापस आ जाएगा, लेकिन UriBuilder इस मामले को सेटर में संभालता है Path

Https://github.com/dotnet/corefx/blob/master/src/System.PStreet.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;
      }
 }

क्या यह सबसे अच्छा तरीका है?

निश्चित रूप से यह समाधान बहुत आत्म वर्णन है (कम से कम मेरी राय में)। लेकिन आप अनिर्दिष्ट (भरोसेमंद कम से कम मुझे त्वरित Google खोज के साथ कुछ भी नहीं मिला) पर भरोसा कर रहे हैं। .NET एपीआई से "सुविधा"। यह भविष्य के रिलीज के साथ बदल सकता है इसलिए कृपया टेस्ट के साथ विधि को कवर करें।

Https://github.com/dotnet/corefx/blob/master/src/System.PStreet.Uri/tests/FunctionalTests/UriBuilderTests.cs ( Path_Get_Set) पर परीक्षण होते हैं , जो \सही ढंग से रूपांतरित होने पर जांच करते हैं।

साइड नोट: व्यक्ति UriBuilder.Uriसीधे प्रॉपर्टी के साथ भी काम कर सकता है , अगर यूटीआई का उपयोग System.Urictor के लिए किया जाएगा ।


यह एक बहुत ही विश्वसनीय दृष्टिकोण है। यूनिट परीक्षण के लिए अंगूठे !!
6

2

किसी के लिए जो एक-लाइनर की तलाश में है और बस एक नई विधि बनाने या एक नए पुस्तकालय का संदर्भ दिए बिना एक पथ के कुछ हिस्सों में शामिल होना चाहता है या एक यूआरआई मूल्य का निर्माण करता है और इसे एक स्ट्रिंग में परिवर्तित करता है, फिर ...

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


1

उपयोग:

    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


1

यहाँ मेरा दृष्टिकोण है और मैं इसे अपने लिए भी उपयोग करूँगा:

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

यह केवल आपके मामले के लिए स्वीकार्य है। ऐसे मामले हैं जो आपके कोड को तोड़ सकते हैं। इसके अलावा, आपने पथ के भागों का उचित एन्कोडिंग नहीं किया। यह एक बड़ी भेद्यता हो सकती है जब यह क्रॉस साइट स्क्रिप्टिंग हमले की बात आती है।
विश्वास

मैं आपकी बातों से सहमत हूं। कोड को केवल दो url भागों का साधारण संयोजन करना चाहिए।
अमित भगत

1

इसे इस्तेमाल करो:

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
x.StartsWith ("/") &&! x.StartsWith ("http") - http क्यों जाँच करता है? आपको क्या हासिल हुआ
पेंगुइन

अगर यह http से शुरू होता है, तो आप स्लैश को हटाने की कोशिश नहीं करना चाहते हैं।
मार्टिन मर्फी

@BrianMacKay, मुझे यकीन नहीं है कि दो लाइनर वारंट एक यूनिट टेस्ट है, लेकिन अगर आप एक प्रदान करने के लिए स्वतंत्र महसूस करते हैं। ऐसा नहीं है कि मैं पैच या कुछ भी स्वीकार कर रहा हूं, लेकिन सुझाव को संपादित करने के लिए स्वतंत्र महसूस करता हूं।
मार्टिन मर्फी

1

मैंने पाया कि Uriकंस्ट्रक्टर '\' को '/' में फ़्लिप करता है। तो आप कंस्ट्रक्टर के Path.Combineसाथ भी उपयोग कर सकते हैं Uri

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

1

क्या यह मूल्य के लिए है, यहाँ विस्तार विधियों का एक जोड़ा है। पहला एक पथों को संयोजित करेगा और दूसरा 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();
    }

1

जैसा कि अन्य उत्तरों में पाया गया है, या तो नया है Uri()या TryCreate()टिक कर सकता है। हालांकि, आधार उरी के साथ समाप्त होना है /और रिश्तेदार को शुरू नहीं करना है/ ; अन्यथा यह बेस Url के अनुगामी भाग को हटा देगा

मुझे लगता है कि यह सबसे अच्छा एक विस्तार विधि के रूप में किया जाता है, अर्थात

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 सेकंड में एक लाख ऑपरेशन किया। यह ज्यादातर परिदृश्यों के लिए काम करेगा, हालांकि अधिक कुशल होने के लिए, सब कुछ तार के रूप में हेरफेर करना बेहतर है, यह 1 मिलियन संचालन के लिए 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;
}

और अगर आप अभी भी एक यूआरआई लौटना चाहते हैं, तो 1 मिलियन ऑपरेशन के लिए लगभग 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);
}

आशा है कि ये आपकी मदद करेगा।


1

मुझे लगता है कि इससे आपको अधिक लचीलापन मिलना चाहिए क्योंकि आप जितने चाहें उतने पथ खंडों से निपट सकते हैं:

public static string UrlCombine(this string baseUrl, params string[] segments)
=> string.Join("/", new[] { baseUrl.TrimEnd('/') }.Concat(segments.Select(s => s.Trim('/'))));
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.