Path.Join Méthode

Définition

Espace de noms:

System.IO

Assembly:

System.Runtime.dll

Surcharges

Join(String, String, String, String)	Concatène quatre chemins dans un seul chemin.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatène quatre composants de chemin dans un seul chemin.
Join(String, String, String)	Concatène trois chemins dans un seul chemin.
Join(String[])	Concatène un tableau de chemins dans un seul chemin.
Join(String, String)	Concatène deux chemins dans un seul chemin.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatène deux composants de chemin d'accès en un seul chemin.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatène trois composants de chemin d'accès en un seul chemin.

Join(String, String, String, String)

Source:

Path.cs

Concatène quatre chemins dans un seul chemin.

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

Paramètres

path1

String

Premier chemin à joindre.

path2

String

Second chemin à joindre.

path3

String

Troisième chemin à joindre.

path4

String

Quatrième chemin à joindre.

Retours

String

Chemin concaténé.

Remarques

Cette méthode concatène pathsimplement , path2, path3 et path4 et ajoute un caractère séparateur de répertoire entre l’un des composants de chemin d’accès s’il n’en existe pas déjà un. Si la longueur de l’un des path1arguments , path2path3 ou path4 est égale à zéro, la méthode concatène les arguments restants. Si la longueur de la chaîne concaténée résultante est égale à zéro, la méthode retourne String.Empty.

Si path1 ou path2 se path3 termine par un caractère séparateur de chemin qui n’est pas approprié pour la plateforme cible, la Join méthode conserve le caractère séparateur de chemin d’accès d’origine et ajoute celui pris en charge. Ce problème se produit dans les chemins codés en dur qui utilisent la barre oblique inverse Windows (« \ »), qui n’est pas reconnu comme séparateur de chemin sur les systèmes Unix. Pour contourner ce problème, vous pouvez :

• Récupérez la valeur de la Path.DirectorySeparatorChar propriété au lieu de coder en dur un caractère séparateur de répertoire.

• Utilisez une barre oblique (« / ») comme caractère séparateur de répertoire. Ce caractère est retourné par la Path.DirectorySeparatorChar propriété sur les systèmes Unix et par la propriété sur les Path.AltDirectorySeparatorChar systèmes Windows.

Contrairement à la Combine méthode, la Join méthode ne tente pas d’rooter le chemin retourné. (Autrement dit, si path2 ou path3 est path4 un chemin absolu, la Join méthode n’ignore pas les chemins précédents comme le fait la Combine méthode.)

Tous les caractères non valides pour les noms de répertoires et de fichiers ne sont pas interprétés comme inacceptables par la Join méthode, car vous pouvez utiliser ces caractères pour la recherche de caractères génériques. Par exemple, bien qu’il Path.Join("c:\\", "temp", "*.txt") puisse être non valide lors de la création d’un fichier, il est valide en tant que chaîne de recherche. La Join méthode l’interprète donc correctement.

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

Source:

Path.cs

Concatène quatre composants de chemin dans un seul chemin.

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

Paramètres

path1

ReadOnlySpan<Char>

Étendue de caractères contenant le premier chemin d'accès à joindre.

path2

ReadOnlySpan<Char>

Étendue de caractères contenant le deuxième chemin d'accès à joindre.

path3

ReadOnlySpan<Char>

Étendue de caractères contenant le troisième chemin d'accès à joindre.

path4

ReadOnlySpan<Char>

Étendue de caractères contenant le quatrième chemin à joindre.

Retours

String

Chemin concaténé.

Remarques

Cette méthode concatène pathsimplement , path2, path3 et path4 et ajoute un caractère séparateur de répertoire entre l’un des composants de chemin d’accès s’il n’en existe pas déjà un. Si le Length de l’un des path1arguments , path2path3 ou path4 est égal à zéro, la méthode concatène les arguments restants. Si le ReadOnlySpan<T>.Length de tous les composants est égal à zéro, la méthode retourne String.Empty.

