Path.Join Método

  • Referência

Definição

Namespace:
System.IO
Assembly:
System.Runtime.dll
Assembly:
System.Runtime.Extensions.dll
Assembly:
netstandard.dll

Sobrecargas

Join(String, String, String, String)

Concatena quatro caminhos em um único caminho.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatena componentes de quatro caminhos em um único caminho.
Join(String, String, String)

Concatena três caminhos em um único caminho.
Join(String[])

Concatena uma matriz de caminhos em um único caminho.
Join(String, String)

Concatena dois caminhos em um único caminho.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatena componentes de dois caminhos em um único caminho.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatena componentes de três caminhos em um único caminho.

Join(String, String, String, String)

Origem:
Path.cs
Origem:
Path.cs
Origem:
Path.cs

Concatena quatro caminhos em um único caminho.

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

Parâmetros

path1
String

O primeiro caminho a ser unido.

path2
String

O segundo caminho a ser unido.

path3
String

O terceiro caminho a ser unido.

path4
String

O quarto caminho a ser unido.

Retornos

String

O caminho concatenado.

Comentários

Esse método simplesmente concatena path, path2path3 e path4 e adiciona um caractere separador de diretório entre qualquer um dos componentes de caminho se um ainda não estiver presente. Se o comprimento de qualquer um dos path1argumentos , path2path3 ou path4 for zero, o método concatena os argumentos restantes. Se o comprimento da cadeia de caracteres concatenada resultante for zero, o método retornará String.Empty.

