Path.Join Método

Definição

Espaço de Nomes:: System.IO

Assemblagens:: netstandard.dll, System.Runtime.dll

Assemblagem:: System.Runtime.Extensions.dll

Assemblagem:: netstandard.dll

Importante

Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.

Sobrecargas

Name	Description
Join(String, String, String, String)	Concatena quatro caminhos num único caminho.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatena quatro componentes do caminho num único caminho.
Join(String, String, String)	Concatena três caminhos num único caminho.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatena três componentes de caminho num único caminho.
Join(ReadOnlySpan<String>)	Concatena um conjunto de caminhos num único caminho.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatena dois componentes do caminho num único caminho.
Join(String[])	Concatena um array de caminhos num único caminho.
Join(String, String)	Concatena dois caminhos num único caminho.

Join(String, String, String, String)

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Concatena quatro caminhos num ú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 para se juntar.

path2: String

O segundo caminho para entrar.

path3: String

O terceiro caminho para entrar.

path4: String

O quarto caminho para se juntar.

Devoluções

String

O caminho concatenado.

Observações

Este método simplesmente concatena path, path2, path3 e path4 adiciona um carácter separador de diretório entre qualquer um dos componentes do caminho, caso um não esteja já presente. Se o comprimento de qualquer de path1, path2, path3 ou path4 argumento for zero, o método concatena os argumentos restantes. Se o comprimento da cadeia concatenada resultante for zero, o método devolve String.Empty.

