wake-up-neo.com

Path.Combine für URLs?

Path.Combine ist praktisch, aber gibt es eine ähnliche Funktion im .NET-Framework für RLs ?

Ich suche nach folgender Syntax:

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

was zurückkehren würde:

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

1156
Brian MacKay

Dort ist ein Kommentar von Todd Menier oben dass Flurl eine Url.Combine enthält.

Mehr Details:

Url.Combine ist im Grunde eine Path.Combine für URLs, die ein und nur ein Trennzeichen zwischen Teilen sicherstellt:

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&y=2" 

Holen Sie sich Flurl.Http auf NuGet :

PM> Install-Package Flurl.Http

Oder laden Sie den eigenständigen URL-Builder herunter ohne die HTTP-Funktionen:

PM> Install-Package Flurl

33

Uri hat einen Konstruktor, der dies für Sie erledigen sollte: new Uri(Uri baseUri, string relativeUri)

Hier ist ein Beispiel:

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

Anmerkung des Herausgebers: Achtung, diese Methode funktioniert nicht wie erwartet. In einigen Fällen kann es einen Teil von baseUri abschneiden. Siehe Kommentare und andere Antworten.

1103
Joel Beckham

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

Wird zurückkehren:

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

140
Ryan Cook

Dies kann eine entsprechend einfache Lösung sein:

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

Hier gibt es bereits einige gute Antworten. Basierend auf dem Vorschlag von mdsharpe ist hier eine Erweiterungsmethode, die einfach verwendet werden kann, wenn Sie mit Uri-Instanzen arbeiten möchten:

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

Und Anwendungsbeispiel:

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

Dies erzeugt http://example.com/subpath/part1/part2

120

Ryan Cooks Antwort kommt dem sehr nahe, wonach ich suche, und ist möglicherweise besser für andere Entwickler geeignet. Es fügt jedoch http: // am Anfang der Zeichenfolge hinzu und formatiert im Allgemeinen etwas mehr, als ich erwartet habe.

In meinen Anwendungsfällen ist es auch nicht wichtig, relative Pfade aufzulösen.

die Antwort von mdsharp enthält auch den Keim einer guten Idee, obwohl für die tatsächliche Implementierung einige weitere Details erforderlich waren, um vollständig zu sein. Dies ist ein Versuch, es zu konkretisieren (und ich verwende dies in der Produktion):

C #

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

Dieser Code besteht den folgenden Test, der sich zufällig in VB befindet:

<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
83
Brian MacKay

Anhand des von Ihnen angegebenen Beispiels URL gehe ich davon aus, dass Sie URLs kombinieren möchten, die relativ zu Ihrer Website sind.

Ausgehend von dieser Annahme werde ich diese Lösung als die am besten geeignete Antwort auf Ihre Frage vorschlagen: "Path.Combine ist praktisch, gibt es eine ähnliche Funktion im Framework für URLs? "

Da es eine ähnliche Funktion im Framework für URLs gibt, schlage ich vor, dass die richtige lautet: "VirtualPathUtility .Combine "-Methode. Hier ist der MSDN-Referenzlink: VirtualPathUtility.Combine-Methode

Es gibt eine Einschränkung: Ich glaube, dies funktioniert nur für URLs, die sich auf Ihre Website beziehen (dh Sie können damit keine Links zu einer anderen Website erstellen. Beispiel: var url = VirtualPathUtility.Combine("www.google.com", "accounts/widgets");).

33

Path.Combine funktioniert bei mir nicht, da es Zeichen wie "|" geben kann. in QueryString Argumente und damit die URL, die zu einer ArgumentException führt.

Ich habe zuerst den neuen Ansatz Uri(Uri baseUri, string relativeUri) ausprobiert, der für mich aufgrund von URIs wie http://www.mediawiki.org/wiki/Special:SpecialPages fehlgeschlagen ist:

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

führt zu Special: SpecialPages, da der Doppelpunkt nach Special ein Schema kennzeichnet.

Also musste ich endlich die Route von mdsharpe/Brian MacKays einschlagen und es etwas weiterentwickeln, um mit mehreren URI-Teilen zu arbeiten:

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

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

31
Mike Fuchs
Path.Combine("Http://MyUrl.com/", "/Images/Image.jpg").Replace("\\", "/")
22
JeremyWeir

Ich habe gerade eine kleine Erweiterungsmethode zusammengestellt:

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

Es kann so verwendet werden:

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

Witziges Beispiel, Ryan, um mit einem Link zur Funktion zu enden. Gut gemacht.

Eine Empfehlung Brian: Wenn Sie diesen Code in eine Funktion einschließen, möchten Sie möglicherweise einen UriBuilder verwenden, um die Basis-URL vor dem TryCreate-Aufruf einzuschließen.

Andernfalls MUSS die Basis-URL das Schema enthalten (wobei der UriBuilder http: // übernimmt). Nur ein Gedanke:

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");
}
12
mtazva

Das Kombinieren mehrerer Teile einer URL kann etwas schwierig sein. Sie können den Zwei-Parameter-Konstruktor Uri(baseUri, relativeUri) oder die Utility-Funktion Uri.TryCreate() verwenden.

In beiden Fällen wird möglicherweise ein falsches Ergebnis zurückgegeben, da diese Methoden die relativen Teile des ersten Parameters baseUri weiter abschneiden, d. H. Von http://google.com/some/thing bis http://google.com.

