Path.Combine Método

Definição

Combina as cadeias de caracteres em um caminho.Combines strings into a path.

Sobrecargas

Combine(String[])

Combina uma matriz de cadeias de caracteres em um caminho.Combines an array of strings into a path.

Combine(String, String)

Combina duas cadeias de caracteres em um caminho.Combines two strings into a path.

Combine(String, String, String)

Combina três cadeias de caracteres em um caminho.Combines three strings into a path.

Combine(String, String, String, String)

Combina quatro cadeias de caracteres em um caminho.Combines four strings into a path.

Comentários

Esse método destina-se a concatenar cadeias de caracteres individuais em uma única cadeia que representa um caminho de arquivo.This method is intended to concatenate individual strings into a single string that represents a file path. No entanto, se um argumento diferente do primeiro contiver um caminho com raiz, todos os componentes de caminho anteriores serão ignorados e a cadeia de caracteres retornada começará com esse componente de caminho com raiz.However, if an argument other than the first contains a rooted path, any previous path components are ignored, and the returned string begins with that rooted path component. Como alternativa ao Combine método, considere usar os Join TryJoin métodos ou.As an alternative to the Combine method, consider using the Join or TryJoin methods.

Importante

Esse método pressupõe que o primeiro argumento é um caminho absoluto e que o argumento ou argumentos a seguir são caminhos relativos.This method assumes that the first argument is an absolute path and that the following argument or arguments are relative paths. Se esse não for o caso e, particularmente, se qualquer argumento subsequente for uma entrada de cadeias de caracteres pelo usuário, chame o Join TryJoin método ou em vez disso.If this is not the case, and particularly if any subsequent arguments are strings input by the user, call the Join or TryJoin method instead.

Combine(String[])

Combina uma matriz de cadeias de caracteres em um caminho.Combines an array of strings into a path.

public:
 static System::String ^ Combine(... cli::array <System::String ^> ^ paths);
public static string Combine (params string[] paths);
static member Combine : string[] -> string
Public Shared Function Combine (ParamArray paths As String()) As String

Parâmetros

paths
String[]

Uma matriz de partes do caminho.An array of parts of the path.

Retornos

String

Os caminhos combinados.The combined paths.

Exceções

Versões do .NET Framework e do .NET Core anteriores a 2,1: uma das cadeias de caracteres na matriz contém um ou mais dos personagens inválidos definidos em GetInvalidPathChars() ..NET Framework and .NET Core versions older than 2.1: One of the strings in the array contains one or more of the invalid characters defined in GetInvalidPathChars().

Uma das cadeias de caracteres na matriz é null.One of the strings in the array is null.

Exemplos

O exemplo a seguir combina uma matriz de cadeias de caracteres em um caminho.The following example combines an array of strings into a path.

string[] paths = {@"d:\archives", "2001", "media", "images"};
string fullPath = Path.Combine(paths);
Console.WriteLine(fullPath);
Dim paths As String() = {"d:\archives", "2001", "media", "images"}
Dim fullPath As String = Path.Combine(paths)
Console.WriteLine(fullPath)

Comentários

paths deve ser uma matriz das partes do caminho a serem combinadas.paths should be an array of the parts of the path to combine. Se um dos caminhos subsequentes for um caminho absoluto, a operação combinar redefinirá a partir desse caminho absoluto, descartando todos os caminhos combinados anteriores.If the one of the subsequent paths is an absolute path, then the combine operation resets starting with that absolute path, discarding all previous combined paths.

Se qualquer elemento no paths , mas o último não for uma unidade e não terminar com o DirectorySeparatorChar AltDirectorySeparatorChar caractere ou, o Combine método adicionará um DirectorySeparatorChar caractere entre esse elemento e o próximo.If any element in paths but the last one is not a drive and does not end with either the DirectorySeparatorChar or the AltDirectorySeparatorChar character, the Combine method adds a DirectorySeparatorChar character between that element and the next one. Observe que, se o elemento terminar em um caractere separador de caminho que não seja apropriado para a plataforma de destino, o Combine método preservará o caractere separador de caminho original e acrescentará um com suporte.Note that, if the element ends in a path separator character that is not appropriate for the target platform, the Combine method preserves the original path separator character and appends a supported one. O exemplo a seguir compara o resultado em sistemas baseados em Windows e UNIX quando a barra invertida é usada como um caractere separador de caminho.The following example compares the result on Windows and Unix-based systems when the backslash is used as a path separator character.

