ইউআরএলগুলির জন্য পাথ.কোমাইন?


1242

পাথ.কোমাইনটি সুবিধাজনক, তবে ইউআরএলগুলির জন্য .NET ফ্রেমওয়ার্কে কি একই রকম ফাংশন রয়েছে ?

আমি এই জাতীয় বাক্য গঠন খুঁজছি:

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

যা ফিরে আসবে:

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


14
ফ্লারল একটি Url.Combineপদ্ধতি অন্তর্ভুক্ত করে যা কেবল এটি করে।
টড মেনিয়ার

2
আসলে, //টি ওয়েবসাইট বা সার্ভারের রাউটিং দ্বারা পরিচালিত হয় ব্রাউজার দ্বারা নয়। আপনি ঠিকানা বারে যা রেখেছেন তা এটি প্রেরণ করবে। এই কারণেই আমরা HTTP: // এর পরিবর্তে htp: // টাইপ করার সময় সমস্যাগুলি পাই So সুতরাং // কিছু সাইটগুলিতে বড় সমস্যা দেখা দিতে পারে। আমি একটি ক্রলারের জন্য একটি .dll লিখছি যা কোনও নির্দিষ্ট ওয়েবসাইট পরিচালনা করে যা আপনার 40 টি ইউআরএল থাকলে 404 নিক্ষেপ করে।
ডেভ গর্ডন

উত্তর:


72

সেখানে উপরে একটি টড Menier এর মন্তব্য যে Flurl একটি অন্তর্ভুক্ত Url.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" 

নুগেটে ফ্লারল.এইচটিটিপি পান :

প্রধানমন্ত্রী> ইনস্টল-প্যাকেজ ফ্লুরল Hএইচটিটিপি

অথবা এইচটিটিপি বৈশিষ্ট্যগুলি ছাড়াই একা একা ইউআরএল নির্মাতা পান :

প্রধানমন্ত্রী> ইনস্টল-প্যাকেজ ফ্লারল


4
ঠিক আছে, এই প্রশ্নটি প্রচুর ট্র্যাফিক পায় এবং 1000+ আপভোটের উত্তরটি আসলে সব ক্ষেত্রে কার্যকর হয় না। বছরগুলি পরে, আমি এটির জন্য আসলে ফ্লুর্ল ব্যবহার করি, তাই আমি এটি গ্রহণ করছি। মনে হয়েছে যে সমস্ত ক্ষেত্রে আমি মুখোমুখি হয়েছি তা কাজ করে। লোকেরা যদি নির্ভরতা নিতে না চায় তবে আমি একটি উত্তর পোস্ট করেছিলাম যা ভালও কাজ করে।
ব্রায়ান ম্যাকেয়ে

এবং যদি আপনি ব্যবহার করেন না Flurlএবং একটি হালকা ভার্সন ব্যবহার করেন তবে github.com/jean-lourenco/UllCombine
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
আমি উরি ক্লাসের ব্যবহার পছন্দ করি, দুর্ভাগ্যক্রমে এটি পথের মতো আচরণ করবে না OP উদাহরণস্বরূপ নতুন উরি (নতুন উরি (" test.com/mydirectory/" ), "/heelorld.aspx")। টুস্ট্রিং () আপনাকে " test.com/helloworld.aspx " দেয় ; আমরা যদি কোনও পথ চাইতাম তবে এটি ভুল হবে omb কোম্বাইন স্টাইলের ফলাফল।
ডক্টর জোন্স

195
এটি সব কমেছে। যদি আপেক্ষিক পথ অংশটি স্ল্যাশ দিয়ে শুরু হয়, তবে এটি আপনার বর্ণনার মতো আচরণ করে। তবে, যদি আপনি স্ল্যাশটি ছেড়ে দেন, তবে এটি আপনার প্রত্যাশা মতো কাজ করে (দ্বিতীয় প্যারামিটারে অনুপস্থিত স্ল্যাশটি নোট করুন): নতুন উরি (নতুন উরি (" test.com/mydirectory/" )), "হেলিওরল্ড.এএসপিএক্স" ) .ToString () এর ফলাফল " test.com/mydirectory/helloworld.aspx "। পাথ.কোমাইন একই রকম আচরণ করে। যদি আপেক্ষিক পাথার প্যারামিটারটি স্ল্যাশ দিয়ে শুরু হয় তবে এটি কেবল আপেক্ষিক পাথ ফেরত দেয় এবং তাদের সংযুক্ত করে না।
জোয়েল বেকহ্যাম

