Chemin.Combiner pour des URLs?

Chemin d'accès.Combiner est pratique, mais y a-t-il une fonction similaire dans le framework .NET pour URLs ?

je cherche une syntaxe comme celle-ci:

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

qui reviendrait:

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

1049
demandé sur Peter Mortensen 2008-12-17 00:42:26
la source

30 ответов

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");
1021
répondu Joel Beckham 2018-09-20 11:52:35
la source

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

Sera de retour:

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

131
répondu Ryan Cook 2008-12-17 00:49:56
la source

il peut s'agir d'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);
}
126
répondu Matt Sharpe 2009-09-25 14:29:57
la source

il y a déjà de bonnes réponses ici. Sur la base de la suggestion de mdsharpe, voici une méthode d'extension qui peut facilement être utilisée lorsque vous voulez traiter 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

106
répondu Ales Potocnik Hahonina 2014-03-20 09:17:34
la source

cette question a obtenu de grandes réponses, hautement votées!

la réponse de Ryan Cook est proche de ce que je cherche et pourrait ê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 formatage que je suis après.

aussi, pour mes cas d'utilisation, la résolution des chemins relatifs n'est pas importante.

la réponse de mdsharp contient également le germe d'une bonne idée, bien que cette mise en œuvre effective nécessitait quelques détails supplémentaires pour être complète. C'est une tentative d'étoffer (et je l'utilise dans la 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 avec succès 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
80
répondu Brian MacKay 2016-07-07 22:22:44
la source

basé sur l'échantillon URL que vous avez fourni, je vais supposer que vous voulez combiner des URLs qui sont relatives à votre site.

sur la base de cette hypothèse, je vais proposer cette solution comme la réponse la plus appropriée à votre question qui était: "chemin.Combinez est pratique, y a - t-il une fonction similaire dans le cadre des URLs?"

Puisqu'il y a un fonction similaire dans le cadre des URLs je propose le correct est: "VirtualPathUtility.Combiner" la méthode. Voici le lien de référence MSDN: VirtualPathUtility.Méthode Combinée

il y a une mise en garde: je crois que cela ne fonctionne que pour les URLs 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"); ).

32
répondu Jeronimo Colon III 2018-09-20 12:05:29
la source

Chemin d'accès.Combinez ne fonctionne pas pour moi car il peut y avoir des caractères comme "|" dans les arguments de type QueryString et donc L'Url, ce qui donnera une ArgumentException.

j'ai d'abord essayé la nouvelle approche Uri(Uri baseUri, string relativeUri), 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 des Pagesspéciales spéciales, en raison du deux-points après spécial qui dénote un schéma.

J'ai donc finalement dû prendre la route de mdsharpe/Brian MacKays et je l'ai développée un peu plus loin pour travailler avec plusieurs pièces d'uri:

public static string CombineUri(params string[] uriParts)
{
    string uri = string.Empty;
    if (uriParts != null && uriParts.Count() > 0)
    {
        char[] trims = new char[] { '\', '/' };
        uri = (uriParts[0] ?? string.Empty).TrimEnd(trims);
        for (int i = 1; i < uriParts.Count(); i++)
        {
            uri = string.Format("{0}/{1}", uri.TrimEnd(trims), (uriParts[i] ?? string.Empty).TrimStart(trims));
        }
    }
    return uri;
}

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

28
répondu Mike Fuchs 2011-08-19 15:12:16
la source
Path.Combine("Http://MyUrl.com/", "/Images/Image.jpg").Replace("\", "/")
22
répondu JeremyWeir 2011-01-12 00:41:18
la source

je viens de mettre en place des petits 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('/');
        }

peut être utilisé comme ceci:

"www.example.com/".UriCombine("/images").UriCombine("first.jpeg");
14
répondu urza 2010-11-25 11:43:19
la source

Spirituel exemple, Ryan, à la fin, avec un lien vers la fonction. Bien fait.

une recommandation Brian: si vous enveloppez ce code dans une fonction, vous pouvez utiliser un UriBuilder pour envelopper L'URL de base avant L'appel TryCreate.

sinon, L'URL de base doit inclure le schéma (où l'UriBuilder va supposer 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");
}
11
répondu mtazva 2015-02-03 18:04:45
la source

combiner plusieurs parties d'une Url peut être un peu délicat. Vous pouvez utiliser le constructeur à 2 paramètres Uri(baseUri, relativeUri) , ou vous pouvez utiliser la fonction utilitaire Uri.TryCreate() . Dans les deux cas, vous pourriez finir par retourner un résultat incorrect parce que ces méthodes continuent à tronquer les parties relatives du premier paramètre baseUri , i.e. de quelque chose comme http://google.com/some/thing à http://google.com

pour pouvoir combiner plusieurs parties dans une url finale, vous pouvez copier 2 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 3 cas les plus communs: enter image description here

8
répondu Believe2014 2014-09-24 17:43:22
la source

cette réponse sera probablement perdue dans toutes les réponses ci-dessus, mais j'ai trouvé que UriBuilder fonctionnait vraiment bien pour ce genre de chose.

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

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

7
répondu javajavajavajavajava 2018-09-20 14:41:06
la source

je sais que cela a été répondu, mais un moyen facile de combiner et de s'assurer qu'il est toujours correct..

string.Format("{0}/{1}", Url1.Trim('/'), Url2);
6
répondu Alex 2010-05-13 01:42:32
la source

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

    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

4
répondu Chris Marisic 2017-06-07 00:25:44
la source

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;
}
3
répondu Alex Titarenko 2015-05-17 10:52:20
la source

je sais que je suis en retard à la fête, mais j'ai créé cette fonction qui va rendre votre vie plus facile

    /// <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 aussi bien pour les URLs que pour les chemins normaux

Utilisation :

    //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