string[] paths = {@"d:\archives", "2001", "media", "images"};
string fullPath = Path.Combine(paths);
Console.WriteLine(fullPath);            

paths = new string[] {@"d:\archives\", @"2001\", "media", "images"};
fullPath = Path.Combine(paths);
Console.WriteLine(fullPath); 

paths = new string[] {"d:/archives/", "2001/", "media", "images"};
fullPath = Path.Combine(paths);
Console.WriteLine(fullPath); 
// The example displays the following output if run on a Windows system:
//    d:\archives\2001\media\images
//    d:\archives\2001\media\images
//    d:/archives/2001/media\images
//
// The example displays the following output if run on a Unix-based system:
//    d:\archives/2001/media/images
//    d:\archives\/2001\/media/images
//    d:/archives/2001/media/images        
Dim paths As String() = { "d:\archives", "2001", "media", "images" }
Dim fullPath As String = Path.Combine(paths)
Console.WriteLine(fullPath)            

paths = { "d:\archives\", "2001\", "media", "images" }
fullPath = Path.Combine(paths)
Console.WriteLine(fullPath) 

paths = { "d:/archives/", "2001/", "media", "images" }
fullPath = Path.Combine(paths)
Console.WriteLine(fullPath) 
' The example displays the following output if run on a Windows system:
'    d:\archives\2001\media\images
'    d:\archives\2001\media\images
'    d:/archives/2001/media\images
'
' The example displays the following output if run on a Linux system:
'    d:\archives/2001/media/images
'    d:\archives\/2001\/media/images
'    d:/archives/2001/media/images    

As cadeias de caracteres de comprimento zero são omitidas do caminho combinado.Zero-length strings are omitted from the combined path.

Os parâmetros não serão analisados se tiverem espaço em branco.The parameters are not parsed if they have white space.

.NET Framework e versões do .NET Core anteriores a 2,1: nem todos os caracteres inválidos para nomes de diretório e arquivo são interpretados como inaceitáveis pelo Combine método, pois você pode usar esses caracteres para caracteres curinga de pesquisa..NET Framework and .NET Core versions older than 2.1: Not all invalid characters for directory and file names are interpreted as unacceptable by the Combine method, because you can use these characters for search wildcard characters. Por exemplo, embora Path.Combine("c:\\", "*.txt") possa ser inválido se você fosse criar um arquivo a partir dele, ele é válido como uma cadeia de caracteres de pesquisa.For example, while Path.Combine("c:\\", "*.txt") might be invalid if you were to create a file from it, it is valid as a search string. Portanto, ele é interpretado com êxito pelo Combine método.It is therefore successfully interpreted by the Combine method.

Aplica-se a

Combine(String, String)

Combina duas cadeias de caracteres em um caminho.Combines two strings into a path.

public:
 static System::String ^ Combine(System::String ^ path1, System::String ^ path2);
public static string Combine (string path1, string path2);
static member Combine : string * string -> string
Public Shared Function Combine (path1 As String, path2 As String) As String

Parâmetros

path1
String

O primeiro caminho a ser combinado.The first path to combine.

path2
String

O segundo caminho a ser combinado.The second path to combine.

Retornos

String

Os caminhos combinados.The combined paths. Se um dos caminhos especificados for uma cadeia de comprimento zero, esse método retornará o outro caminho.If one of the specified paths is a zero-length string, this method returns the other path. Se path2 contiver um caminho absoluto, esse método retornará path2.If path2 contains an absolute path, this method returns path2.

Exceções

.NET Framework e versões do .NET Core anteriores a 2,1: path1 ou path2 contém um ou mais dos caracteres inválidos definidos em GetInvalidPathChars() ..NET Framework and .NET Core versions older than 2.1: path1 or path2 contains one or more of the invalid characters defined in GetInvalidPathChars().

path1 ou path2 é null.path1 or path2 is null.

Exemplos

O exemplo a seguir demonstra o uso do Combine método em uma plataforma de área de trabalho baseada no Windows.The following example demonstrates using the Combine method on a Windows-based desktop platform.

using namespace System;
using namespace System::IO;
void CombinePaths( String^ p1, String^ p2 )
{
   try
   {
      String^ combination = Path::Combine( p1, p2 );
      Console::WriteLine( "When you combine '{0}' and '{1}', the result is: {2}'{3}'", p1, p2, Environment::NewLine, combination );
   }
   catch ( Exception^ e ) 
   {
      if (p1 == nullptr)
         p1 = "nullptr";
      if (p2 == nullptr)
         p2 = "nullptr";
      Console::WriteLine( "You cannot combine '{0}' and '{1}' because: {2}{3}", p1, p2, Environment::NewLine, e->Message );
   }

   Console::WriteLine();
}

int main()
{
   String^ path1 = "c:\\temp";
   String^ path2 = "subdir\\file.txt";
   String^ path3 = "c:\\temp.txt";
   String^ path4 = "c:^*&)(_=@#'\\^&#2.*(.txt";
   String^ path5 = "";
   String^ path6 = nullptr;
   CombinePaths( path1, path2 );
   CombinePaths( path1, path3 );
   CombinePaths( path3, path2 );
   CombinePaths( path4, path2 );
   CombinePaths( path5, path2 );
   CombinePaths( path6, path2 );
}

using System;
using System.IO;

public class ChangeExtensionTest {

    public static void Main() {

        string path1 = "c:\\temp";
        string path2 = "subdir\\file.txt";
        string path3 = "c:\\temp.txt";
        string path4 = "c:^*&)(_=@#'\\^&#2.*(.txt";
        string path5 = "";
        string path6 = null;

        CombinePaths(path1, path2);
        CombinePaths(path1, path3);
        CombinePaths(path3, path2);
        CombinePaths(path4, path2);
        CombinePaths(path5, path2);
        CombinePaths(path6, path2);
    }

    private static void CombinePaths(string p1, string p2) {

        try {
            string combination = Path.Combine(p1, p2);

            Console.WriteLine("When you combine '{0}' and '{1}', the result is: {2}'{3}'",
                        p1, p2, Environment.NewLine, combination);
        } catch (Exception e) {
            if (p1 == null)
                p1 = "null";
            if (p2 == null)
                p2 = "null";
            Console.WriteLine("You cannot combine '{0}' and '{1}' because: {2}{3}",
                        p1, p2, Environment.NewLine, e.Message);
        }

        Console.WriteLine();
    }
}
// This code produces output similar to the following:
//
// When you combine 'c:\temp' and 'subdir\file.txt', the result is:
// 'c:\temp\subdir\file.txt'
//
// When you combine 'c:\temp' and 'c:\temp.txt', the result is:
// 'c:\temp.txt'
//
// When you combine 'c:\temp.txt' and 'subdir\file.txt', the result is:
// 'c:\temp.txt\subdir\file.txt'
//
// When you combine 'c:^*&)(_=@#'\^&#2.*(.txt' and 'subdir\file.txt', the result is:
// 'c:^*&)(_=@#'\^&#2.*(.txt\subdir\file.txt'
//
// When you combine '' and 'subdir\file.txt', the result is:
// 'subdir\file.txt'
//
// You cannot combine 'null' and 'subdir\file.txt' because:
// Value cannot be null.
// Parameter name: path1
Imports System.IO

Public Class ChangeExtensionTest
    
    
    Public Shared Sub Main()
        Dim path1 As String = "c:\temp"
        Dim path2 As String = "subdir\file.txt"
        Dim path3 As String = "c:\temp.txt"
        Dim path4 As String = "c:^*&)(_=@#'\\^&#2.*(.txt"
        Dim path5 As String = ""
        Dim path6 As String = Nothing

        CombinePaths(path1, path2)
        CombinePaths(path1, path3)
        CombinePaths(path3, path2)
        CombinePaths(path4, path2)
        CombinePaths(path5, path2)
        CombinePaths(path6, path2)
    End Sub

    Private Shared Sub CombinePaths(p1 As String, p2 As String)
        
        Try
            Dim combination As String = Path.Combine(p1, p2)
            
            Console.WriteLine("When you combine '{0}' and '{1}', the result is: {2}'{3}'", p1, p2, Environment.NewLine, combination)
        Catch e As Exception
            If p1 = Nothing Then
                p1 = "Nothing"
            End If
            If p2 = Nothing Then
                p2 = "Nothing"
            End If
            Console.WriteLine("You cannot combine '{0}' and '{1}' because: {2}{3}", p1, p2, Environment.NewLine, e.Message)
        End Try
        
        Console.WriteLine()
    End Sub
End Class
' This code produces output similar to the following:
'
' When you combine 'c:\temp' and 'subdir\file.txt', the result is: 
' 'c:\temp\subdir\file.txt'
' 
' When you combine 'c:\temp' and 'c:\temp.txt', the result is: 
' 'c:\temp.txt'
' 
' When you combine 'c:\temp.txt' and 'subdir\file.txt', the result is: 
' 'c:\temp.txt\subdir\file.txt'
' 
' When you combine 'c:^*&)(_=@#'\^&#2.*(.txt' and 'subdir\file.txt', the result is: 
' 'c:^*&)(_=@#'\^&#2.*(.txt\subdir\file.txt'
' 
' When you combine '' and 'subdir\file.txt', the result is: 
' 'subdir\file.txt'
' 
' You cannot combine '' and 'subdir\file.txt' because: 
' Value cannot be null.
' Parameter name: path1

Comentários

Se path1 não for uma referência de unidade (ou seja, "C:" ou "D:") e não terminar com um caractere separador válido, conforme definido em DirectorySeparatorChar , AltDirectorySeparatorChar ou VolumeSeparatorChar , DirectorySeparatorChar será anexado path1 antes da concatenação.If path1 is not a drive reference (that is, "C:" or "D:") and does not end with a valid separator character as defined in DirectorySeparatorChar, AltDirectorySeparatorChar, or VolumeSeparatorChar, DirectorySeparatorChar is appended to path1 before concatenation. Observe que path1 , se o terminar em um caractere separador de caminho que não seja apropriado para a plataforma de destino, o Combine método preservará o caractere separador de caminho original e acrescentará um com suporte.Note that if path1 ends in a path separator character that is not appropriate for the target platform, the Combine method preserves the original path separator character and appends a supported one. O exemplo a seguir compara o resultado em sistemas baseados em Windows e UNIX quando a barra invertida é usada como um caractere separador de caminho.The following example compares the result on Windows and Unix-based systems when the backslash is used as a path separator character.

var result = Path.Combine(@"C:\Pictures\", "Saved Pictures"); 
Console.WriteLine(result);
// The example displays the following output if run on a Windows system:
//    C:\Pictures\Saved Pictures
//
// The example displays the following output if run on a Unix-based system:
//    C:\Pictures\/Saved Pictures        
Dim result = Path.Combine("C:\Pictures\", "Saved Pictures") 
Console.WriteLine(result)
' The example displays the following output if run on a Windows system:
'    C:\Pictures\Saved Pictures
'
' The example displays the following output if run on a Unix-based system:
'    C:\Pictures\/Saved Pictures        

Se não path2 incluir uma raiz (por exemplo, se não path2 começar com um caractere separador ou uma especificação de unidade), o resultado será uma concatenação dos dois caminhos, com um caractere separador intermediário.If path2 does not include a root (for example, if path2 does not start with a separator character or a drive specification), the result is a concatenation of the two paths, with an intervening separator character. Se path2 incluir uma raiz, path2 será retornado.If path2 includes a root, path2 is returned.

Os parâmetros não serão analisados se tiverem espaço em branco.The parameters are not parsed if they have white space. Portanto, se path2 incluir espaço em branco (por exemplo, "\file.txt"), o Combine método acrescentará em path2 path1 vez de retornar apenas path2 .Therefore, if path2 includes white space (for example, " \file.txt "), the Combine method appends path2 to path1 instead of returning only path2.

.NET Framework e versões do .NET Core anteriores a 2,1: nem todos os caracteres inválidos para nomes de diretório e arquivo são interpretados como inaceitáveis pelo Combine método, pois você pode usar esses caracteres para caracteres curinga de pesquisa..NET Framework and .NET Core versions older than 2.1: Not all invalid characters for directory and file names are interpreted as unacceptable by the Combine method, because you can use these characters for search wildcard characters. Por exemplo, embora Path.Combine("c:\\", "*.txt") possa ser inválido se você fosse criar um arquivo a partir dele, ele é válido como uma cadeia de caracteres de pesquisa.For example, while Path.Combine("c:\\", "*.txt") might be invalid if you were to create a file from it, it is valid as a search string. Portanto, ele é interpretado com êxito pelo Combine método.It is therefore successfully interpreted by the Combine method.

Para obter uma lista de tarefas comuns de e/s, consulte tarefas comuns de e/s.For a list of common I/O tasks, see Common I/O Tasks.

Aplica-se a

Combine(String, String, String)

Combina três cadeias de caracteres em um caminho.Combines three strings into a path.

public:
 static System::String ^ Combine(System::String ^ path1, System::String ^ path2, System::String ^ path3);
public static string Combine (string path1, string path2, string path3);
static member Combine : string * string * string -> string
Public Shared Function Combine (path1 As String, path2 As String, path3 As String) As String

Parâmetros

path1
String

O primeiro caminho a ser combinado.The first path to combine.

path2
String

O segundo caminho a ser combinado.The second path to combine.

path3
String

O terceiro caminho a ser combinado.The third path to combine.

Retornos

String

Os caminhos combinados.The combined paths.

Exceções

As versões .NET Framework e .NET Core anteriores a 2,1: path1 , path2 ou path3 contém um ou mais dos caracteres inválidos definidos em GetInvalidPathChars() ..NET Framework and .NET Core versions older than 2.1: path1, path2, or path3 contains one or more of the invalid characters defined in GetInvalidPathChars().

path1, path2 ou path3 é null.path1, path2, or path3 is null.

Exemplos

O exemplo a seguir combina três caminhos.The following example combines three paths.

string p1 = @"d:\archives\";
string p2 = "media";
string p3 = "images";
string combined = Path.Combine(p1, p2, p3);
Console.WriteLine(combined);
Dim p1 As String = "d:\archives\"
Dim p2 As String = "media"
Dim p3 As String = "images"
Dim combined As String = Path.Combine(p1, p2, p3)
Console.WriteLine(combined)

Comentários

path1 deve ser um caminho absoluto (por exemplo, "d:\archives" ou " \ \archives\public").path1 should be an absolute path (for example, "d:\archives" or "\\archives\public"). Se path2 ou path3 for também um caminho absoluto, a operação combinar descartará todos os caminhos combinados anteriormente e redefinirá esse caminho absoluto.If path2 or path3 is also an absolute path, the combine operation discards all previously combined paths and resets to that absolute path.

As cadeias de caracteres de comprimento zero são omitidas do caminho combinado.Zero-length strings are omitted from the combined path.

Se path1 ou path2 não for uma referência de unidade (ou seja, "C:" ou "D:") e não terminar com um caractere separador válido, conforme definido em DirectorySeparatorChar , AltDirectorySeparatorChar ou VolumeSeparatorChar , DirectorySeparatorChar será anexado path1 ou path2 antes da concatenação.If path1 or path2 is not a drive reference (that is, "C:" or "D:") and does not end with a valid separator character as defined in DirectorySeparatorChar, AltDirectorySeparatorChar, or VolumeSeparatorChar, DirectorySeparatorChar is appended to path1 or path2 before concatenation. Observe que se path1 ou path2 terminar em um caractere separador de caminho que não seja apropriado para a plataforma de destino, o Combine método preservará o caractere separador de caminho original e acrescentará um com suporte.Note that if path1 or path2 ends in a path separator character that is not appropriate for the target platform, the Combine method preserves the original path separator character and appends a supported one. O exemplo a seguir compara o resultado em sistemas baseados em Windows e UNIX quando a barra invertida é usada como um caractere separador de caminho.The following example compares the result on Windows and Unix-based systems when the backslash is used as a path separator character.

var result = Path.Combine(@"C:\Pictures\", @"Saved Pictures\", "2019"); 
Console.WriteLine(result);
// The example displays the following output if run on a Windows system:
//    C:\Pictures\Saved Pictures\2019
//
// The example displays the following output if run on a Unix-based system:
//    C:\Pictures\/Saved Pictures\/2019      
Dim result = Path.Combine("C:\Pictures\", "Saved Pictures\", "2019") 
Console.WriteLine(result)
' The example displays the following output if run on a Windows system:
'    C:\Pictures\Saved Pictures\2019
'
' The example displays the following output if run on a Unix-based system:
'    C:\Pictures\/Saved Pictures\/2019      

Se não path2 incluir uma raiz (por exemplo, se não path2 começar com um caractere separador ou uma especificação de unidade), o resultado será uma concatenação dos dois caminhos, com um caractere separador intermediário.If path2 does not include a root (for example, if path2 does not start with a separator character or a drive specification), the result is a concatenation of the two paths, with an intervening separator character. Se path2 incluir uma raiz, path2 será retornado.If path2 includes a root, path2 is returned.

Os parâmetros não serão analisados se tiverem espaço em branco.The parameters are not parsed if they have white space. Portanto, se path2 incluir espaço em branco (por exemplo, "\file.txt"), o Combine método acrescentará path2 a path1 .Therefore, if path2 includes white space (for example, " \file.txt "), the Combine method appends path2 to path1.

.NET Framework e versões do .NET Core anteriores a 2,1: nem todos os caracteres inválidos para nomes de diretório e arquivo são interpretados como inaceitáveis pelo Combine método, pois você pode usar esses caracteres para caracteres curinga de pesquisa..NET Framework and .NET Core versions older than 2.1: Not all invalid characters for directory and file names are interpreted as unacceptable by the Combine method, because you can use these characters for search wildcard characters. Por exemplo, embora Path.Combine("c:\\", "*.txt") possa ser inválido se você fosse criar um arquivo a partir dele, ele é válido como uma cadeia de caracteres de pesquisa.For example, while Path.Combine("c:\\", "*.txt") might be invalid if you were to create a file from it, it is valid as a search string. Portanto, ele é interpretado com êxito pelo Combine método.It is therefore successfully interpreted by the Combine method.

Aplica-se a

Combine(String, String, String, String)

Combina quatro cadeias de caracteres em um caminho.Combines four strings into a path.

public:
 static System::String ^ Combine(System::String ^ path1, System::String ^ path2, System::String ^ path3, System::String ^ path4);
public static string Combine (string path1, string path2, string path3, string path4);
static member Combine : string * string * string * string -> string
Public Shared Function Combine (path1 As String, path2 As String, path3 As String, path4 As String) As String

Parâmetros

path1
String

O primeiro caminho a ser combinado.The first path to combine.

path2
String

O segundo caminho a ser combinado.The second path to combine.

path3
String

O terceiro caminho a ser combinado.The third path to combine.

path4
String

O quarto caminho a ser combinado.The fourth path to combine.

Retornos

String

Os caminhos combinados.The combined paths.

Exceções

As versões .NET Framework e .NET Core anteriores a 2,1: path1 ,, path2 path3 ou path4 contém um ou mais dos caracteres inválidos definidos em GetInvalidPathChars() ..NET Framework and .NET Core versions older than 2.1: path1, path2, path3, or path4 contains one or more of the invalid characters defined in GetInvalidPathChars().

path1, path2, path3 ou path4 é null.path1, path2, path3, or path4 is null.

Exemplos

O exemplo a seguir combina quatro caminhos.The following example combines four paths.

string path1 = @"d:\archives\";
string path2 = "2001";
string path3 = "media";
string path4 = "images";
string combinedPath = Path.Combine(path1, path2, path3, path4);
Console.WriteLine(combinedPath);
Dim path1 As String = "d:\archives\"
Dim path2 As String = "2001"
Dim path3 As String = "media"
Dim path4 As String = "imaged"
Dim combinedPath As String = Path.Combine(path1, path2, path3, path4)
Console.WriteLine(combined)

Comentários

path1 deve ser um caminho absoluto (por exemplo, "d:\archives" ou " \ \archives\public").path1 should be an absolute path (for example, "d:\archives" or "\\archives\public"). Se um dos caminhos subsequentes for também um caminho absoluto, a operação combinar descartará todos os caminhos combinados anteriormente e redefinirá esse caminho absoluto.If one of the subsequent paths is also an absolute path, the combine operation discards all previously combined paths and resets to that absolute path.

As cadeias de caracteres de comprimento zero são omitidas do caminho combinado.Zero-length strings are omitted from the combined path.

Se path1 , path2 ou path3 não for uma referência de unidade (ou seja, "C:" ou "D:") e não terminar com um caractere separador válido, conforme definido em DirectorySeparatorChar , AltDirectorySeparatorChar ou VolumeSeparatorChar , DirectorySeparatorChar será anexado a ele antes da concatenação.If path1, path2, or path3 is not a drive reference (that is, "C:" or "D:") and does not end with a valid separator character as defined in DirectorySeparatorChar, AltDirectorySeparatorChar, or VolumeSeparatorChar, DirectorySeparatorChar is appended to it before concatenation. Observe que se path1 , path2 ou path3 terminar em um caractere separador de caminho que não seja apropriado para a plataforma de destino, o Combine método preservará o caractere separador de caminho original e acrescentará um com suporte.Note that if path1, path2, or path3 ends in a path separator character that is not appropriate for the target platform, the Combine method preserves the original path separator character and appends a supported one. O exemplo a seguir compara o resultado em sistemas baseados em Windows e UNIX quando a barra invertida é usada como um caractere separador de caminho.The following example compares the result on Windows and Unix-based systems when the backslash is used as a path separator character.

var result = Path.Combine(@"C:\Pictures\", @"Saved Pictures\", @"2019\", @"Jan\"); 
Console.WriteLine(result);
// The example displays the following output if run on a Windows system:
//    C:\Pictures\Saved Pictures\2019\Jan\
//
// The example displays the following output if run on a Unix-based system:
//    C:\Pictures\Saved Pictures\2019\Jan\      
Dim result = Path.Combine("C:\Pictures\", "Saved Pictures\", "2019\", "Jan\") 
Console.WriteLine(result)
' The example displays the following output if run on a Windows system:
'    C:\Pictures\Saved Pictures\2019\Jan\
'
' The example displays the following output if run on a Unix-based system:
'    C:\Pictures\Saved Pictures\2019\Jan\      

Se não path2 incluir uma raiz (por exemplo, se não path2 começar com um caractere separador ou uma especificação de unidade), o resultado será uma concatenação dos dois caminhos, com um caractere separador intermediário.If path2 does not include a root (for example, if path2 does not start with a separator character or a drive specification), the result is a concatenation of the two paths, with an intervening separator character. Se path2 incluir uma raiz, path2 será retornado.If path2 includes a root, path2 is returned.

Os parâmetros não serão analisados se tiverem espaço em branco.The parameters are not parsed if they have white space. Portanto, se path2 incluir espaço em branco (por exemplo, "\file.txt"), o Combine método acrescentará path2 a path1 .Therefore, if path2 includes white space (for example, " \file.txt "), the Combine method appends path2 to path1.

.NET Framework e versões do .NET Core anteriores a 2,1: nem todos os caracteres inválidos para nomes de diretório e arquivo são interpretados como inaceitáveis pelo Combine método, pois você pode usar esses caracteres para caracteres curinga de pesquisa..NET Framework and .NET Core versions older than 2.1: Not all invalid characters for directory and file names are interpreted as unacceptable by the Combine method, because you can use these characters for search wildcard characters. Por exemplo, embora Path.Combine("c:\\", "*.txt") possa ser inválido se você fosse criar um arquivo a partir dele, ele é válido como uma cadeia de caracteres de pesquisa.For example, while Path.Combine("c:\\", "*.txt") might be invalid if you were to create a file from it, it is valid as a search string. Portanto, ele é interpretado com êxito pelo Combine método.It is therefore successfully interpreted by the Combine method.

Aplica-se a