70
যদি আপনার বেসউরিটি "test.com/mydirectory/mysubdirectory" হয়ে থাকে তবে ফলাফলটি "test.com/mydirectory/mysubdirectory/helloworld.aspx" এর পরিবর্তে "test.com/mydirectory/helloworld.aspx" হবে। সূক্ষ্ম পার্থক্য হ'ল প্রথম প্যারামিটারের পিছনে স্ল্যাশের অভাব। আমি বিদ্যমান ফ্রেমওয়ার্ক পদ্ধতিগুলি ব্যবহার করার জন্য সমস্তই, যদি আমার যদি ইতিমধ্যে সেখানে অনুসরণ করার স্ল্যাশ করতে হয় তবে আমি মনে করি যে পার্টউআরএল 1 + পার্টআরল 2 করার ফলে খুব কম গন্ধ পাওয়া যায় - আমি সম্ভবত কিছুক্ষণের জন্য সেই ট্রেলিং স্ল্যাশ রাউন্ডটিকে তাড়া করতে পেরেছিলাম for স্ট্রিং কনক্যাট না করার খাতিরে।
কার্ল

63
আমি ইউআরআই সম্মিলন পদ্ধতির একমাত্র কারণটি হ'ল আমাকে পিছনের পিছনে স্ল্যাশ পরীক্ষা করতে হবে না। অনুরোধ.এপ্লিকেশনপথটি '/' হ'ল যদি আপনার অ্যাপ্লিকেশনটি মূলে থাকে তবে '/ foo' যদি তা না থাকে।
নিকড

24
আমি এই উত্তরটি -1 কারণ এটি সমস্যার উত্তর দেয় না। আপনি যখন ইউআরএল একত্রিত করতে চান, যেমন আপনি যখন পাথ.কোমাইন ব্যবহার করতে চান তখন আপনি পিছনে / র যত্ন নিতে চান না। এবং এই সঙ্গে, আপনি যত্ন নিতে হবে। আমি উপরে ব্রায়ান ম্যাককে বা এমডিশার্পের সমাধান পছন্দ করি
ব্যাপটিস্ট পার্নেট

160

এটি একটি উপযুক্ত সহজ সমাধান হতে পারে:

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

7
+1: যদিও এটি আপেক্ষিক-স্টাইলের পাথগুলি হ্যান্ডেল করে না (../../wwWWWWShtml), সরলতার জন্য আমি এটি পছন্দ করি। আমি '\' চরিত্রের জন্য ছাঁটাও যুক্ত করব।
ব্রায়ান ম্যাকেয়ে

3
এর আরও সম্পূর্ণরূপে সংস্করণের জন্য আমার উত্তরটি দেখুন।
ব্রায়ান ম্যাকেকে

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) যদি কোনও বিবৃতিতে এটিকে সহজেই ব্যবহার করা যায় তবে এই আউটপুট পরম থাকে। বিটিডব্লিউ, আপনাকে যেমন পরিবর্তনটি আরম্ভ করতে হবে না যেমন রায়ান এই উদাহরণে করেছে।
আবেল

41
এই উত্তরটি জোয়েলের মতো একই সমস্যায় ভুগছে : যোগদান করা test.com/mydirectory/এবং এর /helloworld.aspxফলস্বরূপ আপনি test.com/helloworld.aspxযা চান তা আপাতদৃষ্টিতে দেখাবে না।
ম্যাট কোকাজ

3
হাই, এটি অনুসরণ করার জন্য ব্যর্থ হয়েছে: যদি (উরি.ট্রিক্রিয়েট (নতুন উরি (" লোকালহোস্ট / মাই সার্ভিস /" )), "/ ইভেন্ট / সাম্মেথোড? Abc = 123", ফলাফল)) so কনসোল.উরাইটলাইন (ফলাফল); } এটি আমাকে ফলাফল হিসাবে দেখিয়েছে: লোকালহোস্ট / ইভেন্ট / সামমথোড? Abc = 123 দ্রষ্টব্য: "http: //" এখানে বেস উরি থেকে স্ট্যাকওভারফ্লো দ্বারা প্রতিস্থাপন করা হয়েছে
ফয়সাল এমকিউ

