Path.Combine Método

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

Retornos

String

Os caminhos combinados.The combined paths.

Exceções

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.

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

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

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.

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

Retornos

String

Os caminhos combinados.The combined paths.

Exceções

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.

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

Retornos

String

Os caminhos combinados.The combined paths.

Exceções

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.