Path.Combine Méthode

Définition

Combine des chaînes en un chemin d'accès.Combines strings into a path.

Surcharges

Combine(String[])

Combine un tableau de chaînes en un chemin d’accès.Combines an array of strings into a path.

Combine(String, String)

Combine deux chaînes en un chemin d’accès.Combines two strings into a path.

Combine(String, String, String)

Combine trois chaînes en un chemin d'accès.Combines three strings into a path.

Combine(String, String, String, String)

Combine quatre chaînes en un chemin d'accès.Combines four strings into a path.

Remarques

Cette méthode est conçue pour concaténer des chaînes individuelles dans une chaîne unique qui représente un chemin d’accès de fichier.This method is intended to concatenate individual strings into a single string that represents a file path. Toutefois, si un argument autre que le premier contient un chemin d’accès associé à une racine, les composants précédents du chemin d’accès sont ignorés et la chaîne retournée commence par ce composant de chemin d’accès avec racine.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. En guise d’alternative à la méthode Combine, envisagez d’utiliser les méthodes Join ou TryJoin.As an alternative to the Combine method, consider using the Join or TryJoin methods.

Important

Cette méthode suppose que le premier argument est un chemin d’accès absolu et que l’argument ou les arguments suivants sont des chemins d’accès relatifs.This method assumes that the first argument is an absolute path and that the following argument or arguments are relative paths. Si ce n’est pas le cas, et en particulier si les arguments suivants sont des chaînes entrées par l’utilisateur, appelez plutôt la méthode Join ou TryJoin.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[])

Combine un tableau de chaînes en un chemin d’accès.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

Paramètres

paths
String[]

Tableau de parties du chemin d’accès.An array of parts of the path.

Retours

Chemins d'accès combinés.The combined paths.

Exceptions

L’une des chaînes du tableau contient un ou plusieurs des caractères non valides définis dans GetInvalidPathChars().One of the strings in the array contains one or more of the invalid characters defined in GetInvalidPathChars().

L’une des chaînes du tableau est null.One of the strings in the array is null.

Exemples

L’exemple suivant combine un tableau de chaînes en un chemin d’accès.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)

Remarques

paths doit être un tableau des parties du chemin d’accès à combiner.paths should be an array of the parts of the path to combine. Si l’un des chemins d’accès suivants est un chemin d’accès absolu, l’opération combine réinitialise en commençant par ce chemin d’accès absolu, en ignorant tous les chemins d’accès combinés précédents.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.

Si un élément de paths mais le dernier n’est pas un lecteur et ne se termine pas par l' DirectorySeparatorChar ou le caractère AltDirectorySeparatorChar, la méthode Combine ajoute un caractère DirectorySeparatorChar entre cet élément et le suivant.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. Notez que, si l’élément se termine par un caractère de séparation de chemin d’accès qui n’est pas approprié pour la plateforme cible, la méthode Combine conserve le caractère de séparation du chemin d’accès d’origine et ajoute une prise en charge.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. L’exemple suivant compare le résultat sur les systèmes Windows et UNIX lorsque la barre oblique inverse est utilisée comme séparateur de chemin d’accès.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    

Les chaînes de longueur nulle sont omises du chemin combiné.Zero-length strings are omitted from the combined path.

Les paramètres ne sont pas analysés s’ils comportent un espace blanc.The parameters are not parsed if they have white space.

Les caractères non valides pour les noms de répertoires et de fichiers ne sont pas tous interprétés comme étant inacceptables par la méthode Combine, car vous pouvez utiliser ces caractères pour rechercher des caractères génériques.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. Par exemple, bien que Path.Combine("c:\\", "*.txt") ne soit pas valide si vous deviez créer un fichier à partir de celui-ci, il s’agit d’une chaîne de recherche valide.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. Elle est donc interprétée correctement par la méthode Combine.It is therefore successfully interpreted by the Combine method.

Voir aussi

Combine(String, String)

Combine deux chaînes en un chemin d’accès.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

Paramètres

path1
String

Premier chemin d'accès à combiner.The first path to combine.

path2
String

Deuxième chemin d'accès à combiner.The second path to combine.

Retours

Chemins d'accès combinés.The combined paths. Si un des chemins d'accès spécifiés est une chaîne de longueur zéro, cette méthode retourne l'autre chemin d'accès.If one of the specified paths is a zero-length string, this method returns the other path. Si path2 contient un chemin d’accès absolu, cette méthode retourne path2.If path2 contains an absolute path, this method returns path2.

Exceptions

