Path.Combine pour les URL?

Path.Combine est pratique, mais existe-t-il une fonction similaire dans le framework .NET pour les URL ?

Je recherche une syntaxe comme celle-ci:

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

qui retournerait:

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

Il y a un commentaire de Todd Menier ci - dessus selon lequel Flurl inclut un Url.Combine.

Plus de détails:

Url.Combine est essentiellement un Path.Combine pour les URL, assurant un et un seul caractère séparateur entre les parties:

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" 

Obtenez Flurl.Http sur NuGet :

PM> Install-Package Flurl.Http

Ou obtenez le générateur d'URL autonome sans les fonctionnalités HTTP:

PM> Flurl du package d'installation

Uri a un constructeur qui devrait le faire pour vous: new Uri(Uri baseUri, string relativeUri)

Voici un exemple:

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

Note de l'éditeur: Attention, cette méthode ne fonctionne pas comme prévu. Il peut couper une partie de baseUri dans certains cas. Voir les commentaires et autres réponses.

Cela peut être une solution suffisamment simple:

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

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

Reviendra:

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

Il y a déjà d'excellentes réponses ici. Basé sur la suggestion de mdsharpe, voici une méthode d'extension qui peut facilement être utilisée lorsque vous souhaitez gérer des instances Uri:

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

Et exemple d'utilisation:

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

Cela produira http://example.com/subpath/part1/part2

La réponse de Ryan Cook est proche de ce que je recherche et peut être plus appropriée pour d'autres développeurs. Cependant, il ajoute http: // au début de la chaîne et en général, il fait un peu plus de mise en forme que je ne le suis.

De plus, pour mes cas d'utilisation, la résolution de chemins relatifs n'est pas importante.

La réponse de mdsharp contient également le germe d'une bonne idée, bien que cette implémentation réelle ait besoin de quelques détails supplémentaires pour être complète. Ceci est une tentative de l'étoffer (et je l'utilise en production):

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

Ce code passe le test suivant, qui se trouve être en 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

Path.Combine ne fonctionne pas pour moi car il peut y avoir des caractères comme "|" dans les arguments QueryString et donc l'URL, ce qui entraînera une ArgumentException.

J'ai d'abord essayé la nouvelle Uri(Uri baseUri, string relativeUri)approche, qui a échoué pour moi à cause d'URI comme http://www.mediawiki.org/wiki/Special:SpecialPages:

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

se traduira par Special: SpecialPages, à cause des deux points après Special cela dénote un schéma.

J'ai donc finalement dû prendre la route mdsharpe / Brian MacKays et la développer un peu plus pour travailler avec plusieurs parties 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;
}

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

Basé sur l'exemple d' URL vous avez fourni, je suppose que vous souhaitez combiner des URL relatives à votre site.

Sur la base de cette hypothèse, je proposerai cette solution comme la réponse la plus appropriée à votre question qui était: "Path.Combine est pratique, y a-t-il une fonction similaire dans le cadre des URL?"

Puisqu'il y a une fonction similaire dans le cadre des URL, je propose que la bonne soit: "VirtualPathUtility.Combine". Voici le lien de référence MSDN: VirtualPathUtility.Combine, méthode

Il y a une mise en garde: je pense que cela ne fonctionne que pour les URL relatives à votre site (c'est-à-dire que vous ne pouvez pas l'utiliser pour générer des liens vers un autre site Web. Par exemple, var url = VirtualPathUtility.Combine("www.google.com", "accounts/widgets");).

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

Je viens de mettre en place une petite méthode d'extension:

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

Il peut être utilisé comme ceci:

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

Exemple plein d'esprit, Ryan, pour terminer avec un lien vers la fonction. Bien joué.

Une recommandation Brian: si vous encapsulez ce code dans une fonction, vous souhaiterez peut-être utiliser un UriBuilder pour encapsuler l'URL de base avant l'appel TryCreate.

Sinon, l'URL de base DOIT inclure le schéma (où UriBuilder supposera http: //). Juste une pensée:

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

Un moyen simple de les combiner et de vous assurer qu'elles sont toujours correctes est:

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