3
@ ফয়সালমিকিউ এটিই সঠিক আচরণ, যেহেতু আপনি মূল-আপেক্ষিক দ্বিতীয় প্যারামিটারটি পাস করেছেন। আপনি যদি প্রথম পরামিতিটি / দ্বিতীয় প্যারামিটারটি ছেড়ে রেখেছিলেন তবে আপনি যে ফলাফলটি প্রত্যাশিত তা পেয়েছেন।
টম লিন্ট

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
এই দ্রবণটি একটি ইউরিউটিলস.কোমাইন ("বেস ইউআরএল", "পার্ট 1", "পার্ট 2", ...) স্ট্যাটিক পদ্ধতি যা প্যাথ.কোমাইন () এর সাথে খুব মিল রয়েছে তা লিখতে তুচ্ছ করে তোলে। নিস!
অ্যাঙ্গুলারসেন

আপেক্ষিক ইউআরআই সমর্থন করতে আমাকে উরি কনস্ট্রাক্টরে অ্যাবসুলিউটরি এবং ইউরিকাইন্ডের পরিবর্তে টসস্ট্রিং () ব্যবহার করতে হয়েছিল।
Angularsen

আপেক্ষিক উরিস সম্পর্কে পরামর্শ দেওয়ার জন্য ধন্যবাদ। দুর্ভাগ্যক্রমে উরি আপেক্ষিক পথগুলি মোকাবেলা করা সহজ করে না কারণ অনুরোধের সাথে সর্বদা কিছু মাতামাতি রয়েছে। অ্যাপ্লিকেশনপথ জড়িত। সম্ভবত আপনি নতুন উরি (HttpContext.Current.Request.applicationPath) কে বেস হিসাবে ব্যবহার করার চেষ্টা করতে পারেন এবং কেবল এটিতে অ্যাপেন্ড কল করতে পারেন? এটি আপনাকে পরমপথ দেবে তবে সাইটের কাঠামোর মধ্যে যে কোনও জায়গায় কাজ করা উচিত।
এলেস পোটোকনিক হাহোনিনা

গ্রেট। খুশী হ'ল এটি অন্য কাউকে সাহায্য করেছে। এটি কিছু সময়ের জন্য এটি ব্যবহার করা হয়েছে এবং কোনও সমস্যা হয়নি।
এলেস পোটোকনিক হাহোনিনা

আমি যুক্ত করেছিলাম যে কোনও পথ জুড়ে রাখার জন্য কোনও পথ নাল নয় বা খালি স্ট্রিং কিনা check
n.podbielski

91

রায়ান কুকের উত্তর আমার পরে যা আছে তার কাছাকাছি এবং অন্যান্য বিকাশকারীদের পক্ষে এটি আরও উপযুক্ত হতে পারে। তবে এটি স্ট্রিংয়ের শুরুতে http: // যুক্ত করে এবং সাধারণভাবে এটি আমার চেয়ে আরও কিছু ফর্ম্যাটিং করে।

এছাড়াও, আমার ব্যবহারের ক্ষেত্রে, আপেক্ষিক পাথগুলি সমাধান করা গুরুত্বপূর্ণ নয়।

mdharp এর উত্তরেও একটি ভাল ধারণার বীজ রয়েছে, যদিও বাস্তব বাস্তবায়নটি আরও কিছু বিশদ প্রয়োজন। এটি একেবারে চেষ্টা করার চেষ্টা (এবং আমি এটি উত্পাদনে ব্যবহার করছি):

সি শার্প

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

এই কোডটি নিম্নলিখিত পরীক্ষায় পাস করেছে, যা ভিবিতে হবে:

<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? দুঃখিত, কেবল বাছাই করা হচ্ছে ;-)। মনে রাখবেন যে ব্যাকস্ল্যাশ-এর ​​ইউআরআই-তে কিছু করার নেই (এবং যদি এটি থাকে তবে এটি ছাঁটাই করা উচিত নয়), যাতে আপনি এটি নিজের ট্রিমএক্সএক্সএক্সএক্স থেকে সরাতে পারেন।
আবেল