Se path1 ou path2path3 ou terminar num carácter separador de caminho que não seja apropriado para a plataforma de destino, o Join método preserva o carácter separador de caminho original e acrescenta o caractere suportado. Este problema surge em caminhos codificados fixamente que utilizam o carácter Windows backslash ("\"), que não é reconhecido como separador de caminhos em sistemas baseados em Unix. Para contornar esse problema, você pode:

Recuperar o valor da Path.DirectorySeparatorChar propriedade em vez de codificar diretamente um carácter separador de diretório.
Use uma barra para a frente ("/") como caractere separador de diretórios. Este carácter é devolvido pela propriedade Path.DirectorySeparatorChar em sistemas baseados em Unix e pela propriedade Path.AltDirectorySeparatorChar em sistemas Windows.

Ao contrário do Combine método, este Join não tenta enraizar o caminho devolvido. (Ou seja, se path2 ou path3path4 ou for um caminho absoluto, o Join método não descarta os caminhos anteriores como o Combine método faz.)

Nem todos os caracteres inválidos para nomes de diretórios e ficheiros são interpretados como inaceitáveis pelo Join método, porque pode usar estes caracteres para caracteres curinga de pesquisa. Por exemplo, embora Path.Join("c:\\", "temp", "*.txt") possa ser inválido ao criar um ficheiro, é válido como cadeia de pesquisa. O Join método, portanto, interpreta-o com sucesso.

Aplica-se a

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

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Concatena quatro componentes do caminho num ú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 espaço de caracteres que contém o primeiro caminho a entrar.

path2: ReadOnlySpan<Char>

Um espaço de caracteres que contém o segundo caminho para se juntar.

path3: ReadOnlySpan<Char>

Um intervalo de caracteres que contém o terceiro caminho para se juntar.

path4: ReadOnlySpan<Char>

Um espaço de caracteres que contém o quarto caminho a entrar.

Devoluções

String

O caminho concatenado.

Observações

Este método simplesmente concatena path, path2, path3 e path4 adiciona um carácter separador de diretório entre qualquer um dos componentes do caminho, caso um não esteja já presente. Se o Length de qualquer de path1, path2, path3 ou path4 argumento for zero, o método concatena os argumentos restantes. Se o ReadOnlySpan<T>.Length de todos os componentes for zero, o método retorna String.Empty.

Recuperar o valor da Path.DirectorySeparatorChar propriedade em vez de codificar diretamente um carácter separador de diretório.
Use uma barra para a frente ("/") como caractere separador de diretórios. Este carácter é devolvido pela propriedade Path.DirectorySeparatorChar em sistemas baseados em Unix e pela propriedade Path.AltDirectorySeparatorChar em sistemas Windows.

Aplica-se a

Join(String, String, String)

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Concatena três caminhos num ú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 para se juntar.

path2: String

O segundo caminho para entrar.

path3: String

O terceiro caminho para entrar.

Devoluções

String

O caminho concatenado.

Observações

Este método simplesmente concatena path, path2, e path3 adiciona um carácter separador de diretório entre qualquer um dos componentes do caminho, caso um não esteja já presente. Se o comprimento de qualquer de path1, path2 ou path3 argumento for zero, o método concatena os argumentos restantes. Se o comprimento da cadeia concatenada resultante for zero, o método devolve String.Empty.

Se path1 ou path2 terminar num carácter separador de caminho que não é apropriado para a plataforma de destino, o Join método preserva o carácter separador de caminho original e acrescenta o suportado. Este problema surge em caminhos codificados fixamente que utilizam o carácter Windows backslash ("\"), que não é reconhecido como separador de caminhos em sistemas baseados em Unix. Para contornar esse problema, você pode:

Recuperar o valor da Path.DirectorySeparatorChar propriedade em vez de codificar diretamente um carácter separador de diretório.
Use uma barra para a frente ("/") como caractere separador de diretórios. Este carácter é devolvido pela propriedade Path.DirectorySeparatorChar em sistemas baseados em Unix e pela propriedade Path.AltDirectorySeparatorChar em sistemas Windows.

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

Aplica-se a

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

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Concatena três componentes de caminho num ú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 espaço de caracteres que contém o primeiro caminho a entrar.

path2: ReadOnlySpan<Char>

Um espaço de caracteres que contém o segundo caminho para se juntar.

path3: ReadOnlySpan<Char>

Um intervalo de caracteres que contém o terceiro caminho para se juntar.

Devoluções

String

O caminho concatenado.

Exemplos

O exemplo seguinte ilustra a diferença nos caminhos devolvidos pelos Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) métodos e.Path.Combine(String, String, String) Quando a primeira cadeia é um caminho totalmente qualificado que inclui um diretório de disco e raiz e a segunda é um caminho relativo a partir do primeiro caminho, os dois métodos produzem resultados idênticos. Na segunda e terceira chamadas ao ShowPathInformation método, as cadeias devolvidas pelos dois métodos divergem. Na segunda chamada de método, o argumento da primeira cadeia é uma unidade, enquanto a segunda é um diretório enraizado. O Join método concatena as duas cadeias e preserva os separadores de caminho duplicados. Uma chamada ao GetFullPath método eliminaria a duplicação. O Combine método abandona o disco e devolve um diretório enraizado no disco atual. Se a unidade atual da aplicação for C:\ e a cadeia for usada para aceder a um ficheiro ou ficheiros no diretório, ela acederá C: em vez de D:. Finalmente, como o argumento final na terceira chamada a ShowPathInformation está enraizado, o Join método simplesmente o adiciona aos dois primeiros argumentos para criar um caminho de ficheiro sem sentido, enquanto o Combine método descarta as duas primeiras cadeias e retorna a terceira. Usar esta cadeia para aceder a ficheiros pode dar à aplicação acesso não intencional a ficheiros sensíveis.

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'

Observações

Este método simplesmente concatena path, path2, e path3 adiciona um carácter separador de diretório entre qualquer um dos componentes do caminho, caso um não esteja já presente. Se o Length de qualquer de path1, path2, ou path3 argumentos for zero, o método concatena os argumentos restantes. Se o ReadOnlySpan<T>.Length de todos os componentes for zero, o método retorna String.Empty.

Recuperar o valor da Path.DirectorySeparatorChar propriedade em vez de codificar diretamente um carácter separador de diretório.
Use uma barra para a frente ("/") como caractere separador de diretórios. Este carácter é devolvido pela propriedade Path.DirectorySeparatorChar em sistemas baseados em Unix e pela propriedade Path.AltDirectorySeparatorChar em sistemas Windows.

Ver também

Formatos de caminho de ficheiro em sistemas Windows

Aplica-se a

Join(ReadOnlySpan<String>)

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Concatena um conjunto de caminhos num único caminho.

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

Parâmetros

paths: ReadOnlySpan<String>

Um vão de caminhos.

Devoluções

String

O caminho concatenado.

Aplica-se a

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

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Concatena dois componentes do caminho num ú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 espaço de caracteres que contém o primeiro caminho a entrar.

path2: ReadOnlySpan<Char>

Um espaço de caracteres que contém o segundo caminho para se juntar.

Devoluções

String

Os caminhos combinados.

Exemplos

O exemplo seguinte ilustra a diferença nos caminhos devolvidos pelos Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) métodos e.Path.Combine(String, String) Quando a primeira cadeia é um caminho totalmente qualificado que inclui um diretório de disco e raiz, e a segunda é um caminho relativo a partir do primeiro caminho, os dois métodos produzem resultados idênticos. Na segunda e terceira chamadas ao ShowPathInformation método, as cadeias devolvidas pelos dois métodos divergem. Na segunda chamada de método, o argumento da primeira cadeia é uma unidade, enquanto a segunda é um diretório enraizado. O Join método concatena as duas cadeias e preserva os separadores de caminho duplicados. O Combine método abandona o disco e devolve um diretório enraizado no disco atual. Se a unidade atual da aplicação for C:\ e a cadeia for usada para aceder a um ficheiro ou ficheiros no diretório, ela acederá C: em vez de D:. Finalmente, como ambos os argumentos na terceira chamada para ShowPathInformation estão enraizados, o Join método simplesmente os adiciona para criar um caminho de ficheiro sem sentido, enquanto o Combine método descarta a primeira cadeia e devolve a segunda. Usar esta cadeia para aceder a ficheiros pode dar à aplicação acesso não intencional a ficheiros sensíveis.

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