répondu bigworld12 2016-07-21 21:19:05
la source

je sais que cette question est bien répondu, mais je trouve cela utile, car il a les caractéristiques suivantes

  • lance sur l'espace nul ou blanc
  • classe statique qui imite plus étroitement System.Io.Path
  • prend params paramètre pour plusieurs segments D'Url

Note : L'Url du nom de classe peut être changée, car il existe une classe de système System.Security.Policy.Url

Classe

public static class Url
{
   private static string InternalCombine(string source, string dest)
   {

      // If the source is null or white space retune the dest only
      if (string.IsNullOrWhiteSpace(source))
      {
         throw new ArgumentException("Cannot be null or white space", "source");
         // throw new ArgumentException("Cannot be null or white space", nameof(source)); // c# 6.0 Nameof Expression
      }

      if (string.IsNullOrWhiteSpace(dest))
      {
         throw new ArgumentException("Cannot be null or white space", "dest");
         // throw new ArgumentException("Cannot be null or white space", nameof(dest)); // c# 6.0 Nameof Expression
      }

      source =  source.TrimEnd('/', '\');
      dest = dest.TrimStart('/', '\');

      return string.Format("{0}/{1}", source, dest);
      // return $"{source}/{dest}"; // c# 6.0 string interpolation
   }

   public static string Combine(string source, params string[] args)
   {
      return args.Aggregate(source, InternalCombine);
   }
}

résultats

Url.Combine("test1", "test2");    
Url.Combine("test1//", "test2"); 
Url.Combine("test1", "/test2");

// Result = test1/test2

Url.Combine(@"test1\/\/\/", @"\/\/\\\//test2", @"\/\/\\\//test3\") ;

// Result = test1/test2/test3

Url.Combine("/test1/", "/test2/", null);
Url.Combine("", "/test2/");
Url.Combine("/test1/", null);

// Throws an ArgumentException
2
répondu TheGeneral 2017-02-28 05:16:46
la source

Il y est un Todd Menier du commentaire ci-dessus que Flurl comprend une Url.Combiner.

plus de détails:

de l'Url.Combinez est essentiellement un chemin.Combiner pour les URLs, en assurant un et un seul caractère séparateur entre les parties:

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" 
2
répondu Michael Freidgeim 2018-04-13 09:00:13
la source

et ça?

 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
répondu Martin Murphy 2012-12-10 19:31:30
la source

Voici mon approche et je l'utiliserai pour moi aussi

public static string UrlCombine(string part1, string part2)
{
    string newPart1 = string.Empty;
    string newPart2 = string.Empty;
    string seprator = "/";

    // if either part1 or part 2 is empty,
    // we don't need to combine with seprator
    if (string.IsNullOrEmpty(part1) || string.IsNullOrEmpty(part2))
    {
        seprator = 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, seprator, newPart2);
}
1
répondu Amit Bhagat 2013-08-03 07:39:54
la source
    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);
    }

a l'avantage de se comporter exactement comme Path.Combiner

1
répondu TruthOf42 2014-02-18 19:31:39
la source

règles en combinant URL avec URI

pour éviter les comportements étranges, il y a une règle à suivre:

  • 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 sera concaténée en essayant de se combiner avec la partie url suivante.
  • il y a une exception: l'adresse URL de base (sans information de répertoire) ne doit pas se terminer par ' / '
  • la partie chemin ne doit pas commencer par '/', si elle commence par '/' toutes les informations relatives existantes de L'URL sont supprimées...l'ajout de la chaîne.Empty part path supprimera aussi le répertoire relatif de L'URL!

si vous suivez les règles ci-dessus, vous pouvez combiner des URLs avec le code ci-dessous. selon votre situation, vous pouvez ajouter plusieurs parties 'directory' à 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();
        });
1
répondu baHI 2016-04-05 08:04:15
la source

pourquoi ne pas simplement utiliser ce qui suit.

System.IO.Path.Combine(rootUrl, subPath).Replace(@"\", "/")
1
répondu Andreas 2017-11-17 16:11:56
la source

plus de suggestions... J'ai combiné tout ce qui précède:

    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
répondu Per G 2013-04-25 14:51:01
la source

Eh bien, je concaténate deux cordes et utilise des Expressions régulières pour faire la partie de nettoyage.

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

ainsi, vous pouvez utiliser comme ceci:

    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"

espérons qu'il peut être utile pour quelqu'un!

0
répondu Marcio Martins 2014-05-21 22:44:13
la source

j'ai utilisé ce code pour résoudre le problème:

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
répondu Joshua Smith 2016-03-17 18:50:50
la source

deux de ces travaux

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

ou

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

ie

si

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

et

relativePath = "To_Folder"

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

certaines erreurs apparaîtront pour code ci-dessous

 // if you use below code, some issues will be there in final uri
 Uri final= new Uri(baseUrl ,relativePath );
0
répondu DAre G 2017-04-24 10:43:08
la source

Un simple liner:

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

inspiré de la réponse de @Matt Sharpe.

0
répondu Nick N. 2017-11-06 15:41:07
la source

nous utilisons la méthode d'aide simple suivante pour joindre le nombre arbitraire de parties D'URL ensemble:

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

Note, qu'il ne supporte pas"../../quelque chose/page.htm de style " URL relative-s!

0
répondu pholpar 2018-03-22 17:19:05
la source

J'ai trouvé que Uri constructeur flips '\' dans '/'. Donc vous pouvez aussi utiliser Path.Combiner, avec Uri ctr.

 Uri baseUri = new Uri("http://MyUrl.com");
 string path = Path.Combine("Images","Image.jpg");
 Uri myUri = new Uri(baseUri , path);
0
répondu skippy 2018-09-30 13:43:22
la source

Autres questions sur c# asp.net .net url path