4
আপনি প্যারাম স্ট্রিং ব্যবহার করতে পারেন [] এবং 2 টিরও বেশি সংমিশ্রণের জন্য পুনরাবৃত্তভাবে তাদের সাথে যোগ দিন
জয়দার

4
আমি নিশ্চিত যে এটি পাঠ.কোমাইনের মতো বেস ক্লাস লাইব্রেরিতে থাকত।
উরিয়া ব্লাথারউইক

1
@ মার্কহর্ড আমি আবার কোডটি সম্পাদনা করেছি, যাতে এটি আচরণগতভাবে সি # এর মতো এবং সিনট্যাক্টিক্যালি সমতুল্যও।
জেজেএস

1
@ ব্রায়ান ম্যাককে আমি এটিকে ভেঙে দিয়েছি, মারখুরদ আমার ভুলটি নির্দেশ করে পিছনে ফিরে এসেছিল, আমি আবার আপডেট করেছি ... চিয়ার্স
জেজেএস

36

পাথ.কোম্বাইন আমার পক্ষে কাজ করে না কারণ "|" এর মতো অক্ষর থাকতে পারে কোয়েরিস্ট্রিং আর্গুমেন্টে এবং সেইজন্য ইউআরএল, যার ফলে একটি আর্গুমেন্টএক্সেপশন হবে।

আমি প্রথমে নতুন Uri(Uri baseUri, string relativeUri)পদ্ধতির চেষ্টা করেছি , যা ইউআরআইয়ের কারণে আমার পক্ষে ব্যর্থ হয়েছিল http://www.mediawiki.org/wiki/Special:SpecialPages:

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

বিশেষে ফলস্বরূপ: স্পেশাল পৃষ্ঠাগুলি, কারণ কোলনের পরে Specialকোনও স্কিম বোঝায়।

সুতরাং অবশেষে আমাকে mdharpe / ব্রায়ান ম্যাককেজ রুট নিতে হয়েছিল এবং একাধিক ইউআরআই অংশ নিয়ে কাজ করার জন্য এটি আরও কিছুটা এগিয়ে নিয়ে যেতে হয়েছিল:

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: এখন আমরা কথা বলছি ... আমি এটি চেষ্টা করে যাচ্ছি। এটি এমনকি নতুন গৃহীত উত্তর হতে পারে। নতুন উরি () পদ্ধতির চেষ্টা করার পরেও আমি সত্যিই এটি পছন্দ করি না। খুব পাতলা।
ব্রায়ান ম্যাকেকে

এটাই আমার দরকার ছিল! আমি যেখানে
ট্রেলিং

নাল পরীক্ষায় রোলিংয়ের জন্য +1 করুন যাতে এটি ফুরিয়ে যায় না।
নাইটওয়েল 888

গণনা () দৈর্ঘ্য হওয়া উচিত যাতে আপনার জন্য তার লাইব্রেরিতে লিনক অন্তর্ভুক্ত করার দরকার নেই।
PRMan

এটি ঠিক আমি যা খুঁজছিলাম ছিল।
ThePeter

34

আপনার সরবরাহিত নমুনা URL এর ভিত্তিতে , আমি ধরে নিচ্ছি যে আপনি আপনার সাইটের সাথে সম্পর্কিত URL গুলি একত্রিত করতে চান।

এই অনুমানের উপর ভিত্তি করেই আমি আপনার প্রশ্নের সর্বাধিক উপযুক্ত প্রতিক্রিয়া হিসাবে এই সমাধানটি প্রস্তাব করব যা ছিল: "পথ।কোবাইন কার্যকর , ইউআরএলগুলির কাঠামোর ক্ষেত্রে কি একই রকম ফাংশন রয়েছে?"

যেহেতু ইউআরএলগুলির জন্য ফ্রেমওয়ার্কে অনুরূপ ফাংশন রয়েছে তাই সঠিক প্রস্তাবটি হ'ল "ভার্চুয়ালপ্যাথ ইউটিলিটি Cকোমাইন" পদ্ধতি। এখানে এমএসডিএন রেফারেন্স লিঙ্কটি রয়েছে: ভার্চুয়ালপ্যাথ ইউটিলিটি C কোম্বাইন পদ্ধতি