Se path1 ou path2 terminar path3 em um caractere separador de caminho que não é apropriado para a plataforma de destino, o Join método preservará o caractere separador de caminho original e acrescentará o caractere com suporte. Esse problema surge em caminhos embutidos em código que usam o caractere de barra invertida do Windows ("\"), que não é reconhecido como separador de caminho em sistemas baseados em Unix. Para contornar esse problema, você pode:

Ao contrário do Combine método , o Join método não tenta criar a raiz do caminho retornado. (Ou seja, se path2 ou path3 for path4 um caminho absoluto, o Join método não descartará os caminhos anteriores como o Combine método faz.)

Nem todos os caracteres inválidos para nomes de diretório e arquivo são interpretados como inaceitáveis pelo Join método , pois você pode usar esses caracteres para caracteres curinga de pesquisa. Por exemplo, embora Path.Join("c:\\", "temp", "*.txt") possa ser inválido ao criar um arquivo, ele é válido como uma cadeia de caracteres de pesquisa. Portanto Join , o método o interpreta com êxito.

Aplica-se a

Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Origem:
Path.cs
Origem:
Path.cs
Origem:
Path.cs

Concatena componentes de quatro caminhos em um único caminho.

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

Parâmetros

path1
ReadOnlySpan<Char>

Um intervalo de caracteres que contém o primeiro caminho a ser unido.

path2
ReadOnlySpan<Char>

Um intervalo de caracteres que contém o segundo caminho a ser unido.

path3
ReadOnlySpan<Char>

Um intervalo de caracteres que contém o terceiro caminho a ser unido.

path4
ReadOnlySpan<Char>

Um intervalo de caracteres que contém o quarto caminho a ser unido.

Retornos

String

O caminho concatenado.

Comentários

Esse método simplesmente concatena path, path2path3 e path4 e adiciona um caractere separador de diretório entre qualquer um dos componentes de caminho se um ainda não estiver presente. Se o Length de qualquer um dos path1argumentos , path2path3 ou path4 for zero, o método concatena os argumentos restantes. Se o ReadOnlySpan<T>.Length de todos os componentes for zero, o método retornará String.Empty.

Se path1 ou path2 terminar path3 em um caractere separador de caminho que não é apropriado para a plataforma de destino, o Join método preservará o caractere separador de caminho original e acrescentará o caractere com suporte. Esse problema surge em caminhos embutidos em código que usam o caractere de barra invertida do Windows ("\"), que não é reconhecido como separador de caminho em sistemas baseados em Unix. Para contornar esse problema, você pode:

Ao contrário do Combine método , o Join método não tenta criar a raiz do caminho retornado. (Ou seja, se path2 ou path3 for path4 um caminho absoluto, o Join método não descartará os caminhos anteriores como o Combine método faz.)

Nem todos os caracteres inválidos para nomes de diretório e arquivo são interpretados como inaceitáveis pelo Join método , pois você pode usar esses caracteres para caracteres curinga de pesquisa. Por exemplo, embora Path.Join("c:\\", "temp", "*.txt") possa ser inválido ao criar um arquivo, ele é válido como uma cadeia de caracteres de pesquisa. Portanto Join , o método o interpreta com êxito.

Aplica-se a

Join(String, String, String)

Origem:
Path.cs
Origem:
Path.cs
Origem:
Path.cs

Concatena três caminhos em um único caminho.

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

Parâmetros

path1
String

O primeiro caminho a ser unido.

path2
String

O segundo caminho a ser unido.

path3
String

O terceiro caminho a ser unido.

Retornos

String

O caminho concatenado.

Comentários

Esse método simplesmente concatena path, path2e path3 e adiciona um caractere separador de diretório entre qualquer um dos componentes de caminho se um ainda não estiver presente. Se o comprimento de qualquer um dos path1path2 argumentos ou path3 for zero, o método concatena os argumentos restantes. Se o comprimento da cadeia de caracteres concatenada resultante for zero, o método retornará String.Empty.

Se path1 ou path2 terminar em um caractere separador de caminho que não seja apropriado para a plataforma de destino, o Join método preservará o caractere separador de caminho original e acrescentará o caractere com suporte. Esse problema surge em caminhos embutidos em código que usam o caractere de barra invertida do Windows ("\"), que não é reconhecido como separador de caminho em sistemas baseados em Unix. Para contornar esse problema, você pode:

Ao contrário do Combine método , o Join método não tenta criar a raiz do caminho retornado. (Ou seja, se path2 ou path3 for um caminho absoluto, o Join método não descartará os caminhos anteriores como o Combine método faz.)

Nem todos os caracteres inválidos para nomes de diretório e arquivo são interpretados como inaceitáveis pelo Join método , pois você pode usar esses caracteres para caracteres curinga de pesquisa. Por exemplo, embora Path.Join("c:\\", "temp", "*.txt") possa ser inválido ao criar um arquivo, ele é válido como uma cadeia de caracteres de pesquisa. Portanto Join , o método o interpreta com êxito.

Aplica-se a

Join(String[])

Origem:
Path.cs
Origem:
Path.cs
Origem:
Path.cs

Concatena uma matriz de caminhos em um único caminho.

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

Parâmetros

paths
String[]

Uma matriz de caminhos.

Retornos

String

O caminho concatenado.

Comentários

Esse método simplesmente concatena todas as cadeias de caracteres em paths e adiciona um caractere separador de diretório entre qualquer um dos componentes de caminho se um ainda não estiver presente. Se o Length de qualquer um dos caminhos em paths for zero, o método concatena os argumentos restantes. Se o comprimento da cadeia de caracteres concatenada resultante for zero, o método retornará String.Empty.

Se qualquer um dos caminhos em paths, exceto o último, terminar em um caractere separador de caminho que não seja apropriado para a plataforma de destino, o Join método preservará o caractere separador de caminho original e acrescentará o caractere com suporte. Esse problema surge em caminhos embutidos em código que usam o caractere de barra invertida do Windows ("\"), que não é reconhecido como separador de caminho em sistemas baseados em Unix. Para contornar esse problema, você pode:

Ao contrário do Combine método , o Join método não tenta criar a raiz do caminho retornado. (Ou seja, se qualquer um dos caminhos em paths, exceto o primeiro, for um caminho absoluto, o Join método não descartará os caminhos anteriores como o Combine método faz.)

Nem todos os caracteres inválidos para nomes de diretório e arquivo são interpretados como inaceitáveis pelo Join método , pois você pode usar esses caracteres para caracteres curinga de pesquisa. Por exemplo, embora Path.Join("c:\\", "temp", "*.txt") possa ser inválido ao criar um arquivo, ele é válido como uma cadeia de caracteres de pesquisa. Portanto Join , o método o interpreta com êxito.

Aplica-se a

Join(String, String)

Origem:
Path.cs
Origem:
Path.cs
Origem:
Path.cs

Concatena dois caminhos em um único caminho.

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

Parâmetros

path1
String

O primeiro caminho a ser unido.

path2
String

O segundo caminho a ser unido.

Retornos

String

O caminho concatenado.

Comentários

Esse método simplesmente concatena path e path2 adiciona um caractere separador de diretório entre qualquer um dos componentes de caminho se um ainda não estiver presente. Se o comprimento de ou path1path2 for zero, o método concatena o argumento restante. Se o comprimento da cadeia de caracteres concatenada resultante for zero, o método retornará String.Empty.

Se path1 terminar em um caractere separador de caminho que não é apropriado para a plataforma de destino, o Join método preservará o caractere separador de caminho original e acrescentará o caractere com suporte. Esse problema surge em caminhos embutidos em código que usam o caractere de barra invertida do Windows ("\"), que não é reconhecido como separador de caminho em sistemas baseados em Unix. Para contornar esse problema, você pode:

Ao contrário do Combine método , o Join método não tenta raiz do caminho retornado. (Ou seja, se path2 for um caminho absoluto, o Join método não descartará os caminhos anteriores como o Combine método faz.)

Nem todos os caracteres inválidos para nomes de diretório e arquivo são interpretados como inaceitáveis pelo Join método , pois você pode usar esses caracteres para pesquisar caracteres curinga. Por exemplo, embora Path.Join("c:\\", "temp", "*.txt") possa ser inválido ao criar um arquivo, ele é válido como uma cadeia de caracteres de pesquisa. Portanto Join , o método o interpreta com êxito.

Aplica-se a

Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Origem:
Path.cs
Origem:
Path.cs
Origem:
Path.cs

Concatena componentes de dois caminhos em um único caminho.

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

Parâmetros

path1
ReadOnlySpan<Char>

Um intervalo de caracteres que contém o primeiro caminho a ser unido.

path2
ReadOnlySpan<Char>

Um intervalo de caracteres que contém o segundo caminho a ser unido.

Retornos

String

Os caminhos combinados.

Exemplos

O exemplo a seguir ilustra a diferença nos caminhos retornados pelos Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) métodos e Path.Combine(String, String) . Quando a primeira cadeia de caracteres é um caminho totalmente qualificado que inclui uma unidade e um diretório raiz e o segundo é um caminho relativo do primeiro caminho, os dois métodos produzem resultados idênticos. Na segunda e terceira chamadas para o ShowPathInformation método , as cadeias de caracteres retornadas pelos dois métodos divergem. Na segunda chamada de método, o primeiro argumento de cadeia de caracteres é uma unidade, enquanto o segundo é um diretório raiz. O Join método concatena as duas cadeias de caracteres e preserva separadores de caminho duplicados. O Combine método abandona a unidade e retorna um diretório com raiz na unidade atual. Se a unidade atual do aplicativo for C:\ e a cadeia de caracteres for usada para acessar um arquivo ou arquivos no diretório, ela acessará C: em vez de D:. Por fim, como ambos os argumentos na terceira chamada para ShowPathInformation têm raiz, o Join método simplesmente os acrescenta para criar um caminho de arquivo sem sentido, enquanto o Combine método descarta a primeira cadeia de caracteres e retorna a segunda. Usar essa cadeia de caracteres para acesso a arquivos pode dar ao aplicativo acesso não intencional a arquivos confidenciais.

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

Comentários

Esse método simplesmente concatena path e path2 adiciona um caractere separador de diretório entre os dois componentes de caminho se um ainda não estiver presente no final ou path1 no início de path2. Se o Length de path1 ou path2 for zero, o método retornará o outro caminho. Se o Length de path1 e path2 for zero, o método retornará String.Empty.

Se path1 terminar em um caractere separador de caminho que não é apropriado para a plataforma de destino, o Join método preservará o caractere separador de caminho original e acrescentará o com suporte. Esse problema surge em caminhos embutidos em código que usam o caractere de barra invertida do Windows ("\"), que não é reconhecido como separador de caminho em sistemas baseados em Unix. Para contornar esse problema, você pode:

Ao contrário do Combine método , o Join método não tenta raiz do caminho retornado. (Ou seja, se path2 for um caminho absoluto, o Join método não descartará path1 e retornará path2 como o Combine método faz.) O exemplo a seguir ilustra a diferença nos caminhos retornados pelos dois métodos. Se a origem de for entrada do path2 usuário, o Combine método possibilita que um usuário acesse um recurso do sistema de arquivos (como C:/Users/User1/Documents/Financial/ no caso do exemplo) que o aplicativo não pretendia tornar acessível.

Nem todos os caracteres inválidos para nomes de diretório e arquivo são interpretados como inaceitáveis pelo Join método , pois você pode usar esses caracteres para pesquisar caracteres curinga. Por exemplo, embora Path.Join("c:\\", "*.txt") possa ser inválido ao criar um arquivo, ele é válido como uma cadeia de caracteres de pesquisa. Portanto Join , o método o interpreta com êxito.

Confira também

Aplica-se a

Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Origem:
Path.cs
Origem:
Path.cs
Origem:
Path.cs

Concatena componentes de três caminhos em um único caminho.

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

Parâmetros

path1
ReadOnlySpan<Char>

Um intervalo de caracteres que contém o primeiro caminho a ser unido.

path2
ReadOnlySpan<Char>

Um intervalo de caracteres que contém o segundo caminho a ser unido.

path3
ReadOnlySpan<Char>

Um intervalo de caracteres que contém o terceiro caminho a ser unido.

Retornos

String

O caminho concatenado.

Exemplos

O exemplo a seguir ilustra a diferença nos caminhos retornados pelos Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) métodos e Path.Combine(String, String, String) . Quando a primeira cadeia de caracteres é um caminho totalmente qualificado que inclui uma unidade e um diretório raiz e o segundo é um caminho relativo do primeiro caminho, os dois métodos produzem resultados idênticos. Na segunda e terceira chamadas para o ShowPathInformation método , as cadeias de caracteres retornadas pelos dois métodos divergem. Na segunda chamada de método, o primeiro argumento de cadeia de caracteres é uma unidade, enquanto o segundo é um diretório raiz. O Join método concatena as duas cadeias de caracteres e preserva separadores de caminho duplicados. Uma chamada para o GetFullPath método eliminaria a duplicação. O Combine método abandona a unidade e retorna um diretório com raiz na unidade atual. Se a unidade atual do aplicativo for C:\ e a cadeia de caracteres for usada para acessar um arquivo ou arquivos no diretório, ela acessará C: em vez de D:. Por fim, como o argumento final na terceira chamada a ShowPathInformation tem raiz, o Join método simplesmente o acrescenta aos dois primeiros argumentos para criar um caminho de arquivo sem sentido, enquanto o Combine método descarta as duas primeiras cadeias de caracteres e retorna a terceira. Usar essa cadeia de caracteres para acesso a arquivos pode dar ao aplicativo acesso não intencional a arquivos confidenciais.

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'

Comentários

Esse método simplesmente concatena path, path2e path3 adiciona um caractere separador de diretório entre qualquer um dos componentes de caminho se ainda não estiver presente. Se o Length de qualquer um dos path1argumentos , path2ou path3 for zero, o método concatena os argumentos restantes. Se o ReadOnlySpan<T>.Length de todos os componentes for zero, o método retornará String.Empty.

Se path1 ou path2 terminar em um caractere separador de caminho que não é apropriado para a plataforma de destino, o Join método preservará o caractere separador de caminho original e acrescentará o com suporte. Esse problema surge em caminhos embutidos em código que usam o caractere de barra invertida do Windows ("\"), que não é reconhecido como separador de caminho em sistemas baseados em Unix. Para contornar esse problema, você pode:

Ao contrário do Combine método , o Join método não tenta raiz do caminho retornado. (Ou seja, se path2 ou path3 for um caminho absoluto, o Join método não descartará os caminhos anteriores como o Combine método faz.)

Nem todos os caracteres inválidos para nomes de diretório e arquivo são interpretados como inaceitáveis pelo Join método , pois você pode usar esses caracteres para pesquisar caracteres curinga. Por exemplo, embora Path.Join("c:\\", "temp", "*.txt") possa ser inválido ao criar um arquivo, ele é válido como uma cadeia de caracteres de pesquisa. Portanto Join , o método o interpreta com êxito.

Confira também

Aplica-se a