La combinaison de plusieurs parties d'une URL peut être un peu délicate. Vous pouvez utiliser le constructeur à deux paramètres Uri(baseUri, relativeUri)ou utiliser la Uri.TryCreate()fonction utilitaire.

Dans les deux cas, vous pourriez finir par renvoyer un résultat incorrect car ces méthodes continuent de tronquer les parties relatives du premier paramètre baseUri, c'est-à-dire de quelque chose comme http://google.com/some/thingà http://google.com.

Pour pouvoir combiner plusieurs parties en une URL finale, vous pouvez copier les deux fonctions ci-dessous:

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

Le code complet avec des tests unitaires pour démontrer l'utilisation peut être trouvé à https://uricombine.codeplex.com/SourceControl/latest#UriCombine/Uri.cs

J'ai des tests unitaires pour couvrir les trois cas les plus courants:

J'ai trouvé que ça UriBuilderfonctionnait très bien pour ce genre de chose:

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

Voir Classe UriBuilder - MSDN pour plus de constructeurs et de documentation.

Voici la méthode UrlUtility.Combine de Microsoft (OfficeDev PnP) :

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

Source: GitHub

Je trouve les éléments suivants utiles et présente les caractéristiques suivantes:

• Lance un espace nul ou blanc
• Prend plusieurs paramsparamètres pour plusieurs segments d'URL
• jette sur vide ou vide

Classe

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

Les 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

Ma solution générique:

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

J'ai créé cette fonction qui vous facilitera la vie:

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

Cela fonctionne pour les URL ainsi que pour les chemins normaux.

Usage:

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

Pourquoi ne pas simplement utiliser ce qui suit.

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

Règles lors de la combinaison d'URL avec un URI

Pour éviter un comportement étrange, il y a une règle à suivre:

• Le chemin (répertoire) doit se terminer par '/'. Si le chemin se termine sans '/', la dernière partie est traitée comme un nom de fichier et elle sera concaténée lors de la tentative de combinaison avec la partie URL suivante.
• Il y a une exception: l'adresse URL de base (sans les informations de répertoire) ne doit pas se terminer par '/'
• la partie chemin ne doit pas commencer par '/'. S'il commence par '/', toutes les informations relatives existantes de l'URL sont supprimées ... l'ajout d'un string.Emptychemin de partie supprimera également le répertoire relatif de l'URL!

Si vous suivez les règles ci-dessus, vous pouvez combiner des URL avec le code ci-dessous. Selon votre situation, vous pouvez ajouter plusieurs parties de «répertoire» à l'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();
        });

Si vous ne souhaitez pas ajouter une dépendance tierce telle que Flurl ou créer une méthode d'extension personnalisée, dans ASP.NET Core (également disponible dans Microsoft.Owin), vous pouvez utiliser PathStringce qui est destiné à la création d'URI chemins. Vous pouvez ensuite créer votre URI complet en utilisant une combinaison de ceci, Uriet UriBuilder.

Dans ce cas, ce serait:

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

Cela vous donne toutes les parties constitutives sans avoir à spécifier les séparateurs dans l'URL de base. Malheureusement, PathStringrequiert que /soit ajouté à chaque chaîne sinon il lance en fait un ArgumentException! Mais au moins, vous pouvez créer votre URI de manière déterministe d'une manière qui est facilement testable par unité.

J'ai donc une autre approche, similaire à tous ceux qui ont utilisé UriBuilder.

Je ne voulais pas diviser ma BaseUrl (qui peut contenir une partie du chemin - par exemple http://mybaseurl.com/dev/ ) comme javajavajavajavajava .

L'extrait suivant montre le code + tests.

Attention: cette solution met en minuscule l'hôte et ajoute un port. Si cela n'est pas souhaité, on peut écrire une représentation sous forme de chaîne en utilisant par exemple la Uripropriété de 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));
         }
  }

Testé avec .NET Core 2.1 sur Windows 10.

Pourquoi ça marche?

Même s'il Path.Combinerenverra des barres obliques inverses (au moins sur Windows), l'UriBuilder gère ce cas dans le Setter de Path.

Tiré de https://github.com/dotnet/corefx/blob/master/src/System.Private.Uri/src/System/UriBuilder.cs (attention à l'appel à string.Replace)