একটি সতর্কতা রয়েছে: আমি বিশ্বাস করি এটি কেবল আপনার সাইটের সাথে সম্পর্কিত ইউআরএলগুলির জন্য কাজ করে (এটি আপনি অন্য কোনও ওয়েবসাইটে লিঙ্ক তৈরি করতে ব্যবহার করতে পারবেন না example উদাহরণস্বরূপ, var url = VirtualPathUtility.Combine("www.google.com", "accounts/widgets");)।


+1 কারণ এটি আমি যা খুঁজছি তার কাছাকাছি, যদিও এটি কোনও পুরানো url এর জন্য কাজ করে তবে আদর্শ হবে ideal আমি দ্বিগুণ এটি mdharpe প্রস্তাবিত চেয়ে অনেক মার্জিত পেতে হবে।
ব্রায়ান ম্যাককে ২৯'১৮

2
ক্যাভিয়েটটি সঠিক, এটি পরম ইউরিসের সাথে কাজ করতে পারে না এবং ফলাফলটি সর্বদা মূল থেকে আপেক্ষিক। তবে এটির একটি অতিরিক্ত উপকার রয়েছে, এটি "~ /" এর মতো টিলড প্রক্রিয়া করে। এটি এটিকে Server.MapPathসংমিশ্রণের জন্য শর্টকাট তৈরি করে।
আবেল

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

12
path.Replace(Path.DirectorySeparatorChar, '/');
জয়দার

5
path.Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)
স্লিভারনিজা - এমএসএফটি

1
এটিকে আরঙ্কিত করতে আপনাকে অবশ্যই প্রথমে / দ্বিতীয় আরগে অবশ্যই "/ চিত্রগুলি" - / পথ.কোমাইন (" HTTP://MyUrl.com ", "চিত্র / চিত্র.জপিজি") মুছে ফেলতে হবে
প্রতি G

8
@ স্লিভারনিঞ্জা এটি সঠিক নয় এই ক্ষেত্রটির মান ইউনিক্সের একটি ব্যাকস্ল্যাশ ('\'), এবং উইন্ডোজ এবং ম্যাকিনটোস অপারেটিং সিস্টেমগুলিতে একটি স্ল্যাশ ('/')। লিনাক্স সিস্টেমে মনো ব্যবহার করার সময়, আপনি ভুল বিভাজকটি পেতে পারেন।
ব্যবহারকারী 247702

6
ডিরেক্টরি বিভাজকটি সন্ধানকারী সমস্ত ইয়েল ভুলে যাচ্ছে যে স্ট্রিংগুলি এখনকার চেয়ে আলাদা OS থেকে আসতে পারে have কেবল ব্যাকস্ল্যাশকে ফরোয়ার্ড স্ল্যাশের সাথে প্রতিস্থাপন করুন এবং আপনি কভার করেছেন।
জেরেমিওয়ের

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

মজাদার উদাহরণ, রায়ান, ফাংশনটির একটি লিঙ্কের সাথে শেষ করতে। সাবাশ.

একটি প্রস্তাবনা ব্রায়ান: আপনি যদি কোনও ফাংশনে এই কোডটি আবদ্ধ করেন, আপনি ট্রাইক্রিয়েট কল করার আগে বেস ইউআরএলটি মোড়ানোর জন্য একটি ইউরিবিল্ডার ব্যবহার করতে চাইতে পারেন।

অন্যথায়, বেস ইউআরএল অবশ্যই স্কিমটি অন্তর্ভুক্ত করবে (যেখানে ইউরিবিল্ডার 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, যদিও এটি mdharpe- এর উত্তরের সাথে খুব সামঞ্জস্যপূর্ণ, যা আমি আমার উত্তরে উন্নতি করেছি। এই সংস্করণটি দুর্দান্ত কাজ করে যদি না url2 / / \ দিয়ে শুরু হয়, বা url1 ঘটনাক্রমে ends এ শেষ হয়, বা হয় একটি খালি থাকে! :)
ব্রায়ান ম্যাকেকে

9

একটি URL এর একাধিক অংশ একত্রিত করা কিছুটা জটিল হতে পারে y আপনি দুটি পরামিতি নির্মাণকারী 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
আমার কাছে বেশ ভালো লাগছে। যদিও আপনি আরও স্পষ্টতার জন্য আই লুপটি ফোরচ লুপের সাথে প্রতিস্থাপন করতে পারেন।
ক্রিস মেরিসিক

ধন্যবাদ ক্রিস। ফরচ ব্যবহার করার জন্য আমি আমার কোডটি পরিবর্তন করেছি।
বিশ্বাস2014

1
সমস্ত অতিরিক্ত প্রচেষ্টা জন্য +1। উচ্চতর ভোট প্রাপ্ত উত্তরের জন্য আমার এই প্রশ্নটি কিছুটা বজায় রাখা দরকার, আপনি গন্টলেটটি ফেলে দিয়েছেন। ;)
ব্রায়ান ম্যাকেয়ে

