URL的Path.Combine吗？

Path.Combine很方便，但是.NET框架中有类似的URL功能吗？

我正在寻找这样的语法：

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

这将返回：

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

上面有一个Todd Menier的评论，Flurl包含一个Url.Combine。

更多细节：

Url.Combine本质上是URL的Path.Combine，确保部分之间只有一个分隔符：

var url = Url.Combine(
    "http://MyUrl.com/",
    "/too/", "/many/", "/slashes/",
    "too", "few?",
    "x=1", "y=2"
// result: "http://www.MyUrl.com/too/many/slashes/too/few?x=1&y=2" 

在NuGet上获取Flurl.Http：

PM>安装包Flurl.Http

或获取不具有HTTP功能的独立URL构建器：

PM>安装包Flurl

Uri 有一个应该为您执行此操作的构造函数： new Uri(Uri baseUri, string relativeUri)

这是一个例子：

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

编辑注意：请注意，此方法无法正常工作。在某些情况下，它可以削减baseUri的一部分。查看评论和其他答案。

这可能是一个适当的简单解决方案：

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

您使用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

这里已经有了一些很好的答案。根据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

瑞安·库克（Ryan Cook）的答案与我所追求的接近，并且可能更适合其他开发人员。但是，它在字符串的开头添加了http：//，并且总的来说，格式化要比后面的要多。

另外，对于我的用例，解决相对路径也不重要。

mdsharp的答案还包含一个好主意，尽管实际的实现需要更多细节才能完成。这是一个充实的尝试（我正在生产中使用它）：

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

此代码通过了以下测试，恰好在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对我不起作用，因为可能会有类似“ |”的字符 在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.Length > 0)
    {
        char[] trims = new char[] { '\\', '/' };
        uri = (uriParts[0] ?? string.Empty).TrimEnd(trims);
        for (int i = 1; i < uriParts.Length; i++)
        {
            uri = string.Format("{0}/{1}", uri.TrimEnd(trims), (uriParts[i] ?? string.Empty).TrimStart(trims));
        }
    }
    return uri;
}

用法： CombineUri("http://www.mediawiki.org/", "wiki", "Special:SpecialPages")

根据您提供的示例URL，我将假设您要组合相对于您的网站的URL。

基于此假设，我将提出此解决方案作为对您的问题的最适当答复：“ Path.Combine很方便，URL框架中是否有类似的功能？”

由于URL框架中存在类似的功能，因此我建议正确的方法是：“ VirtualPathUtility.Combine”方法。这是MSDN参考链接：VirtualPathUtility.Combine方法

有一个警告：我相信这仅适用于相对于您网站的URL（也就是说，您不能使用它来生成指向另一个网站的链接。例如，var url = VirtualPathUtility.Combine("www.google.com", "accounts/widgets");）。

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

我只是整理了一个小的扩展方法：

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

机智的例子Ryan以该函数的链接结尾。做得好。

建议Brian：如果将此代码包装在一个函数中，则可能需要使用UriBuilder在TryCreate调用之前包装基本URL。

否则，基本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");
}

合并它们并确保其始终正确的一种简单方法是：

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

组合URL的多个部分可能会有些棘手。您可以使用两参数构造函数Uri(baseUri, relativeUri)，也可以使用Uri.TryCreate()实用程序功能。

在这两种情况下，您都可能最终返回不正确的结果，因为这些方法会不断截断第一个参数的相对部分baseUri，例如从http://google.com/some/thingto到http://google.com。

为了能够将多个部分组合成最终URL，您可以复制以下两个函数：

    public static string Combine(params string[] parts)
    {
        if (parts == null || parts.Length == 0) return string.Empty;

        var urlBuilder = new StringBuilder();
        foreach (var part in parts)
        {
            var tempUrl = tryCreateRelativeOrAbsolute(part);
            urlBuilder.Append(tempUrl);
        }
        return VirtualPathUtility.RemoveTrailingSlash(urlBuilder.ToString());
    }

    private static string tryCreateRelativeOrAbsolute(string s)
    {
        System.Uri uri;
        System.Uri.TryCreate(s, UriKind.RelativeOrAbsolute, out uri);
        string tempUrl = VirtualPathUtility.AppendTrailingSlash(uri.ToString());
        return tempUrl;
    }

