Path.Combine для URL-адресов?

Path.Combine удобен, но есть ли аналогичная функция в платформе .NET для URL-адрес?

Я ищу синтаксис вот так:

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

который вернется:

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

936
задан Brian MacKay 17 дек. '08 в 0:42
источник поделиться
30 ответов

Uri имеет конструктор, который должен сделать это для вас: new Uri(Uri baseUri, string relativeUri)

Вот пример:

Uri baseUri = new Uri("http://www.contoso.com");
Uri myUri = new Uri(baseUri, "catalog/shownew.htm");
917
ответ дан Joel Beckham 06 окт. '09 в 22:37
источник поделиться

Вы используете 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

120
ответ дан Ryan Cook 17 дек. '08 в 0:49
источник поделиться

Это может быть достаточно простым решением:

public static string Combine(string uri1, string uri2)
{
    uri1 = uri1.TrimEnd('/');
    uri2 = uri2.TrimStart('/');
    return string.Format("{0}/{1}", uri1, uri2);
}
106
ответ дан Matt Sharpe 25 сент. '09 в 13:29
источник поделиться

Здесь уже есть отличные ответы. На основе предложения mdsharpe, здесь используется метод расширения, который можно легко использовать, когда вы хотите иметь дело с экземплярами 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('/'))));
    }
}

И пример использования:

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

Это приведет к http://example.com/subpath/part1/part2

86
ответ дан Ales Potocnik Hahonina 03 нояб. '11 в 13:20
источник поделиться

Этот вопрос получил отличные, высоко оцененные ответы!

Ответ Райана Кука близок к тому, что мне нужно, и может быть более подходящим для других разработчиков. Тем не менее, он добавляет http://в начало строки и, в общем, делает немного больше форматирования, чем я.

Кроме того, для моих вариантов использования не разрешается относить относительные пути.

mdsharp answer также содержит семя хорошей идеи, хотя для фактической реализации понадобилось еще несколько деталей, чтобы быть полными. Это попытка изложить его (и я использую это в процессе производства):

С#

public string UrlCombine(string url1, string url2)
{
    if (url1.Length == 0) {
        return url2;
    }

    if (url2.Length == 0) {
        return url1;
    }

    url1 = url1.TrimEnd('/', '\\');
    url2 = url2.TrimStart('/', '\\');

    return string.Format("{0}/{1}", url1, url2);
}

VB.Net