দুঃখিত, তবে যথেষ্ট নয় আপনি যে কয়েকটি ক্ষেত্রে দেখান তাতে কাজ করে তবে সংমিশ্রণে ব্যবহারের যোগ্য far উদাহরণস্বরূপ, পথে কলোনগুলি ক্ষতির কারণ হবে।
গ্যাবার

আপনি কি বলতে চান দয়া করে একটি উদাহরণ দিতে পারেন? আমি সমস্যাটি সমাধান করতে এবং পরবর্তী ব্যবহারকারীদের সহায়তা করতে খুশি হব।
বিশ্বাস2014

7

আমি UriBuilderএই ধরণের জিনিস জন্য সত্যিই ভাল কাজ পেয়েছি :

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

দেখুন দুটিই MSDN - UriBuilder ক্লাস আরো কনস্ট্রাকটর এবং ডকুমেন্টেশন জন্য।


4

মাইক্রোসফ্টের (অফিসডেভ পিএনপি) পদ্ধতিটি ইউরলিটিলিটি.কোমবাইন :

    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 এর চেয়ে পাথের জন্য হতে পারে।
ব্রায়ান ম্যাকেয়ে

@ ব্রায়ানম্যাকেকে সম্মত হয়েছে যে এটি দেখতে দেখতে এটির মতো দেখাচ্ছে তবে এটি ইউরুল ইউটিলিটি শ্রেণীর এবং ইউআরএলগুলির সংমিশ্রনের প্রসঙ্গে ব্যবহার করা হয়েছে

2
এটি কোন শ্রেণীর অন্তর্ভুক্ত তা স্পষ্ট করতে সম্পাদনা করা হয়েছে

এই ক্লাসটি ব্যবহার করার সময় সাবধানতা অবলম্বন করুন, বাকী ক্লাসে শেয়ারপয়েন্টের নির্দিষ্ট নিদর্শন রয়েছে।
হ্যারি বেরি

4

আমি নিম্নলিখিত দরকারী খুঁজে পেতে এবং নিম্নলিখিত বৈশিষ্ট্যগুলি রয়েছে:

  • নাল বা সাদা জায়গায় ছুড়ে ফেলে
  • 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

@ পিটারমোরটেনসেন সম্পাদনার জন্য ধন্যবাদ
দ্য জেনারাল

পরীক্ষাগুলি সহ কিছু সমস্যা: // ফলাফল = টেস্ট 1 / টেস্ট 2 / টেস্ট3 the 4 র্থ এবং থ্রো পরীক্ষার শেষটি আর্গুমেন্টএক্সেপশনের পরিবর্তে
অরগমেন্ট নলএক্সেপশন

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

এটি 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

3

কেন কেবল নিচেরটি ব্যবহার করবেন না।

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

আমি এর পাওয়ারশেল সংস্করণটির সন্ধান করছিলাম যা হ'ল: [System.IO.Path]::Combine("http://MyUrl.com/","/Images/Image.jpg")তবে এটি এর ফলে: ব্যর্থ হয় /Images/Image.jpg। সরান /দ্বিতীয় subPath থেকে এবং এটি কাজ করে:[System.IO.Path]::Combine("http://MyUrl.com/","Images/Image.jpg")
Underverse

দুর্দান্ত ধারণা, তবে এটি ব্যর্থ হয়, যখন কোনও একটি প্যারামিটার শূন্য থাকে।
ফোপ্পার

2

ইউআরআই এর সাথে ইউআরএল একত্রিত করার সময় নিয়ম