Si path1 ou path2 se path3 termine par un caractère séparateur de chemin qui n’est pas approprié pour la plateforme cible, la Join méthode conserve le caractère séparateur de chemin d’accès d’origine et ajoute celui pris en charge. Ce problème se produit dans les chemins codés en dur qui utilisent la barre oblique inverse Windows (« \ »), qui n’est pas reconnu comme séparateur de chemin sur les systèmes Unix. Pour contourner ce problème, vous pouvez :

• Récupérez la valeur de la Path.DirectorySeparatorChar propriété au lieu de coder en dur un caractère séparateur de répertoire.

• Utilisez une barre oblique (« / ») comme caractère séparateur de répertoire. Ce caractère est retourné par la Path.DirectorySeparatorChar propriété sur les systèmes Unix et par la propriété sur les Path.AltDirectorySeparatorChar systèmes Windows.

Contrairement à la Combine méthode, la Join méthode ne tente pas d’rooter le chemin retourné. (Autrement dit, si path2 ou path3 est path4 un chemin absolu, la Join méthode n’ignore pas les chemins précédents comme le fait la Combine méthode.)

Tous les caractères non valides pour les noms de répertoires et de fichiers ne sont pas interprétés comme inacceptables par la Join méthode, car vous pouvez utiliser ces caractères pour la recherche de caractères génériques. Par exemple, bien qu’il Path.Join("c:\\", "temp", "*.txt") puisse être non valide lors de la création d’un fichier, il est valide en tant que chaîne de recherche. La Join méthode l’interprète donc correctement.

Join(String, String, String)

Source:

Path.cs

Concatène trois chemins dans un seul chemin.

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

Paramètres

path1

String

Premier chemin à joindre.

path2

String

Second chemin à joindre.

path3

String

Troisième chemin à joindre.

Retours

String

Chemin concaténé.

Remarques

Cette méthode concatène pathsimplement , path2, et path3 et ajoute un caractère séparateur de répertoire entre l’un des composants de chemin d’accès s’il n’en existe pas déjà un. Si la longueur de l’un des path1arguments ou path2path3 est égale à zéro, la méthode concatène les arguments restants. Si la longueur de la chaîne concaténée résultante est égale à zéro, la méthode retourne String.Empty.

Si path1 ou path2 se termine par un caractère séparateur de chemin qui n’est pas approprié pour la plateforme cible, la Join méthode conserve le caractère séparateur de chemin d’accès d’origine et ajoute celui pris en charge. Ce problème se produit dans les chemins codés en dur qui utilisent la barre oblique inverse Windows (« \ »), qui n’est pas reconnu comme séparateur de chemin sur les systèmes Unix. Pour contourner ce problème, vous pouvez :

• Récupérez la valeur de la Path.DirectorySeparatorChar propriété au lieu de coder en dur un caractère séparateur de répertoire.

• Utilisez une barre oblique (« / ») comme caractère séparateur de répertoire. Ce caractère est retourné par la Path.DirectorySeparatorChar propriété sur les systèmes Unix et par la propriété sur les Path.AltDirectorySeparatorChar systèmes Windows.

Contrairement à la Combine méthode, la Join méthode ne tente pas d’rooter le chemin retourné. (Autrement dit, si path2 ou path3 est un chemin absolu, la Join méthode n’ignore pas les chemins précédents comme le fait la Combine méthode.)

Tous les caractères non valides pour les noms de répertoires et de fichiers ne sont pas interprétés comme inacceptables par la Join méthode, car vous pouvez utiliser ces caractères pour la recherche de caractères génériques. Par exemple, bien qu’il Path.Join("c:\\", "temp", "*.txt") puisse être non valide lors de la création d’un fichier, il est valide en tant que chaîne de recherche. La Join méthode l’interprète donc correctement.

Join(String[])

Source:

Path.cs

Concatène un tableau de chemins dans un seul chemin.

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

Paramètres

paths

String[]

Tableau de chemins.

Retours

String

Chemin concaténé.

Remarques