Um mehrere Teile zu einer endgültigen URL zusammenzufassen, können Sie die beiden folgenden Funktionen kopieren:

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

Vollständiger Code mit Unit-Tests zum Nachweis der Verwendung finden Sie unter https://uricombine.codeplex.com/SourceControl/latest#UriCombine/Uri.cs

Ich habe Unit-Tests, um die drei häufigsten Fälle abzudecken:

Enter image description here

9
Believe2014

Eine einfache Möglichkeit, sie zu kombinieren und sicherzustellen, dass sie immer korrekt sind, ist:

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

Ich fand UriBuilder sehr gut für diese Art von Dingen:

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

Weitere Konstruktoren und Dokumentationen finden Sie unter riBuilder Class - MSDN .

Hier ist die Microsoft-Methode (OfficeDev PnP) rlUtility.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);
    }

Quelle: GitHub

4
user3638471

Ich habe diese Funktion erstellt, die Ihnen das Leben leichter machen wird:

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

Es funktioniert sowohl für URLs als auch für normale Pfade.

Verwendungszweck:

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

Meine generische Lösung:

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
Alex Titarenko

Ich finde folgendes nützlich und habe folgende Eigenschaften:

  • Wirft auf Null oder Leerzeichen
  • Übernimmt mehrere params -Parameter für mehrere URL-Segmente
  • wirft auf null oder leer

Klasse

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

Tests

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
TheGeneral

Regeln beim Kombinieren von URLs mit einem URI

Um seltsames Verhalten zu vermeiden, gilt es eine Regel zu beachten:

  • Der Pfad (Verzeichnis) muss mit '/' enden. Wenn der Pfad ohne '/' endet, wird der letzte Teil wie ein Dateiname behandelt und wird verkettet, wenn versucht wird, ihn mit dem nächsten URL-Teil zu kombinieren.
  • Es gibt eine Ausnahme: Die Basis-URL-Adresse (ohne Verzeichnisinformationen) muss nicht mit '/' enden.
  • der Pfadteil darf nicht mit '/' beginnen. Wenn es mit '/' beginnt, werden alle vorhandenen relativen Informationen aus der URL gelöscht. Durch Hinzufügen eines string.Empty -Pfads wird auch das relative Verzeichnis aus der URL entfernt!

Wenn Sie die obigen Regeln befolgen, können Sie URLs mit dem folgenden Code kombinieren. Abhängig von Ihrer Situation können Sie der URL mehrere 'Verzeichnis'-Teile hinzufügen ...

        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
baHI

Wenn Sie keine Drittanbieterabhängigkeit wie Flurl hinzufügen oder eine benutzerdefinierte Erweiterungsmethode erstellen möchten, können Sie in ASP.NET Core (auch in Microsoft.Owin verfügbar) PathString verwenden Zweck des Aufbaus von URI-Pfaden. Sie können dann Ihren vollständigen URI erstellen, indem Sie eine Kombination aus diesem, Uri und UriBuilder verwenden.

In diesem Fall wäre es:

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

Auf diese Weise erhalten Sie alle Bestandteile, ohne die Trennzeichen in der Basis-URL angeben zu müssen. Leider erfordert PathString, dass / vor jeder Zeichenfolge steht, sonst wird tatsächlich ein ArgumentException ausgegeben! Aber zumindest können Sie Ihre URI deterministisch auf eine Weise aufbauen, die sich leicht nach Einheiten testen lässt.

1
Neo

Für das, was es wert ist, hier ein paar Erweiterungsmethoden. Der erste kombiniert Pfade und der zweite fügt der URL Parameter hinzu.

    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
LawMan

Ich habe festgestellt, dass der Konstruktor Uri '\' in '/' wechselt. Sie können also auch Path.Combine mit dem Konstruktor Uri verwenden.

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

Warum nicht einfach folgendes verwenden.

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

Verwenden:

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

Es hat den Vorteil, dass es sich genau wie Path.Combine verhält.

1
TruthOf42

Benutze das:

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
Martin Murphy

Hier ist mein Ansatz und ich werde ihn auch für mich selbst verwenden:

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
Amit Bhagat

Nun, ich verkette nur zwei Zeichenfolgen und verwende reguläre Ausdrücke, um den Reinigungsteil zu erledigen.

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

Sie können es also folgendermaßen verwenden:

    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
Marcio Martins

Ich habe alle bisherigen Antworten zusammengefasst:

    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
Per G

Ich habe diesen Code verwendet, um das Problem zu lösen:

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
Joshua Smith

Beide Arbeiten:

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

Oder

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

Das heißt wenn

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

und

relativePath = "To_Folder"

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

Für den folgenden Code werden einige Fehler angezeigt:

 // If you use the below code, some issues will be there in the final URI
 Uri final = new Uri(baseUrl, relativePath);
0
DAre G

Wir verwenden die folgende einfache Hilfsmethode, um eine beliebige Anzahl von URL-Teilen miteinander zu verbinden:

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

Beachten Sie, dass es keine relativen URLs im '../../something/page.htm'-Stil unterstützt!

0
pholpar

Ein einfacher Einzeiler:

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

Inspiriert von der Antwort von @Matt Sharpe.

0
Nick N.