[AllowNull]
public string Path
{
      get
      {
          return _path;
      }
      set
      {
          if ((value == null) || (value.Length == 0))
          {
              value = "/";
          }
          _path = Uri.InternalEscapeString(value.Replace('\\', '/'));
          _changed = true;
      }
 }

Est-ce la meilleure approche?

Certes, cette solution est assez auto-descriptive (du moins à mon avis). Mais vous comptez sur la "fonctionnalité" non documentée (au moins, je n'ai rien trouvé avec une recherche rapide sur Google) de l'API .NET. Cela peut changer avec une future version, veuillez donc couvrir la méthode avec des tests.

Il existe des tests dans https://github.com/dotnet/corefx/blob/master/src/System.Private.Uri/tests/FunctionalTests/UriBuilderTests.cs ( Path_Get_Set) qui vérifient si le \est correctement transformé.

Note latérale: On pourrait également travailler UriBuilder.Uridirectement avec la propriété, si l'uri sera utilisé pour un System.Urictor.

Pour tous ceux qui recherchent une ligne et veulent simplement joindre des parties d'un chemin sans créer de nouvelle méthode ou référencer une nouvelle bibliothèque ou construire une valeur URI et la convertir en chaîne, puis ...

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

C'est assez basique, mais je ne vois pas de quoi vous avez besoin de plus. Si vous avez peur de doubler '/', vous pouvez simplement faire un .Replace("//", "/")après. Si vous avez peur de remplacer le "//" doublé dans "https: //", puis effectuez une jointure, remplacez le "/" doublé, puis rejoignez l'URL du site Web (mais je suis pratiquement sûr que la plupart des navigateurs le feront automatiquement convertir quoi que ce soit avec 'https:' à l'avant pour lire au format correct). Cela ressemblerait à ceci:

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

Il y a beaucoup de réponses ici qui gèreront tout ce qui précède, mais dans mon cas, je n'en avais besoin qu'une seule fois dans un seul endroit et je n'aurais pas besoin de m'y fier fortement. De plus, il est vraiment facile de voir ce qui se passe ici.

Voir: https://docs.microsoft.com/en-us/dotnet/api/system.string.join?view=netframework-4.8

Utilisation:

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

Il a l'avantage de se comporter exactement comme Path.Combine.

Voici mon approche et je vais l'utiliser pour moi aussi:

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

Utilisez ceci:

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

J'ai trouvé que le Uriconstructeur retourne «\» dans «/». Vous pouvez donc également utiliser Path.Combine, avec le Uriconstructeur.

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

Pour ce que ça vaut, voici quelques méthodes d'extension. Le premier combinera les chemins et le second ajoute des paramètres à l'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();
    }

Comme on le trouve dans d'autres réponses, soit nouveau Uri()ou TryCreate()peut faire le tick. Cependant, l'Uri de base doit se terminer par /et le parent ne doit PAS commencer par/ ; sinon il supprimera la partie arrière de l'URL de base

Je pense que c'est mieux de le faire comme méthode d'extension, c'est-à-dire

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

et pour l'utiliser:

var baseUri = new Uri("http://test.com/test/");
var combinedUri =  baseUri.Append("/Do/Something");

En termes de performances, cela consomme plus de ressources qu'il n'en a besoin, en raison de la classe Uri qui effectue beaucoup d'analyse et de validation; un profilage très grossier (Debug) a fait un million d'opérations en environ 2 secondes. Cela fonctionnera pour la plupart des scénarios, mais pour être plus efficace, il est préférable de tout manipuler sous forme de chaînes, cela prend 125 millisecondes pour 1 million d'opérations. C'est à dire

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

Et si vous souhaitez toujours renvoyer un URI, cela prend environ 600 millisecondes pour 1 million d'opérations.

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

J'espère que ça aide.

Je pense que cela devrait vous donner plus de flexibilité car vous pouvez traiter autant de segments de chemin que vous le souhaitez:

public static string UrlCombine(this string baseUrl, params string[] segments)
=> string.Join("/", new[] { baseUrl.TrimEnd('/') }.Concat(segments.Select(s => s.Trim('/'))));