path1 ou path2 contient un ou plusieurs caractères non valides définis dans GetInvalidPathChars().path1 or path2 contains one or more of the invalid characters defined in GetInvalidPathChars().

path1 ou path2 est null.path1 or path2 is null.

Exemples

L’exemple suivant illustre l’utilisation de la méthode Combine sur une plateforme de bureau 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 '' 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

Remarques

Si path1 n’est pas une référence de lecteur (autrement dit, « C : » ou « D : ») et qu’elle ne se termine pas par un caractère de séparation valide tel que défini dans DirectorySeparatorChar, AltDirectorySeparatorCharou VolumeSeparatorChar, DirectorySeparatorChar est ajouté à path1 avant la concaténation.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. Notez que si path1 se termine par un caractère de séparation de chemin d’accès qui n’est pas approprié pour la plateforme cible, la méthode Combine conserve le caractère de séparation du chemin d’origine et ajoute une prise en charge.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. L’exemple suivant compare le résultat sur les systèmes Windows et UNIX lorsque la barre oblique inverse est utilisée comme séparateur de chemin d’accès.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        

Si path2 n’inclut pas de racine (par exemple, si path2 ne commence pas par un caractère de séparation ou une spécification de lecteur), le résultat est une concaténation des deux chemins d’accès, avec un caractère de séparation intermédiaire.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. Si path2 contient une racine, path2 est retourné.If path2 includes a root, path2 is returned.

Les paramètres ne sont pas analysés s’ils comportent un espace blanc.The parameters are not parsed if they have white space. Par conséquent, si path2 comprend un espace blanc (par exemple, « \File.txt »), la méthode Combine ajoute path2 à path1 au lieu de retourner uniquement path2.Therefore, if path2 includes white space (for example, " \file.txt "), the Combine method appends path2 to path1 instead of returning only path2.

Les caractères non valides pour les noms de répertoires et de fichiers ne sont pas tous interprétés comme étant inacceptables par la méthode Combine, car vous pouvez utiliser ces caractères pour rechercher des caractères génériques.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. Par exemple, bien que Path.Combine("c:\\", "*.txt") ne soit pas valide si vous deviez créer un fichier à partir de celui-ci, il s’agit d’une chaîne de recherche valide.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. Elle est donc interprétée correctement par la méthode Combine.It is therefore successfully interpreted by the Combine method.

Pour obtenir la liste des tâches d’e/s courantes, consultez tâches d’e/s courantes.For a list of common I/O tasks, see Common I/O Tasks.

Voir aussi

Combine(String, String, String)

Combine trois chaînes en un chemin d'accès.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

Paramètres

path1
String

Premier chemin d'accès à combiner.The first path to combine.

path2
String

Deuxième chemin d'accès à combiner.The second path to combine.

path3
String

Troisième chemin d'accès à combiner.The third path to combine.

Retours

Chemins d'accès combinés.The combined paths.

Exceptions

path1, path2 ou path3 contient un ou plusieurs caractères non valides définis dans GetInvalidPathChars().path1, path2, or path3 contains one or more of the invalid characters defined in GetInvalidPathChars().

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

Exemples

L’exemple suivant combine trois chemins d’accès.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)

Remarques

path1 doit être un chemin d’accès absolu (par exemple, « d:\archives » ou «\\archives\public »).path1 should be an absolute path (for example, "d:\archives" or "\\archives\public"). Si path2 ou path3 est également un chemin d’accès absolu, l’opération de combinaison ignore tous les chemins d’accès précédemment combinés et réinitialise ce chemin d’accès absolu.If path2 or path3 is also an absolute path, the combine operation discards all previously combined paths and resets to that absolute path.

Les chaînes de longueur nulle sont omises du chemin combiné.Zero-length strings are omitted from the combined path.

Si path1 ou path2 n’est pas une référence de lecteur (autrement dit, « C : » ou « D : ») et qu’il ne se termine pas par un caractère de séparation valide tel que défini dans DirectorySeparatorChar, AltDirectorySeparatorCharou VolumeSeparatorChar, DirectorySeparatorChar est ajouté à path1 ou path2 avant la concaténation.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. Notez que si path1 ou path2 se termine par un caractère de séparation de chemin d’accès qui n’est pas approprié pour la plateforme cible, la méthode Combine conserve le caractère de séparation du chemin d’accès d’origine et ajoute une prise en charge.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. L’exemple suivant compare le résultat sur les systèmes Windows et UNIX lorsque la barre oblique inverse est utilisée comme séparateur de chemin d’accès.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      