Cette méthode concatène simplement toutes les chaînes dans paths et ajoute un caractère séparateur de répertoire entre les composants de chemin d’accès s’ils ne sont pas déjà présents. Si le Length de l’un des chemins dans est égal à paths zéro, la méthode concatène les arguments restants. Si la longueur de la chaîne concaténée résultante est égale à zéro, la méthode retourne String.Empty.

Si l’un des chemins dans paths, à l’exception du dernier, se termine par un caractère séparateur de chemin qui n’est pas approprié pour la plateforme cible, la Join méthode conserve le caractère séparateur de chemin d’accès d’origine et ajoute celui pris en charge. Ce problème se produit dans les chemins codés en dur qui utilisent la barre oblique inverse Windows (« \ »), qui n’est pas reconnu comme séparateur de chemin sur les systèmes Unix. Pour contourner ce problème, vous pouvez :

• Récupérez la valeur de la Path.DirectorySeparatorChar propriété au lieu de coder en dur un caractère séparateur de répertoire.

• Utilisez une barre oblique (« / ») comme caractère séparateur de répertoire. Ce caractère est retourné par la Path.DirectorySeparatorChar propriété sur les systèmes Unix et par la propriété sur les Path.AltDirectorySeparatorChar systèmes Windows.

Contrairement à la Combine méthode, la Join méthode ne tente pas d’rooter le chemin retourné. (Autrement dit, si l’un des chemins dans paths, à l’exception du premier, est un chemin absolu, la Join méthode n’ignore pas les chemins précédents comme la Combine méthode.)

Tous les caractères non valides pour les noms de répertoires et de fichiers ne sont pas interprétés comme inacceptables par la Join méthode, car vous pouvez utiliser ces caractères pour la recherche de caractères génériques. Par exemple, bien qu’il Path.Join("c:\\", "temp", "*.txt") puisse être non valide lors de la création d’un fichier, il est valide en tant que chaîne de recherche. La Join méthode l’interprète donc correctement.

Join(String, String)

Source:

Path.cs

Concatène deux chemins dans un seul chemin.

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

Paramètres

path1

String

Premier chemin à joindre.

path2

String

Second chemin à joindre.

Retours

String

Chemin concaténé.

Remarques

Cette méthode concatène path simplement et path2 ajoute un caractère de séparation de répertoire entre les composants de chemin d’accès s’ils ne sont pas déjà présents. Si la longueur de path1 ou path2 est égale à zéro, la méthode concatène l’argument restant. Si la longueur de la chaîne concaténée résultante est égale à zéro, la méthode retourne String.Empty.

Si path1 se termine par un caractère séparateur de chemin qui n’est pas approprié pour la plateforme cible, la Join méthode conserve le caractère séparateur de chemin d’accès d’origine et ajoute celui pris en charge. Ce problème se produit dans les chemins codés en dur qui utilisent la barre oblique inverse Windows (« \ »), qui n’est pas reconnu comme séparateur de chemin sur les systèmes Unix. Pour contourner ce problème, vous pouvez :

• Récupérez la valeur de la Path.DirectorySeparatorChar propriété au lieu de coder en dur un caractère séparateur de répertoire.

• Utilisez une barre oblique (« / ») comme caractère de séparateur de répertoire. Ce caractère est retourné par la Path.DirectorySeparatorChar propriété sur les systèmes Unix et par la propriété sur les Path.AltDirectorySeparatorChar systèmes Windows.

Contrairement à la Combine méthode, la Join méthode ne tente pas de rooter le chemin retourné. (Autrement dit, si path2 est un chemin d’accès absolu, la Join méthode n’ignore pas les chemins d’accès précédents comme le fait la Combine méthode.)

Tous les caractères non valides pour les noms de répertoires et de fichiers ne sont pas interprétés comme inacceptables par la Join méthode, car vous pouvez utiliser ces caractères pour rechercher des caractères génériques. Par exemple, alors que Path.Join("c:\\", "temp", "*.txt") peut être non valide lors de la création d’un fichier, il est valide en tant que chaîne de recherche. La Join méthode l’interprète donc correctement.

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

