Path.Join 方法
定义
重要
一些信息与预发行产品相关,相应产品在发行之前可能会进行重大修改。 对于此处提供的信息,Microsoft 不作任何明示或暗示的担保。
重载
Join(String, String, String, String) |
将四个路径连接到一个路径中。 |
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) |
将四个路径组件连接到一个路径中。 |
Join(String, String, String) |
将三个路径连接到一个路径中。 |
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) |
将三个路径组件连接到一个路径中。 |
Join(ReadOnlySpan<String>) | |
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) |
将两个路径组件连接到一个路径中。 |
Join(String[]) |
将路径数组连接到一个路径中。 |
Join(String, String) |
将两个路径连接到一个路径中。 |
Join(String, String, String, String)
- Source:
- Path.cs
- Source:
- Path.cs
- Source:
- Path.cs
将四个路径连接到一个路径中。
public:
static System::String ^ Join(System::String ^ path1, System::String ^ path2, System::String ^ path3, System::String ^ path4);
public static string Join (string? path1, string? path2, string? path3, string? path4);
static member Join : string * string * string * string -> string
Public Shared Function Join (path1 As String, path2 As String, path3 As String, path4 As String) As String
参数
- path1
- String
要联接的第一个路径。
- path2
- String
要联接的第二个路径。
- path3
- String
要联接的第三个路径。
- path4
- String
要联接的第四个路径。
返回
连接的路径。
注解
此方法只是连接 path
、 和 path4
,path2
path3
并在任何路径组件之间添加目录分隔符(如果尚不存在)。 如果任何 、 path2
path3
或 path4
参数的path1
长度为零,该方法将连接其余参数。 如果生成的串联字符串的长度为零,则该方法返回 String.Empty。
如果 path1
或 path2
或 path3
以不适合目标平台的路径分隔符结尾,该方法 Join
将保留原始路径分隔符并追加受支持的字符。 此问题出现在使用 Windows 反斜杠 (“\”) 字符的硬编码路径中,该字符在基于 Unix 的系统上无法识别为路径分隔符。 若要解决此问题,可以:
检索 属性的值, Path.DirectorySeparatorChar 而不是硬编码目录分隔符。
使用正斜杠 (“/”) 作为目录分隔符。 此字符由基于 Unix 的系统上的 Path.DirectorySeparatorChar 属性和 Windows 系统上的 Path.AltDirectorySeparatorChar 属性返回。
Combine与 方法不同, Join 方法不会尝试对返回的路径进行根目录。 (如果 path2
或 path3
path4
是绝对路径,则 Join
该方法不会像 Combine 方法那样丢弃以前的路径。)
并非所有目录和文件名的无效字符都被 方法解释为不可接受的 Join
,因为可以将这些字符用于搜索通配符。 例如,虽然 Path.Join("c:\\", "temp", "*.txt")
创建文件时可能无效,但它作为搜索字符串有效。 因此, Join
方法成功解释它。
适用于
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)
- Source:
- Path.cs
- Source:
- Path.cs
- Source:
- Path.cs
将四个路径组件连接到一个路径中。
public:
static System::String ^ Join(ReadOnlySpan<char> path1, ReadOnlySpan<char> path2, ReadOnlySpan<char> path3, ReadOnlySpan<char> path4);
public static string Join (ReadOnlySpan<char> path1, ReadOnlySpan<char> path2, ReadOnlySpan<char> path3, ReadOnlySpan<char> path4);
static member Join : ReadOnlySpan<char> * ReadOnlySpan<char> * ReadOnlySpan<char> * ReadOnlySpan<char> -> string
Public Shared Function Join (path1 As ReadOnlySpan(Of Char), path2 As ReadOnlySpan(Of Char), path3 As ReadOnlySpan(Of Char), path4 As ReadOnlySpan(Of Char)) As String
参数
- path1
- ReadOnlySpan<Char>
包含要加入的第一个路径的字符范围。
- path2
- ReadOnlySpan<Char>
包含要加入的第二个路径的字符范围。
- path3
- ReadOnlySpan<Char>
包含要加入的第三个路径的字符范围。
- path4
- ReadOnlySpan<Char>
包含要联接的第四个路径的字符跨度。
返回
连接的路径。
注解
此方法只是连接 path
、 和 path4
,path2
path3
并在任何路径组件之间添加目录分隔符(如果尚不存在)。 Length如果任何 、 path2
path3
或 path4
参数的 path1
为零,该方法将连接其余参数。 ReadOnlySpan<T>.Length如果所有组件的 为零,则该方法返回 String.Empty。
如果 path1
或 path2
或 path3
以不适合目标平台的路径分隔符结尾,该方法 Join
将保留原始路径分隔符并追加受支持的字符。 此问题出现在使用 Windows 反斜杠 (“\”) 字符的硬编码路径中,该字符在基于 Unix 的系统上无法识别为路径分隔符。 若要解决此问题,可以:
检索 属性的值, Path.DirectorySeparatorChar 而不是硬编码目录分隔符。
使用正斜杠 (“/”) 作为目录分隔符。 此字符由基于 Unix 的系统上的 Path.DirectorySeparatorChar 属性和 Windows 系统上的 Path.AltDirectorySeparatorChar 属性返回。
Combine与 方法不同, Join 方法不会尝试对返回的路径进行根目录。 (如果 path2
或 path3
path4
是绝对路径,则 Join
该方法不会像 Combine 方法那样丢弃以前的路径。)
并非所有目录和文件名的无效字符都被 方法解释为不可接受的 Join
,因为可以将这些字符用于搜索通配符。 例如,虽然 Path.Join("c:\\", "temp", "*.txt")
创建文件时可能无效,但它作为搜索字符串有效。 因此, Join
方法成功解释它。
适用于
Join(String, String, String)
- Source:
- Path.cs
- Source:
- Path.cs
- Source:
- Path.cs
将三个路径连接到一个路径中。
public:
static System::String ^ Join(System::String ^ path1, System::String ^ path2, System::String ^ path3);
public static string Join (string? path1, string? path2, string? path3);
static member Join : string * string * string -> string
Public Shared Function Join (path1 As String, path2 As String, path3 As String) As String
参数
- path1
- String
要联接的第一个路径。
- path2
- String
要联接的第二个路径。
- path3
- String
要联接的第三个路径。
返回
连接的路径。
注解
此方法只是连接 path
、 和 path3
,path2
并在任何路径组件之间添加目录分隔符(如果尚不存在)。 如果 任何 、 path2
或 path3
参数的path1
长度为零,该方法将连接其余参数。 如果生成的串联字符串的长度为零,则该方法返回 String.Empty。
如果 path1
或 path2
以不适合目标平台的路径分隔符结尾,该方法 Join
将保留原始路径分隔符并追加受支持的字符。 此问题出现在使用 Windows 反斜杠 (“\”) 字符的硬编码路径中,该字符在基于 Unix 的系统上无法识别为路径分隔符。 若要解决此问题,可以:
检索 属性的值, Path.DirectorySeparatorChar 而不是硬编码目录分隔符。
使用正斜杠 (“/”) 作为目录分隔符。 此字符由基于 Unix 的系统上的 Path.DirectorySeparatorChar 属性和 Windows 系统上的 Path.AltDirectorySeparatorChar 属性返回。
Combine与 方法不同, Join 方法不会尝试对返回的路径进行根目录。 (也就是说,如果 path2
或 path3
是绝对路径,则 Join
该方法不会像 方法那样 Combine 丢弃以前的路径。)
并非所有目录和文件名的无效字符都被 方法解释为不可接受的 Join
,因为可以将这些字符用于搜索通配符。 例如,虽然 Path.Join("c:\\", "temp", "*.txt")
创建文件时可能无效,但它作为搜索字符串有效。 因此, Join
方法成功解释它。
适用于
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)
- Source:
- Path.cs
- Source:
- Path.cs
- Source:
- Path.cs
将三个路径组件连接到一个路径中。
public:
static System::String ^ Join(ReadOnlySpan<char> path1, ReadOnlySpan<char> path2, ReadOnlySpan<char> path3);
public static string Join (ReadOnlySpan<char> path1, ReadOnlySpan<char> path2, ReadOnlySpan<char> path3);
static member Join : ReadOnlySpan<char> * ReadOnlySpan<char> * ReadOnlySpan<char> -> string
Public Shared Function Join (path1 As ReadOnlySpan(Of Char), path2 As ReadOnlySpan(Of Char), path3 As ReadOnlySpan(Of Char)) As String
参数
- path1
- ReadOnlySpan<Char>
包含要加入的第一个路径的字符范围。
- path2
- ReadOnlySpan<Char>
包含要加入的第二个路径的字符范围。
- path3
- ReadOnlySpan<Char>
包含要加入的第三个路径的字符范围。
返回
连接的路径。
示例
以下示例说明了 和 Path.Combine(String, String, String) 方法返回Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)的路径的差异。 当第一个字符串是包含驱动器和根目录的完全限定路径,第二个字符串是第一个路径的相对路径时,这两种方法将产生相同的结果。 在对 方法的第二次和第三次 ShowPathInformation
调用中,两个方法返回的字符串会不同。 在第二个方法调用中,第一个字符串参数是驱动器,而第二个参数是根目录。 方法 Join
连接两个字符串,并保留重复的路径分隔符。 调用 GetFullPath 方法将消除重复。 方法 Combine
放弃驱动器,并在当前驱动器上返回根目录。 如果应用程序的当前驱动器为 C:\ ,并且字符串用于访问目录中的文件,则它将访问 C: 而不是 D:。 最后,由于第三次调用 ShowPathInformation
中的最后一个参数是根的, Join
因此该方法只是将其追加到前两个参数以创建一个无意义的文件路径,而 Combine
该方法将放弃前两个字符串并返回第三个字符串。 使用此字符串进行文件访问可能会使应用程序能够意外访问敏感文件。
using System;
using System.IO;
class Program3
{
static void Main()
{
ShowPathInformation("C:/", "users/user1/documents", "letters");
ShowPathInformation("D:/", "/users/user1/documents", "letters");
ShowPathInformation("D:/", "users/user1/documents", "C:/users/user1/documents/data");
}
private static void ShowPathInformation(string path1, string path2, string path3)
{
Console.WriteLine($"Concatenating '{path1}', '{path2}', and '{path3}'");
Console.WriteLine($" Path.Join: '{Path.Join(path1, path2, path3)}'");
Console.WriteLine($" Path.Combine: '{Path.Combine(path1, path2, path3)}'");
Console.WriteLine($" {Path.GetFullPath(Path.Join(path1, path2, path3))}");
}
}
// The example displays the following output if run on a Windows system:
// Concatenating 'C:/', 'users/user1/documents', and 'letters'
// Path.Join: 'C:/users/user1/documents\letters'
// Path.Combine: 'C:/users/user1/documents\letters'
// C:\users\user1\documents\letters
// Concatenating 'D:/', '/users/user1/documents', and 'letters'
// Path.Join: 'D://users/user1/documents\letters'
// Path.Combine: '/users/user1/documents\letters'
// D:\users\user1\documents\letters
// Concatenating 'D:/', 'users/user1/documents', and 'C:/users/user1/documents/data'
// Path.Join: 'D:/users/user1/documents\C:/users/user1/documents/data'
// Path.Combine: 'C:/users/user1/documents/data'
// D:\users\user1\documents\C:\users\user1\documents\data
Imports System.IO
Module Program
Public Sub Main()
Dim path1 As String = "C:/"
Dim path2 As String = "users/user1/documents"
Dim path3 As String = "letters"
ShowPathInformation(path1, path2, path3)
path1 = "D:/"
path2 = "/users/user1/documents"
path3 = "letters"
ShowPathInformation(path1, path2, path3)
path1 = "D:/"
path2 = "users/user1/documents"
path3 = "C:/users/user1/documents/data"
ShowPathInformation(path1, path2, path3)
End Sub
Private Sub ShowPathInformation(path1 As String, path2 As String, path3 As String)
Dim result = Path.Join(path1.AsSpan(), path2.AsSpan(), path3.AsSpan())
Console.WriteLine($"Concatenating '{path1}, '{path2}', and `{path3}'")
Console.WriteLine($" Path.Join: '{result}'")
Console.WriteLine($" Path.Combine: '{Path.Combine(path1, path2, path3)}'")
End Sub
End Module
' The example displays the following output if run on a Windows system:
' Concatenating 'C:/, 'users/user1/documents', and `letters'
' Path.Join: 'C:/users/user1/documents\letters'
' Path.Combine: 'C:/users/user1/documents\letters'
'
' Concatenating 'D:/, '/users/user1/documents', and `letters'
' Path.Join: 'D:'users/user1/documents\letters'
' Path.Combine: '/users/user1/documents\letters'
'
' Concatenating 'D:/, 'users/user1/documents', and `C:/users/user1/documents/data'
' Path.Join: 'D:/users/user1/documents\C:/users/user1/documents/data'
' Path.Combine: 'C:/users/user1/documents/data'
注解
此方法只是连接 path
、 和 path3
,path2
并在任何路径组件之间添加目录分隔符(如果尚不存在)。 Length如果任何 、 path2
或 path3
参数的 path1
为零,该方法将连接其余参数。 ReadOnlySpan<T>.Length如果所有组件的 为零,则该方法返回 String.Empty。
如果 path1
或 path2
以不适合目标平台的路径分隔符结尾,该方法 Join
将保留原始路径分隔符并追加受支持的字符。 此问题出现在使用 Windows 反斜杠 (“\”) 字符的硬编码路径中,该字符在基于 Unix 的系统上无法识别为路径分隔符。 若要解决此问题,可以:
检索 属性的值, Path.DirectorySeparatorChar 而不是硬编码目录分隔符。
使用正斜杠 (“/”) 作为目录分隔符。 此字符由基于 Unix 的系统上的 Path.DirectorySeparatorChar 属性和 Windows 系统上的 Path.AltDirectorySeparatorChar 属性返回。
Combine与 方法不同, Join 方法不会尝试对返回的路径进行根目录。 (也就是说,如果 path2
或 path3
是绝对路径,则 Join
该方法不会像 方法那样 Combine 丢弃以前的路径。)
并非所有目录和文件名的无效字符都被 方法解释为不可接受的 Join
,因为可以将这些字符用于搜索通配符。 例如,虽然 Path.Join("c:\\", "temp", "*.txt")
创建文件时可能无效,但它作为搜索字符串有效。 因此, 方法 Join
成功解释它。
另请参阅
适用于
Join(ReadOnlySpan<String>)
public:
static System::String ^ Join(ReadOnlySpan<System::String ^> paths);
public static string Join (scoped ReadOnlySpan<string?> paths);
static member Join : ReadOnlySpan<string> -> string
Public Shared Function Join (paths As ReadOnlySpan(Of String)) As String
参数
- paths
- ReadOnlySpan<String>
返回
适用于
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)
- Source:
- Path.cs
- Source:
- Path.cs
- Source:
- Path.cs
将两个路径组件连接到一个路径中。
public:
static System::String ^ Join(ReadOnlySpan<char> path1, ReadOnlySpan<char> path2);
public static string Join (ReadOnlySpan<char> path1, ReadOnlySpan<char> path2);
static member Join : ReadOnlySpan<char> * ReadOnlySpan<char> -> string
Public Shared Function Join (path1 As ReadOnlySpan(Of Char), path2 As ReadOnlySpan(Of Char)) As String
参数
- path1
- ReadOnlySpan<Char>
包含要加入的第一个路径的字符范围。
- path2
- ReadOnlySpan<Char>
包含要加入的第二个路径的字符范围。
返回
已组合的路径。
示例
以下示例演示 了 和 Path.Combine(String, String) 方法返回Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)的路径的差异。 当第一个字符串是包含驱动器和根目录的完全限定路径,第二个字符串是第一个路径的相对路径时,这两种方法将生成相同的结果。 在对 方法的第二次和第三次 ShowPathInformation
调用中,这两个方法返回的字符串将不同。 在第二个方法调用中,第一个字符串参数是驱动器,而第二个字符串参数是根目录。 方法 Join
将两个字符串连接在一起,并保留重复的路径分隔符。 方法 Combine
放弃驱动器并返回当前驱动器上的根目录。 如果应用程序的当前驱动器为 C:\,并且字符串用于访问目录中的文件,则它将访问 C: 而不是 D:。 最后,由于第三次调用 ShowPathInformation
中的两个参数都是根的, Join
因此 方法只是追加它们以创建一个不合情理的文件路径,而 Combine
该方法将放弃第一个字符串并返回第二个字符串。 使用此字符串进行文件访问可能会使应用程序能够意外访问敏感文件。
using System;
using System.IO;
class Program2
{
static void Main()
{
var path1 = "C:/Program Files/";
var path2 = "Utilities/SystemUtilities";
ShowPathInformation(path1, path2);
path1 = "C:/";
path2 = "/Program Files";
ShowPathInformation(path1, path2);
path1 = "C:/Users/Public/Documents/";
path2 = "C:/Users/User1/Documents/Financial/";
ShowPathInformation(path1, path2);
}
private static void ShowPathInformation(string path1, string path2)
{
var result = Path.Join(path1.AsSpan(), path2.AsSpan());
Console.WriteLine($"Concatenating '{path1}' and '{path2}'");
Console.WriteLine($" Path.Join: '{result}'");
Console.WriteLine($" Path.Combine: '{Path.Combine(path1, path2)}'");
}
}
// The example displays the following output if run on a Windows system:
// Concatenating 'C:/Program Files/' and 'Utilities/SystemUtilities'
// Path.Join: 'C:/Program Files/Utilities/SystemUtilities'
// Path.Combine: 'C:/Program Files/Utilities/SystemUtilities'
//
// Concatenating 'C:/' and '/Program Files'
// Path.Join: 'C://Program Files'
// Path.Combine: '/Program Files'
//
// Concatenating 'C:/Users/Public/Documents/' and 'C:/Users/User1/Documents/Financial/'
// Path.Join: 'C:/Users/Public/Documents/C:/Users/User1/Documents/Financial/'
// Path.Combine: 'C:/Users/User1/Documents/Financial/'
Imports System.IO
Module Example
Public Sub Main()
Dim path1 = "C:/Program Files/"
Dim path2 = "Utilities/SystemUtilities"
ShowPathInformation(path1, path2)
path1 = "C:/"
path2 = "/Program Files"
ShowPathInformation(path1, path2)
path1 = "C:/Users/Public/Documents/"
path2 = "C:/Users/User1/Documents/Financial/"
ShowPathInformation(path1, path2)
End Sub
Private Sub ShowPathInformation(path1 As String, path2 As String)
Dim result = Path.Join(path1.AsSpan(), path2.AsSpan())
Console.WriteLine($"Concatenating '{path1}' and '{path2}'")
Console.WriteLine($" Path.Join: '{result}'")
Console.WriteLine($" Path.Combine: '{Path.Combine(path1, path2)}'")
Console.WriteLine()
End Sub
End Module
' The example displays the following output if run on a Windows system:
' Concatenating 'C:/Program Files/' and 'Utilities/SystemUtilities'
' Path.Join: 'C:/Program Files/Utilities/SystemUtilities'
' Path.Combine: 'C:/Program Files/Utilities/SystemUtilities'
'
' Concatenating 'C:/' and '/Program Files'
' Path.Join: 'C:'Program Files'
' Path.Combine: '/Program Files'
'
' Concatenating 'C:/Users/Public/Documents/' and 'C:/Users/User1/Documents/Financial/'
' Path.Join: 'C:/Users/Public/Documents/C:/Users/User1/Documents/Financial/'
' Path.Combine: 'C:/Users/User1/Documents/Financial/'
注解
此方法只是连接 path
和 ,path2
并在两个路径组件之间添加一个目录分隔符字符(如果 尚未存在于 的path1
path2
末尾或开头)。 Length如果 或 path2
的 path1
为零,该方法将返回另一个路径。 Length如果 和 path2
的 path1
为零,则方法返回 String.Empty。
如果 path1
以不适合目标平台的路径分隔符结尾,则 Join
方法将保留原始路径分隔符并追加受支持的路径分隔符。 此问题出现在使用 Windows 反斜杠 (“\”) 字符的硬编码路径中,该字符在基于 Unix 的系统上无法识别为路径分隔符。 若要解决此问题,可以:
检索 属性的值, Path.DirectorySeparatorChar 而不是硬编码目录分隔符。
使用正斜杠 (“/”) 作为目录分隔符。 此字符由基于 Unix 的系统上的 Path.DirectorySeparatorChar 属性和 Windows 系统上的 Path.AltDirectorySeparatorChar 属性返回。
Combine与 方法不同,Join该方法不会尝试对返回的路径进行根目录。 (也就是说,如果 path2
是绝对路径,则 Join
该方法不会放弃 path1
并返回 path2
,而 Combine 返回方法 ) 以下示例演示了这两个方法返回的路径之间的差异。 如果 的 path2
源是用户输入,则 Combine 方法使用户能够访问文件系统资源 (,例如 C:/Users/User1/Documents/Financial/ ,如果示例) 应用程序不打算使其可访问。
并非所有目录和文件名的无效字符都被方法解释为不 Join
可接受的,因为可以将这些字符用于搜索通配符。 例如,虽然 Path.Join("c:\\", "*.txt")
创建文件时可能无效,但它作为搜索字符串有效。 因此, 方法 Join
成功解释它。
另请参阅
适用于
Join(String[])
- Source:
- Path.cs
- Source:
- Path.cs
- Source:
- Path.cs
将路径数组连接到一个路径中。
public:
static System::String ^ Join(... cli::array <System::String ^> ^ paths);
public static string Join (params string?[] paths);
static member Join : string[] -> string
Public Shared Function Join (ParamArray paths As String()) As String
参数
- paths
- String[]
路径的数组。
返回
连接的路径。
注解
此方法只是将 中的所有字符串连接在一起, paths
并在任何路径组件之间添加目录分隔符(如果尚不存在)。 Length如果 中paths
任何路径的 为零,则 方法将连接其余参数。 如果生成的串联字符串的长度为零,则 该方法返回 String.Empty。
如果 中 paths
除最后一个路径之外的任何路径都以不适合目标平台的路径分隔符结尾,则 Join
该方法将保留原始路径分隔符并追加受支持的路径分隔符。 此问题出现在使用 Windows 反斜杠 (“\”) 字符的硬编码路径中,该字符在基于 Unix 的系统上无法识别为路径分隔符。 若要解决此问题,可以:
检索 属性的值, Path.DirectorySeparatorChar 而不是硬编码目录分隔符。
使用正斜杠 (“/”) 作为目录分隔符。 此字符由基于 Unix 的系统上的 Path.DirectorySeparatorChar 属性和 Windows 系统上的 Path.AltDirectorySeparatorChar 属性返回。
Combine与 方法不同,Join该方法不会尝试对返回的路径进行根目录。 (也就是说,如果 中 paths
除第一个路径之外的任何路径都是绝对路径,则 Join
方法不会像 方法那样 Combine 丢弃以前的路径。)
并非所有目录和文件名的无效字符都被方法解释为不 Join
可接受的,因为可以将这些字符用于搜索通配符。 例如,虽然 Path.Join("c:\\", "temp", "*.txt")
创建文件时可能无效,但它作为搜索字符串有效。 因此, 方法 Join
成功解释它。
适用于
Join(String, String)
- Source:
- Path.cs
- Source:
- Path.cs
- Source:
- Path.cs
将两个路径连接到一个路径中。
public:
static System::String ^ Join(System::String ^ path1, System::String ^ path2);
public static string Join (string? path1, string? path2);
static member Join : string * string -> string
Public Shared Function Join (path1 As String, path2 As String) As String
参数
- path1
- String
要联接的第一个路径。
- path2
- String
要联接的第二个路径。
返回
连接的路径。
注解
此方法只是连接 path
和 , path2
并在任何路径组件之间添加目录分隔符(如果尚不存在)。 如果 或 path2
的path1
长度为零,则 方法将连接其余参数。 如果生成的串联字符串的长度为零,则 方法返回 String.Empty。
如果 path1
以不适合目标平台的路径分隔符结尾,则 Join
方法将保留原始路径分隔符并追加受支持的路径分隔符。 此问题出现在使用 Windows 反斜杠 (“\”) 字符的硬编码路径中,该字符在基于 Unix 的系统上无法识别为路径分隔符。 若要解决此问题,可以:
检索 属性的值, Path.DirectorySeparatorChar 而不是硬编码目录分隔符。
使用正斜杠 (“/”) 作为目录分隔符。 此字符由基于 Unix 的系统上的 Path.DirectorySeparatorChar 属性和 Windows 系统上的 Path.AltDirectorySeparatorChar 属性返回。
Combine与 方法不同,Join该方法不会尝试对返回的路径进行根目录。 (也就是说,如果 path2
是绝对路径,则 Join
方法不会像方法那样 Combine 放弃以前的路径。)
并非所有目录和文件名的无效字符都被方法解释为不 Join
可接受的,因为可以将这些字符用于搜索通配符。 例如,虽然 Path.Join("c:\\", "temp", "*.txt")
创建文件时可能无效,但它作为搜索字符串有效。 因此, 方法 Join
成功解释它。
适用于
反馈
https://aka.ms/ContentUserFeedback。
即将发布:在整个 2024 年,我们将逐步淘汰作为内容反馈机制的“GitHub 问题”,并将其取代为新的反馈系统。 有关详细信息,请参阅:提交和查看相关反馈