Public Function UrlCombine(ByVal url1 As String, ByVal url2 As String) As String
    If url1.Length = 0 Then
        Return url2
    End If

    If url2.Length = 0 Then
        Return url1
    End If

    url1 = url1.TrimEnd("/"c, "\"c)
    url2 = url2.TrimStart("/"c, "\"c)

    Return String.Format("{0}/{1}", url1, url2)
End Function

Этот код передает следующий тест, который находится в VB:

<TestMethod()> Public Sub UrlCombineTest()
    Dim target As StringHelpers = New StringHelpers()

    Assert.IsTrue(target.UrlCombine("test1", "test2") = "test1/test2")
    Assert.IsTrue(target.UrlCombine("test1/", "test2") = "test1/test2")
    Assert.IsTrue(target.UrlCombine("test1", "/test2") = "test1/test2")
    Assert.IsTrue(target.UrlCombine("test1/", "/test2") = "test1/test2")
    Assert.IsTrue(target.UrlCombine("/test1/", "/test2/") = "/test1/test2/")
    Assert.IsTrue(target.UrlCombine("", "/test2/") = "/test2/")
    Assert.IsTrue(target.UrlCombine("/test1/", "") = "/test1/")
End Sub
63
ответ дан Brian MacKay 11 мая '10 в 0:53
источник поделиться

На основе образца URL, который вы указали, я собираюсь предположить, что вы хотите объединить URL-адреса, относящиеся к вашему сайту.

Исходя из этого предположения, я предлагаю это решение как наиболее подходящий ответ на ваш вопрос, который был: "Path.Combine удобен, есть ли аналогичная функция в структуре URL-адресов?"

Поскольку в структуре URL-адресов существует аналогичная функция, я предлагаю, что правильный: метод VirtualPathUtility.Combine. Здесь ссылка ссылки MSDN: VirtualPathUtility.Combine Method

Существует одно предостережение: я считаю, что это работает только для URL-адресов относительно вашего сайта (т.е. вы не можете использовать его для создания ссылок на другой веб-сайт. Например, var url = VirtualPathUtility.Combine("www.google.com", "accounts/widgets");).

30
ответ дан Jeronimo Colon III 28 марта '10 в 3:21
источник поделиться

Path.Combine не работает для меня, потому что могут быть такие символы, как "|" в аргументах QueryString и, следовательно, Url, что приведет к исключению ArgumentException.

Сначала я попробовал новый подход Uri (Uri baseUri, string relativeUri), который мне не удалось из-за Uri, как http://www.mediawiki.org/wiki/Special:SpecialPages:

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

приведет к Special: SpecialPages из-за двоеточия после Special, который обозначает схему.

Итак, я, наконец, должен был взять маршрут mdsharpe/Brian MacKays и разработал его немного дальше для работы с несколькими частями 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;
}

Использование: CombineUri("http://www.mediawiki.org/", "wiki", "Special:SpecialPages")

27
ответ дан Mike Fuchs 15 июля '11 в 11:17
источник поделиться
Path.Combine("Http://MyUrl.com/", "/Images/Image.jpg").Replace("\\", "/")
16
ответ дан JeremyWeir 12 янв. '11 в 0:41
источник поделиться

Я только что собрал небольшой метод расширения

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");
14
ответ дан urza 25 нояб. '10 в 11:43
источник поделиться

Остроумный пример, Райан, чтобы закончить со ссылкой на функцию. Молодцы.

Одна рекомендация Брайан: если вы закроете этот код в функции, вы можете использовать UriBuilder для обвязывания базового URL до вызова TryCreate.

В противном случае базовый URL ДОЛЖЕН включать схему (где UriBuilder будет считать http://). Просто мысль:

public string CombineUrl(string baseUrl, string relativeUrl) {
    UriBuilder baseUri = new UriBuilder(baseUrl);
    Uri newUri;

    if (Uri.TryCreate(baseUri.Uri, relativeUrl, out newUri))
        return newUri.ToString();
    else
        throw new ArgumentException("Unable to combine specified url values");
}
10
ответ дан mtazva 30 июля '09 в 18:08
источник поделиться

Объединение нескольких частей URL-адреса может быть немного сложным. Вы можете использовать конструктор 2 Uri(baseUri, relativeUri), или вы можете использовать функцию утилиты Uri.TryCreate(). В любом случае вы можете вернуть неверный результат, потому что эти методы продолжают обрезать относительные части от первого параметра baseUri, то есть от чего-то вроде http://google.com/some/thing до http://google.com

Чтобы иметь возможность комбинировать несколько частей в конечном URL-адресе, вы можете скопировать 2 функции ниже:

    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

У меня есть Unit Tests, чтобы охватить 3 наиболее распространенных случая: enter image description here

9
ответ дан Believe2014 01 мая '14 в 1:21
источник поделиться

Я знаю, что на это был дан ответ, но простой способ объединить их и гарантировать, что он всегда правильный.

string.Format("{0}/{1}", Url1.Trim('/'), Url2);
6
ответ дан Alex 13 мая '10 в 0:42
источник поделиться

Этот ответ, вероятно, затерялся во всех ответах выше, но я обнаружил, что UriBuilder отлично работает для такого рода вещей.

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

Подробнее о конструкторах и документации см. UriBuilder Class - MSDN.

5
ответ дан javajavajavajavajava 22 мая '13 в 15:19
источник поделиться

Здесь метод Microsoft (OfficeDev PnP) UrlUtility.Combine:

    const char PATH_DELIMITER = '/';

    /// <summary>
    /// Combines a path and a relative path.
    /// </summary>
    /// <param name="path"></param>
    /// <param name="relative"></param>
    /// <returns></returns>
    public static string Combine(string path, string relative) 
    {
        if(relative == null)
            relative = String.Empty;

        if(path == null)
            path = String.Empty;

        if(relative.Length == 0 && path.Length == 0)
            return String.Empty;

        if(relative.Length == 0)
            return path;

        if(path.Length == 0)
            return relative;

        path = path.Replace('\\', PATH_DELIMITER);
        relative = relative.Replace('\\', PATH_DELIMITER);

        return path.TrimEnd(PATH_DELIMITER) + PATH_DELIMITER + relative.TrimStart(PATH_DELIMITER);
    }

Источник: GitHub

4
ответ дан Björn Ali Göransson 01 нояб. '15 в 21:34
источник поделиться

Мое общее решение:

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 17 мая '15 в 10:52
источник поделиться

Я знаю, что опаздываю на вечеринку, но я создал эту функцию, которая облегчит вам жизнь.

    /// <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
ответ дан bigworld12 21 июля '16 в 21:19
источник поделиться

Я знаю, что этот вопрос хорошо ответил, однако я считаю это полезным, поскольку он имеет следующие функции.

  • Выбрасывает пустое или пустое пространство
  • Статический класс, который более близко имитирует System.Io.Path
  • Принимает параметр params для нескольких сегментов Url

Примечание. Название класса Url можно изменить, так как существует системный класс System.Security.Policy.Url

Класс

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

Результаты

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
ответ дан Saruman 28 февр. '17 в 5:11
источник поделиться

Как насчет этого?

 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 10 дек. '12 в 18:31
источник поделиться

Правила при объединении URL с URI

Чтобы избежать странного поведения, нужно следовать одному правилу:

  • path (directory) должен заканчиваться на '/'. если путь заканчивается без '/', последняя часть обрабатывается как имя файла, и она будет конкатенирована при попытке комбинировать со следующей частью URL.
  • есть 1 исключение: базовый URL-адрес (без информации каталога) не должен заканчиваться на "/"
  • часть пути не должна начинаться с '/', если она начинается с '/', любая существующая относительная информация из URL-адреса отбрасывается... добавление string.Empty path также удалит относительный каталог из URL-адреса!

Если вы следуете приведенным выше правилам, вы можете комбинировать URL-адреса с кодом ниже. В зависимости от вашей ситуации вы можете добавить несколько частей "каталога" в URL-адрес...

        var pathParts = new string[] { destinationBaseUrl, destinationFolderUrl, fileName };

        var destination = pathParts.Aggregate((left, right) =>
        {
            if (string.IsNullOrWhiteSpace(right))
                return left;

            return new Uri(new Uri(left), right).ToString();
        });
1
ответ дан baHI 05 апр. '16 в 8:04
источник поделиться

Вот мой подход, и я тоже буду использовать его для себя.

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
ответ дан Amit Bhagat 03 авг. '13 в 6:39
источник поделиться
    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
ответ дан TruthOf42 18 февр. '14 в 18:31
источник поделиться

Обе эти работы

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

или

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

т

если

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

и

relativePath = "To_Folder"

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

Некоторые ошибки появятся для кода ниже

 // if you use below code, some issues will be there in final uri
 Uri final= new Uri(baseUrl ,relativePath );
0
ответ дан DAre G 24 апр. '17 в 10:43
источник поделиться

Другие предложения... Я объединил все вышеперечисленное:

    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 25 апр. '13 в 13:51
источник поделиться

Я использовал этот код для решения проблемы:

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 04 дек. '15 в 2:17
источник поделиться

Простой один вкладыш:

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

Вдохновленный ответом @Matt Sharpe.

0
ответ дан Nick N. 06 нояб. '17 в 15:41
источник поделиться

Почему бы просто не использовать следующее.

System.IO.Path.Combine(rootUrl, subPath).Replace(@"\", "/")
0
ответ дан Andreas 17 нояб. '17 в 16:11
источник поделиться

Ну, я просто конкатенирую две строки и использую регулярные выражения для выполнения очистки.

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

Итак, вы можете использовать вот так:

    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 16 мая '14 в 2:49
источник поделиться

Я еще не использовал следующий код, но нашел его во время моих интернет-путешествий, чтобы решить проблему с объединением URL-адресов - надеясь, что это будет кратким (и успешным!) ответом:

VirtualPathUtility.Combine
-1
ответ дан missbassethorn 28 февр. '13 в 6:40
источник поделиться

Я должен указать, что Path.Combine работает для этого также непосредственно по крайней мере на .NET4

-1
ответ дан Chris Marisic 01 июля '10 в 19:02
источник поделиться

Nalarium.Url в пакете Nalarium NuGet делает именно это.

Подпись:

public static String Join(params String[] parameterArray)

Следовательно, вы можете сделать это (предположим, что переменные из базы данных или что-то):

Nalarium.Url.Join("https://domain", id, resource, version, parameters);

Clean.

Это params, поэтому вы можете добавлять параметры по мере необходимости.

-1
ответ дан David Betz 05 дек. '17 в 0:48
поделиться

Другие вопросы по меткам или Задайте вопрос