可以在https://uricombine.codeplex.com/SourceControl/latest#UriCombine/Uri.cs中找到带有单元测试以演示用法的完整代码。

我的单元测试涵盖了三种最常见的情况：

我发现UriBuilder这种事情非常有效：

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

有关更多构造函数和文档，请参见UriBuilder类-MSDN。

这是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

我发现以下有用并具有以下功能：

• 抛出空白或空白
• 需要多个 params为多个网址段参数
• 抛出null或空

类

public static class UrlPath
{
   private static string InternalCombine(string source, string dest)
   {
      if (string.IsNullOrWhiteSpace(source))
         throw new ArgumentException("Cannot be null or white space", nameof(source));

      if (string.IsNullOrWhiteSpace(dest))
         throw new ArgumentException("Cannot be null or white space", nameof(dest));

      return $"{source.TrimEnd('/', '\\')}/{dest.TrimStart('/', '\\')}";
   }

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

测验

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

// Result = test1/test2

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

// Result = test1/test2/test3

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

// Throws an ArgumentException

我的通用解决方案：

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

我创建了此功能，可以使您的生活更轻松：

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

为什么不只使用以下内容。

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

将URL与URI结合时的规则

为避免发生奇怪的行为，请遵循以下规则：

• 路径（目录）必须以“ /”结尾。如果路径以“ /”结尾，则将最后一部分视为文件名，并且在尝试与下一个URL部分结合时将其串联。
• 有一个例外：基本URL地址（不带目录信息）不必以'/'结尾
• 路径部分不能以“ /”开头。如果以'/'开头，string.Empty则会删除URL中所有现有的相对信息...添加部件路径也会从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();
        });

如果不想在ASP.NET Core（也可以在Microsoft.Owin中）中添加第三方依赖项（例如Flurl）或创建自定义扩展方法，则可以使用PathString它来建立URI。路径。然后，您可以使用这个组合创建完整的URI，Uri和UriBuilder。

在这种情况下，它将是：

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

这为您提供了所有组成部分，而无需在基本URL中指定分隔符。不幸的是，PathString要求/在每个字符串之前加上，否则实际上会抛出ArgumentException！。但是至少您可以以易于进行单元测试的方式确定性地构建URI。

因此，我有另一种方法，类似于使用UriBuilder的每个人。

我不想将我的BaseUrl（可以包含路径的一部分，例如http://mybaseurl.com/dev/）拆分为javajavajavajavajava一样。

以下代码段显示了代码+测试。

当心：此解决方案会小写主机并附加端口。如果不希望这样，可以通过例如利用Uri属性来编写字符串表示形式UriBuilder。

  public class Tests
  {
         public static string CombineUrl (string baseUrl, string path)
         {
           var uriBuilder = new UriBuilder (baseUrl);
           uriBuilder.Path = Path.Combine (uriBuilder.Path, path);
           return uriBuilder.ToString();
         }

         [TestCase("http://MyUrl.com/", "/Images/Image.jpg", "http://myurl.com:80/Images/Image.jpg")]
         [TestCase("http://MyUrl.com/basePath", "/Images/Image.jpg", "http://myurl.com:80/Images/Image.jpg")]
         [TestCase("http://MyUrl.com/basePath", "Images/Image.jpg", "http://myurl.com:80/basePath/Images/Image.jpg")]
         [TestCase("http://MyUrl.com/basePath/", "Images/Image.jpg", "http://myurl.com:80/basePath/Images/Image.jpg")]
         public void Test1 (string baseUrl, string path, string expected)
         {
           var result = CombineUrl (baseUrl, path);

           Assert.That (result, Is.EqualTo (expected));
         }
  }