অদ্ভুত আচরণ এড়াতে একটি নিয়ম অনুসরণ করতে হবে:

  • পথ (ডিরেক্টরি) অবশ্যই '/' দিয়ে শেষ হবে। যদি পথটি '/' ছাড়াই শেষ হয়, শেষ অংশটি কোনও ফাইল-নামের মতো বিবেচিত হবে এবং পরবর্তী URL অংশের সাথে একত্রিত করার চেষ্টা করার সময় এটি সংক্ষিপ্ত হবে।
  • একটি ব্যতিক্রম রয়েছে: বেস ইউআরএল ঠিকানা (ডিরেক্টরি তথ্য ছাড়া) '/' দিয়ে শেষ হওয়ার দরকার নেই
  • পথ অংশ অবশ্যই '/' দিয়ে শুরু করা উচিত নয়। যদি এটি '/' দিয়ে শুরু হয়, ইউআরএল থেকে প্রতিটি বিদ্যমান আপেক্ষিক তথ্য বাদ দেওয়া হয় ... একটি string.Emptyঅংশ পথ যুক্ত করা URL থেকেও সম্পর্কিত ডিরেক্টরিটিকে মুছে ফেলবে!

আপনি যদি উপরের নিয়মগুলি অনুসরণ করেন তবে আপনি নীচের কোডের সাথে URL গুলি একত্রিত করতে পারেন can আপনার পরিস্থিতির উপর নির্ভর করে আপনি 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

আপনি যদি এএসপি.নেট কোর (মাইক্রোসফট.ওউইনে উপলব্ধ) তে তৃতীয় পক্ষের নির্ভরতা যেমন ফ্লুরল বা কাস্টম এক্সটেনশন পদ্ধতি তৈরি করতে না চান তবে আপনি ইউআরআই গড়ার PathStringউদ্দেশ্যে যা ব্যবহার করতে পারেন তা ব্যবহার করতে পারেন পাথ। এরপরে আপনি এর পুরো মিশ্রণটি ব্যবহার করে আপনার সম্পূর্ণ ইউআরআই তৈরি করতে পারেন Uriএবং UriBuilder

এই ক্ষেত্রে, এটি হবে:

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

এটি আপনাকে বেসের ইউআরএলটিতে বিভাজকগুলি নির্দিষ্ট না করে সমস্ত উপাদান অংশ দেয়। দুর্ভাগ্যক্রমে, এটি প্রতিটি স্ট্রিংকে প্রম্পেন্ড করা PathStringপ্রয়োজন /অন্যথায় এটি আসলে একটি ছুড়ে দেয় ArgumentException! তবে কমপক্ষে আপনি নিজের ইউআরআইকে নির্বিচারে এমনভাবে গড়ে তুলতে পারেন যাতে সহজেই ইউনিট-টেস্টেবল হয়।


2

সুতরাং আমার কাছে অন্য পদ্ধতি রয়েছে, যারা ইউরিবিল্ডার ব্যবহার করেছিলেন তাদের মতো everyone

আমি আমার বেসউআরএলকে ভাগ করতে চাইনি (যা পথের একটি অংশ থাকতে পারে - যেমন: 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 কোর 2.1 দিয়ে পরীক্ষিত।

কেন এই কাজ করে?

যদিও Path.Combineব্যাকস্ল্যাশগুলি ফিরিয়ে আনবে (উইন্ডোজ অ্যাটলাস্টে), উরিবিল্ডার সেটটার অফে এই কেসটি পরিচালনা করে 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;
      }
 }

এটিই কি সেরা পন্থা?

অবশ্যই এই সমাধানটি বেশ স্ব স্ব বর্ণনাকারী (অন্তত আমার মতে)। তবে আপনি .এনইটি এপিআই থেকে অননুমোদিত (অন্তত আমি দ্রুত গুগল অনুসন্ধানের সাথে কিছুই খুঁজে পাইনি) "বৈশিষ্ট্য" এর উপর নির্ভর করছি। এটি ভবিষ্যতের প্রকাশের সাথে পরিবর্তিত হতে পারে তাই দয়া করে পরীক্ষাগুলি সহ পদ্ধতিটি কভার করুন।