Observações

Este método simplesmente concatena path e path2 e adiciona um carácter separador de diretórios entre os dois componentes do caminho se um deles não estiver já presente no final ou path1 no início de path2. Se o Length de ou path1path2 for zero, o método devolve o outro caminho. Se o Length de ambos path1 e path2 for zero, o método retorna String.Empty.

Se path1 terminar num carácter separador de caminho que não é apropriado para a plataforma de destino, o Join método preserva o carácter separador de caminho original e acrescenta o suportado. Este problema surge em caminhos codificados fixamente que utilizam o carácter Windows backslash ("\"), que não é reconhecido como separador de caminhos em sistemas baseados em Unix. Para contornar esse problema, você pode:

Recuperar o valor da Path.DirectorySeparatorChar propriedade em vez de codificar diretamente um carácter separador de diretório.
Use uma barra para a frente ("/") como caractere separador de diretórios. Este carácter é devolvido pela propriedade Path.DirectorySeparatorChar em sistemas baseados em Unix e pela propriedade Path.AltDirectorySeparatorChar em sistemas Windows.

Ao contrário do Combine método, este Join não tenta enraizar o caminho devolvido. (Ou seja, se path2 for um caminho absoluto, o Join método não descarta path1 nem retorna path2 como o Combine método faz.) O exemplo seguinte ilustra a diferença nos caminhos devolvidos pelos dois métodos. Se a fonte de path2 for a entrada do utilizador, o Combine método permite ao utilizador aceder a um recurso do sistema de ficheiros (como C:/Users/User1/Documents/Financial/ no caso do exemplo) que a aplicação não pretendia tornar acessível.

Nem todos os caracteres inválidos para nomes de diretórios e ficheiros são interpretados como inaceitáveis pelo Join método, porque pode usar estes caracteres para caracteres curinga de pesquisa. Por exemplo, embora Path.Join("c:\\", "*.txt") possa ser inválido ao criar um ficheiro, é válido como cadeia de pesquisa. O Join método, portanto, interpreta-o com sucesso.

Ver também

Formatos de caminho de ficheiro em sistemas Windows

Aplica-se a

Join(String[])

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Concatena um array de caminhos num ú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 variedade de caminhos.

Devoluções

String

O caminho concatenado.

Observações

Este método simplesmente concatena todas as cadeias de caracteres e paths adiciona um carácter separador de diretório entre qualquer um dos componentes do caminho, caso um não esteja já 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 concatenada resultante for zero, o método devolve String.Empty.

Se algum dos caminhos em paths, exceto o último, terminar num carácter separador de caminho que não é apropriado para a plataforma alvo, o Join método preserva o carácter separador de caminho original e acrescenta o suportado. Este problema surge em caminhos codificados fixamente que utilizam o carácter Windows backslash ("\"), que não é reconhecido como separador de caminhos em sistemas baseados em Unix. Para contornar esse problema, você pode:

Recuperar o valor da Path.DirectorySeparatorChar propriedade em vez de codificar diretamente um carácter separador de diretório.
Use uma barra para a frente ("/") como caractere separador de diretórios. Este carácter é devolvido pela propriedade Path.DirectorySeparatorChar em sistemas baseados em Unix e pela propriedade Path.AltDirectorySeparatorChar em sistemas Windows.

Ao contrário do Combine método, este Join não tenta enraizar o caminho devolvido. (Ou seja, se algum dos caminhos em paths, exceto o primeiro, for um caminho absoluto, o Join método não descarta os caminhos anteriores como o Combine método faz.)

Aplica-se a

Join(String, String)

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Origem:: Path.cs

Concatena dois caminhos num ú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 para se juntar.

path2: String

O segundo caminho para entrar.

Devoluções

String

O caminho concatenado.

Observações

Este método simplesmente concatena path e path2 adiciona um carácter separador de diretórios entre qualquer um dos componentes do caminho, caso um não esteja já presente. Se o comprimento de ou path1path2 for zero, o método concatena o argumento restante. Se o comprimento da cadeia concatenada resultante for zero, o método devolve String.Empty.

Recuperar o valor da Path.DirectorySeparatorChar propriedade em vez de codificar diretamente um carácter separador de diretório.
Use uma barra para a frente ("/") como caractere separador de diretórios. Este carácter é devolvido pela propriedade Path.DirectorySeparatorChar em sistemas baseados em Unix e pela propriedade Path.AltDirectorySeparatorChar em sistemas Windows.

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

Aplica-se a

Comentários

Esta página foi útil?