已在Windows 10上使用.NET Core 2.1进行测试。

为什么这样做？

即使Path.Combine将返回反斜杠（在Windows上至少），UriBuilder也会在Setter ofPath。

取自https://github.com/dotnet/corefx/blob/master/src/System.Private.Uri/src/System/UriBuilder.cs（注意对的调用string.Replace）

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

这是最好的方法吗？

当然，此解决方案非常自我描述（至少在我看来）。但是，您依赖.NET API中未记录的功能（至少在Google谷歌快速搜索中没有找到任何内容）“功能”。将来的发行版中可能会有所变化，因此请涵盖“测试方法”。

https://github.com/dotnet/corefx/blob/master/src/System.Private.Uri/tests/FunctionalTests/UriBuilderTests.cs（Path_Get_Set）中有测试，检查是否\正确转换了。

旁注：UriBuilder.Uri如果uri将用作System.Urictor ，则也可以直接使用该属性。

对于正在寻找单线并且只想联接路径的一部分而无需创建新方法或引用新库或构造URI值并将其转换为字符串的任何人，那么...

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

这很基本，但是我看不到您还需要什么。如果您害怕将'/'翻倍，则可以简单地进行.Replace("//", "/")事后处理。如果您担心在'https：//'中替换双倍的'//'，则改为一次联接，替换双倍的'/'，然后加入网站网址（但是我敢肯定，大多数浏览器会自动将其前面带有'https：'的内容转换为正确的格式）。看起来像：

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

这里有很多可以解决上述所有问题的答案，但就我而言，我只需要在一个位置一次就可以了，不需要过多地依赖它。另外，很容易看到这里发生了什么。

请参阅：https : //docs.microsoft.com/zh-cn/dotnet/api/system.string.join?view=netframework-4.8

采用：

    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。

这是我的方法，我也将自己使用它：

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

用这个：

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

我发现Uri构造函数将“ \”翻转为“ /”。因此，您也可以将Path.Combine，与Uri构造函数一起使用。

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

对于它的价值，这里有一些扩展方法。第一个将合并路径，第二个将参数添加到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();
    }

在其他的答案作为发现，无论是新的Uri()还是TryCreate()可以做刻度。但是，基本的Uri必须以结尾，/亲戚的必须不要以/; 开头。否则，它将删除基本网址的结尾部分

我认为最好将其作为扩展方法来完成，即

public static Uri Append(this Uri uri, string relativePath)
{
    var baseUri = uri.AbsoluteUri.EndsWith('/') ? uri : new Uri(uri.AbsoluteUri + '/');
    var relative = relativePath.StartsWith('/') ? relativePath.Substring(1) : relativePath;
    return new Uri(baseUri, relative);
}

并使用它：

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

在性能方面，由于Uri类进行了大量的解析和验证，因此消耗的资源超过了需要的资源。一个非常粗糙的分析（调试）在大约2秒钟内完成了100万次操作。这将适用于大多数情况，但是要提高效率，最好将所有内容作为字符串进行处理，这需要125毫秒来执行一百万次操作。即

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

而且，如果您仍然想返回URI，则一百万次操作大约需要600毫秒。

public static Uri AppendUri(this Uri uri, string relativePath)
{
    //avoid the use of Uri as it's not needed, and adds a bit of overhead.
    var absoluteUri = uri.AbsoluteUri; //a calculated property, better cache it
    var baseUri = absoluteUri.EndsWith('/') ? absoluteUri : absoluteUri + '/';
    var relative = relativePath.StartsWith('/') ? relativePath.Substring(1) : relativePath;
    return new Uri(baseUri + relative);
}

我希望这有帮助。

我认为这应该为您提供更大的灵活性，因为您可以根据需要处理任意多个路径段：

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