সেখানে পরীক্ষা নেই https://github.com/dotnet/corefx/blob/master/src/System.Private.Uri/tests/FunctionalTests/UriBuilderTests.cs ( Path_Get_Setযদি,) যা পরীক্ষা \সঠিকভাবে রুপান্তরিত করা হয়।

পার্শ্ব দ্রষ্টব্য: কেউ UriBuilder.Uriসরাসরি সম্পত্তি নিয়ে কাজ করতে পারে , যদি ইউরি কোনও System.Uriসিটারের জন্য ব্যবহৃত হয় ।


এটি একটি খুব নির্ভরযোগ্য পদ্ধতির। থাম্ব আপ ইউনিট পরীক্ষার জন্য !!
অ্যাগসোল 6

2

যে কেউ একটি ওলাইনার সন্ধান করছেন এবং কেবল কোনও নতুন পদ্ধতি তৈরি না করে একটি নতুন লাইব্রেরিটি উল্লেখ না করে বা একটি ইউআরআই মান তৈরি করে স্ট্রিতে রূপান্তর করতে চান না সেজন্য কোনও পথের অংশগুলিতে যোগ দিতে চান ...

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

এটি বেশ বেসিক, তবে আপনার আরও কী প্রয়োজন তা আমি দেখতে পাচ্ছি না। আপনি যদি দ্বিগুণ '/' থেকে ভয় পান তবে আপনি কেবল পরে এটি করতে পারেন .Replace("//", "/")। আপনি যদি 'https: //' তে দ্বিগুণ '//' প্রতিস্থাপন করতে ভয় পান, তবে তার পরিবর্তে একজন যোগ দিন, দ্বিগুণ '/' প্রতিস্থাপন করুন, তারপরে ওয়েবসাইট ইউআরএল-এ যোগ দিন (তবে আমি নিশ্চিত যে বেশিরভাগ ব্রাউজারগুলি স্বয়ংক্রিয়ভাবে আসবে) সঠিক বিন্যাসে পড়তে এর সামনে '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);
}

এটি কেবল আপনার ক্ষেত্রে গ্রহণযোগ্য। এমন কিছু মামলা রয়েছে যা আপনার কোডটি ভেঙে দিতে পারে। এছাড়াও, আপনি পথের অংশগুলির সঠিক এনকোডিং করেননি। সাইট স্ক্রিপ্টিং আক্রমণ ক্রস করার সময় এটি একটি বিশাল দুর্বলতা হতে পারে।
বিশ্বাস2014

আমি আপনার মতামত সম্মত। কোডটি দুটি ইউআরএল অংশের কেবল সহজ সংমিশ্রণ করার কথা।
অমিত ভগত

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

'ওয়েবপথ' দিয়ে দুর্দান্ত স্পর্শ। :) যদিও কোডটি অযথা ঘন হতে পারে - এটি আমার দিকে নজর দেওয়া এবং বলা হ্যাঁ, এটি নিখুঁত it's এটি আমাকে ইউনিট পরীক্ষা দেখতে চায়। হয়তো এটাই আমি!
ব্রায়ান ম্যাকেকে

1
x.StartsWith ("/") &&! x.SarttsWith ("http") - কেন এইচটিপি চেক? আপনি কি লাভ?
পেঙ্গুইট

আপনি যদি স্ল্যাশটি http দিয়ে শুরু হয় তবে তা সরিয়ে দেওয়ার চেষ্টা করতে চান না।
মার্টিন মারফি

@ ব্রায়ানম্যাকেকে, আমি নিশ্চিত নই যে দুটি লাইনার একটি ইউনিট পরীক্ষার জন্য ওয়ারেন্ট দেয় তবে আপনি যদি নির্দ্বিধায় এটি সরবরাহ করতে চান। এটি প্যাচ বা কোনও কিছু গ্রহণ করার মতো নয় তবে পরামর্শটি সম্পাদনা করতে নির্দ্বিধায়।
মার্টিন মারফি

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

এটির মূল্য কী তা জন্য, এখানে বেশ কয়েকটি এক্সটেনশন পদ্ধতি রয়েছে। প্রথমটি পাথগুলি একত্রিত করবে এবং দ্বিতীয়টি ইউআরএলে প্যারামিটার যুক্ত করবে।

    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 মিলিসেকেন্ড সময় নেয় takes অর্থাত

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('/'))));
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.