Si path2 n’inclut pas de racine (par exemple, si path2 ne commence pas par un caractère de séparation ou une spécification de lecteur), le résultat est une concaténation des deux chemins d’accès, avec un caractère de séparation intermédiaire.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. Si path2 contient une racine, path2 est retourné.If path2 includes a root, path2 is returned.

Les paramètres ne sont pas analysés s’ils comportent un espace blanc.The parameters are not parsed if they have white space. Par conséquent, si path2 comprend un espace blanc (par exemple, « \File.txt »), la méthode Combine ajoute path2 à path1.Therefore, if path2 includes white space (for example, " \file.txt "), the Combine method appends path2 to path1.

Les caractères non valides pour les noms de répertoires et de fichiers ne sont pas tous interprétés comme étant inacceptables par la méthode Combine, car vous pouvez utiliser ces caractères pour rechercher des caractères génériques.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. Par exemple, bien que Path.Combine("c:\\", "*.txt") ne soit pas valide si vous deviez créer un fichier à partir de celui-ci, il s’agit d’une chaîne de recherche valide.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. Elle est donc interprétée correctement par la méthode Combine.It is therefore successfully interpreted by the Combine method.

Voir aussi

Combine(String, String, String, String)

Combine quatre chaînes en un chemin d'accès.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

Paramètres

path1
String

Premier chemin d'accès à combiner.The first path to combine.

path2
String

Deuxième chemin d'accès à combiner.The second path to combine.

path3
String

Troisième chemin d'accès à combiner.The third path to combine.

path4
String

Quatrième chemin d'accès à combiner.The fourth path to combine.

Retours

Chemins d'accès combinés.The combined paths.

Exceptions

path1, path2, path3 ou path4 contient un ou plusieurs caractères non valides définis dans GetInvalidPathChars().path1, path2, path3, or path4 contains one or more of the invalid characters defined in GetInvalidPathChars().

path1, path2, path3 ou path4 a la valeur null.path1, path2, path3, or path4 is null.

Exemples

L’exemple suivant combine quatre chemins d’accès.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)

Remarques

path1 doit être un chemin d’accès absolu (par exemple, « d:\archives » ou «\\archives\public »). Si l’un des chemins d’accès suivants est également un chemin d’accès absolu, l’opération de combinaison ignore tous les chemins d’accès précédemment combinés et réinitialise ce chemin d’accès absolu.path1 should be an absolute path (for example, "d:\archives" or "\\archives\public").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.

Les chaînes de longueur nulle sont omises du chemin combiné.Zero-length strings are omitted from the combined path.

Si path1, path2ou path3 n’est pas une référence de lecteur (autrement dit, « C : » ou « D : ») et qu’il ne se termine pas par un caractère de séparation valide tel qu’il est défini dans DirectorySeparatorChar, AltDirectorySeparatorCharou VolumeSeparatorChar, DirectorySeparatorChar y est ajouté avant la concaténation.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. Notez que si path1, path2ou path3 se termine par un caractère de séparation de chemin d’accès qui n’est pas approprié pour la plateforme cible, la méthode Combine conserve le caractère de séparation du chemin d’accès d’origine et ajoute un caractère pris en charge.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. L’exemple suivant compare le résultat sur les systèmes Windows et UNIX lorsque la barre oblique inverse est utilisée comme séparateur de chemin d’accès.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\      

Si path2 n’inclut pas de racine (par exemple, si path2 ne commence pas par un caractère de séparation ou une spécification de lecteur), le résultat est une concaténation des deux chemins d’accès, avec un caractère de séparation intermédiaire.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. Si path2 contient une racine, path2 est retourné.If path2 includes a root, path2 is returned.

Les paramètres ne sont pas analysés s’ils comportent un espace blanc.The parameters are not parsed if they have white space. Par conséquent, si path2 comprend un espace blanc (par exemple, « \File.txt »), la méthode Combine ajoute path2 à path1.Therefore, if path2 includes white space (for example, " \file.txt "), the Combine method appends path2 to path1.

Les caractères non valides pour les noms de répertoires et de fichiers ne sont pas tous interprétés comme étant inacceptables par la méthode Combine, car vous pouvez utiliser ces caractères pour rechercher des caractères génériques.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. Par exemple, bien que Path.Combine("c:\\", "*.txt") ne soit pas valide si vous deviez créer un fichier à partir de celui-ci, il s’agit d’une chaîne de recherche valide.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. Elle est donc interprétée correctement par la méthode Combine.It is therefore successfully interpreted by the Combine method.

Voir aussi

S’applique à