Source:

Path.cs

Concatène deux composants de chemin d'accès en un seul chemin.

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

Paramètres

path1

ReadOnlySpan<Char>

Étendue de caractères contenant le premier chemin d'accès à joindre.

path2

ReadOnlySpan<Char>

Étendue de caractères contenant le deuxième chemin d'accès à joindre.

Retours

String

Chemins d'accès combinés.

Exemples

L’exemple suivant illustre la différence dans les chemins d’accès retournés par les Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) méthodes et Path.Combine(String, String) . Lorsque la première chaîne est un chemin d’accès complet qui comprend un lecteur et un répertoire racine et que la seconde est un chemin relatif du premier chemin, les deux méthodes produisent des résultats identiques. Dans les deuxième et troisième appels à la ShowPathInformation méthode, les chaînes retournées par les deux méthodes divergent. Dans le deuxième appel de méthode, le premier argument de chaîne est un lecteur, tandis que le second est un répertoire rooté. La Join méthode concatène les deux chaînes et conserve les séparateurs de chemin d’accès en double. La Combine méthode abandonne le lecteur et retourne un répertoire rooté sur le lecteur actif. Si le lecteur actuel de l’application est C:\ et la chaîne est utilisée pour accéder à un fichier ou à des fichiers dans le répertoire. Elle accède à C: au lieu de D:. Enfin, étant donné que les deux arguments du troisième appel à ShowPathInformation sont rootés, la Join méthode les ajoute simplement pour créer un chemin de fichier absurde, tandis que la Combine méthode ignore la première chaîne et retourne la deuxième. L’utilisation de cette chaîne pour l’accès aux fichiers peut donner à l’application un accès involontaire aux fichiers sensibles.

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

Remarques

Cette méthode concatène path simplement et path2 ajoute un caractère séparateur de répertoire entre les deux composants de chemin d’accès si l’un d’eux n’est pas déjà présent à la fin ou path1 au début de path2. Si le Length de path1 ou est égal à path2 zéro, la méthode retourne l’autre chemin. Si le Length de et path2 est égal à path1 zéro, la méthode retourne String.Empty.

Si path1 se termine par un caractère séparateur de chemin qui n’est pas approprié pour la plateforme cible, la Join méthode conserve le caractère de séparateur de chemin d’accès d’origine et ajoute celui pris en charge. Ce problème se produit dans les chemins codés en dur qui utilisent le caractère barre oblique inverse Windows (« \ »), qui n’est pas reconnu comme séparateur de chemin sur les systèmes Unix. Pour contourner ce problème, vous pouvez :

• Récupérez la valeur de la Path.DirectorySeparatorChar propriété plutôt que de coder en dur un caractère de séparateur de répertoire.

• Utilisez une barre oblique (« / ») comme caractère de séparateur de répertoire. Ce caractère est retourné par la Path.DirectorySeparatorChar propriété sur les systèmes Unix et par la propriété sur les Path.AltDirectorySeparatorChar systèmes Windows.

Contrairement à la Combine méthode, la Join méthode ne tente pas de rooter le chemin retourné. (Autrement dit, si path2 est un chemin d’accès absolu, la Join méthode n’ignore path1 pas et ne retourne path2 pas comme la Combine méthode.) L’exemple suivant illustre la différence entre les chemins d’accès retournés par les deux méthodes. Si la source de path2 est une entrée utilisateur, la Combine méthode permet à un utilisateur d’accéder à une ressource de système de fichiers (telle que C:/Users/User1/Documents/Financial/ dans l’exemple) que l’application n’avait pas l’intention de rendre accessible.

Tous les caractères non valides pour les noms de répertoires et de fichiers ne sont pas interprétés comme inacceptables par la Join méthode, car vous pouvez utiliser ces caractères pour rechercher des caractères génériques. Par exemple, alors que Path.Join("c:\\", "*.txt") peut être non valide lors de la création d’un fichier, il est valide en tant que chaîne de recherche. La Join méthode l’interprète donc correctement.

Voir aussi

• Formats de chemin de fichier sur les systèmes Windows

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

Source:

Path.cs

Concatène trois composants de chemin d'accès en un seul chemin.

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

Paramètres

path1

ReadOnlySpan<Char>

Étendue de caractères contenant le premier chemin d'accès à joindre.

path2

ReadOnlySpan<Char>

Étendue de caractères contenant le deuxième chemin d'accès à joindre.

path3

ReadOnlySpan<Char>

Étendue de caractères contenant le troisième chemin d'accès à joindre.

Retours

String

Chemin concaténé.

Exemples

L’exemple suivant illustre la différence dans les chemins d’accès retournés par les Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) méthodes et Path.Combine(String, String, String) . Lorsque la première chaîne est un chemin d’accès complet qui inclut un lecteur et un répertoire racine et que la deuxième est un chemin relatif du premier chemin, les deux méthodes produisent des résultats identiques. Dans les deuxième et troisième appels à la ShowPathInformation méthode, les chaînes retournées par les deux méthodes divergent. Dans le deuxième appel de méthode, le premier argument de chaîne est un lecteur, tandis que le second est un répertoire rooté. La Join méthode concatène les deux chaînes et conserve les séparateurs de chemin d’accès en double. Un appel à la GetFullPath méthode éliminerait la duplication. La Combine méthode abandonne le lecteur et retourne un répertoire rooté sur le lecteur actif. Si le lecteur actuel de l’application est C:\ et la chaîne est utilisée pour accéder à un fichier ou à des fichiers dans le répertoire. Elle accède à C: au lieu de D:. Enfin, étant donné que l’argument final du troisième appel à ShowPathInformation est rooté, la Join méthode l’ajoute simplement aux deux premiers arguments pour créer un chemin de fichier absurde, tandis que la Combine méthode ignore les deux premières chaînes et retourne le troisième. L’utilisation de cette chaîne pour l’accès aux fichiers peut donner à l’application un accès involontaire aux fichiers sensibles.

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'

Remarques

Cette méthode concatène pathsimplement , path2et path3 ajoute un caractère séparateur de répertoire entre les composants de chemin d’accès si l’un d’eux n’est pas déjà présent. Si le Length de l’un des path1arguments , path2ou path3 est égal à zéro, la méthode concatène les arguments restants. Si le ReadOnlySpan<T>.Length de tous les composants est égal à zéro, la méthode retourne String.Empty.

Si path1 ou path2 se termine par un caractère séparateur de chemin qui n’est pas approprié pour la plateforme cible, la Join méthode conserve le caractère de séparateur de chemin d’accès d’origine et ajoute celui pris en charge. Ce problème se produit dans les chemins codés en dur qui utilisent le caractère barre oblique inverse Windows (« \ »), qui n’est pas reconnu comme séparateur de chemin sur les systèmes Unix. Pour contourner ce problème, vous pouvez :

• Récupérez la valeur de la Path.DirectorySeparatorChar propriété plutôt que de coder en dur un caractère de séparateur de répertoire.

• Utilisez une barre oblique (« / ») comme caractère de séparateur de répertoire. Ce caractère est retourné par la Path.DirectorySeparatorChar propriété sur les systèmes Unix et par la propriété sur les Path.AltDirectorySeparatorChar systèmes Windows.

Contrairement à la Combine méthode, la Join méthode ne tente pas de rooter le chemin retourné. (Autrement dit, si path2 ou path3 est un chemin d’accès absolu, la Join méthode n’ignore pas les chemins d’accès précédents comme le fait la Combine méthode.)

Tous les caractères non valides pour les noms de répertoires et de fichiers ne sont pas interprétés comme inacceptables par la Join méthode, car vous pouvez utiliser ces caractères pour rechercher des caractères génériques. Par exemple, alors que Path.Join("c:\\", "temp", "*.txt") peut être non valide lors de la création d’un fichier, il est valide en tant que chaîne de recherche. La Join méthode l’interprète donc correctement.

Voir aussi

• Formats de chemin de fichier sur les systèmes Windows