Partager via

Path.Join Méthode

  • Référence

Définition

Espace de noms:
System.IO
Assembly:
System.Runtime.dll
Assembly:
System.Runtime.Extensions.dll
Assembly:
netstandard.dll

Surcharges

Join(String, String, String, String)

Concatène quatre chemins en un seul chemin.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatène quatre composants de chemin en un seul chemin.
Join(String, String, String)

Concatène trois chemins en un seul chemin.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatène trois composants de chemin en un seul chemin.
Join(ReadOnlySpan<String>)

Concatène une étendue de chemins en un seul chemin.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatène deux composants de chemin en un seul chemin.
Join(String[])

Concatène un tableau de chemins en un seul chemin.
Join(String, String)

Concatène deux chemins en un seul chemin.

Join(String, String, String, String)

Source:
Path.cs
Source:
Path.cs
Source:
Path.cs

Concatène quatre chemins en 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 d’accès à joindre.

path2
String

Deuxième chemin d’accès à joindre.

path3
String

Troisième chemin d’accès à joindre.

path4
String

Quatrième chemin d’accès à joindre.

Retours

String

Chemin concaténé.

Remarques

Cette méthode concatène simplement path, path2, path3 et path4 et ajoute un caractère de séparation de répertoire entre l’un des composants de chemin d’accès s’il n’est pas déjà présent. Si la longueur d’une path1, path2, path3 ou path4 argument 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 ou path3 se termine par un caractère de séparateur de chemin qui n’est pas approprié pour la plateforme cible, la méthode Join conserve le caractère de séparateur de chemin d’origine et ajoute le caractère pris en charge. Ce problème se produit dans les chemins codés en dur qui utilisent la barre oblique inverse Windows (« \ ») caractère, qui n’est pas reconnu comme séparateur de chemin d’accès sur les systèmes Unix. Pour contourner ce problème, vous pouvez :

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

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

S’applique à

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

Source:
Path.cs
Source:
Path.cs
Source:
Path.cs

Concatène quatre composants de chemin en 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 qui contient le premier chemin d’accès à joindre.

path2
ReadOnlySpan<Char>

Étendue de caractères qui contient le deuxième chemin d’accès à joindre.

path3
ReadOnlySpan<Char>

Étendue de caractères qui contient le troisième chemin d’accès à joindre.

path4
ReadOnlySpan<Char>

Étendue de caractères qui contient le quatrième chemin d’accès à joindre.

Retours

String

Chemin concaténé.

Remarques

Cette méthode concatène simplement path, path2, path3 et path4 et ajoute un caractère de séparation de répertoire entre l’un des composants de chemin d’accès s’il n’est pas déjà présent. Si la Length de l’un des path1, path2, path3 ou path4 argument est zéro, la méthode concatène les arguments restants. Si la ReadOnlySpan<T>.Length de tous les composants est égale à zéro, la méthode retourne String.Empty.

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

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

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

S’applique à

Join(String, String, String)

Source:
Path.cs
Source:
Path.cs
Source:
Path.cs

Concatène trois chemins en 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 d’accès à joindre.

path2
String

Deuxième chemin d’accès à joindre.

path3
String

Troisième chemin d’accès à joindre.

Retours

String

Chemin concaténé.

Remarques

Cette méthode concatène simplement path, path2et path3 et ajoute un caractère de séparation de répertoire entre l’un des composants du chemin d’accès s’il n’en est pas déjà présent. Si la longueur d’une path1, path2 ou path3 argument 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 de séparateur de chemin qui n’est pas approprié pour la plateforme cible, la méthode Join conserve le caractère de séparateur de chemin d’origine et ajoute le caractère pris en charge. Ce problème se produit dans les chemins codés en dur qui utilisent la barre oblique inverse Windows (« \ ») caractère, qui n’est pas reconnu comme séparateur de chemin d’accès sur les systèmes Unix. Pour contourner ce problème, vous pouvez :

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

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

S’applique à

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

Source:
Path.cs
Source:
Path.cs
Source:
Path.cs

Concatène trois composants de chemin 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 qui contient le premier chemin d’accès à joindre.

path2
ReadOnlySpan<Char>

Étendue de caractères qui contient le deuxième chemin d’accès à joindre.

path3
ReadOnlySpan<Char>

Étendue de caractères qui contient le troisième chemin d’accès à joindre.

Retours

String

Chemin concaténé.

Exemples

L’exemple suivant illustre la différence dans les chemins retournés par les méthodes Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) et Path.Combine(String, String, String). Lorsque la première chaîne est un chemin complet qui inclut un lecteur et un répertoire racine et que le second est un chemin relatif à partir du premier chemin, les deux méthodes produisent des résultats identiques. Dans les deuxième et troisième appels à la méthode ShowPathInformation, les chaînes retournées par les deux méthodes diffèrent. 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 méthode Join concatène les deux chaînes et conserve les séparateurs de chemins en double. Un appel à la méthode GetFullPath éliminerait la duplication. La méthode Combine abandonne le lecteur et retourne un répertoire rooté sur le lecteur actuel. Si le lecteur actuel de l’application est C :\ et que 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 dans le troisième appel à ShowPathInformation est rooté, la méthode Join l’ajoute simplement aux deux premiers arguments pour créer un chemin d’accès de fichier nonsensique, tandis que la méthode Combine 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 inattendu 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 simplement path, path2et path3 et ajoute un caractère de séparation de répertoire entre l’un des composants du chemin d’accès s’il n’en est pas déjà présent. Si la Length de l’un des arguments path1, path2ou path3 est égale à zéro, la méthode concatène les arguments restants. Si la ReadOnlySpan<T>.Length de tous les composants est égale à zéro, la méthode retourne String.Empty.

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

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

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

Voir aussi

S’applique à

Join(ReadOnlySpan<String>)

Concatène une étendue de chemins en un seul chemin.

public:
 static System::String ^ Join(ReadOnlySpan<System::String ^> paths);
public static string Join (scoped ReadOnlySpan<string?> paths);
static member Join : ReadOnlySpan<string> -> string
Public Shared Function Join (paths As ReadOnlySpan(Of String)) As String

Paramètres

paths
ReadOnlySpan<String>

Étendue de chemins d’accès.

Retours

String

Chemin concaténé.

S’applique à

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

Source:
Path.cs
Source:
Path.cs
Source:
Path.cs

Concatène deux composants de chemin 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 qui contient le premier chemin d’accès à joindre.

path2
ReadOnlySpan<Char>

Étendue de caractères qui contient le deuxième chemin d’accès à joindre.

Retours

String

Chemins combinés.

Exemples

L’exemple suivant illustre la différence dans les chemins retournés par les méthodes Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) et Path.Combine(String, String). Lorsque la première chaîne est un chemin complet qui inclut un lecteur et un répertoire racine et que le second 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 méthode ShowPathInformation, les chaînes retournées par les deux méthodes diffèrent. 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 méthode Join concatène les deux chaînes et conserve les séparateurs de chemins en double. La méthode Combine abandonne le lecteur et retourne un répertoire rooté sur le lecteur actuel. Si le lecteur actuel de l’application est C :\ et que 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 méthode Join les ajoute simplement pour créer un chemin d’accès de fichier nonsensique, tandis que la méthode Combine ignore la première chaîne et retourne la seconde. L’utilisation de cette chaîne pour l’accès aux fichiers peut donner à l’application un accès inattendu 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 simplement path et path2 et ajoute un caractère de séparation de répertoire entre les deux composants de chemin d’accès si l’un n’est pas déjà présent à la fin de path1 ou au début de path2. Si la Length de path1 ou de path2 est égale à zéro, la méthode retourne l’autre chemin. Si la Length des deux path1 et path2 est égale à zéro, la méthode retourne String.Empty.

Si path1 se termine par un caractère de séparateur de chemin qui n’est pas approprié pour la plateforme cible, la méthode Join 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 la barre oblique inverse Windows (« \ ») caractère, qui n’est pas reconnu comme séparateur de chemin d’accès sur les systèmes Unix. Pour contourner ce problème, vous pouvez :

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

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

Voir aussi

S’applique à

Join(String[])

Source:
Path.cs
Source:
Path.cs
Source:
Path.cs

Concatène un tableau de chemins en 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 d’accès.

Retours

String

Chemin concaténé.

Remarques

Cette méthode concatène simplement toutes les chaînes dans paths et ajoute un caractère de séparation de répertoire entre l’un des composants de chemin d’accès s’il n’en existe pas déjà un. Si la Length de l’un des chemins d’accès dans paths 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 l’un des chemins d’accès dans paths, à l’exception du dernier, se termine par un caractère de séparateur de chemin qui n’est pas approprié pour la plateforme cible, la méthode Join conserve le caractère de séparateur de chemin d’origine et ajoute le caractère pris en charge. Ce problème se produit dans les chemins codés en dur qui utilisent la barre oblique inverse Windows (« \ ») caractère, qui n’est pas reconnu comme séparateur de chemin d’accès sur les systèmes Unix. Pour contourner ce problème, vous pouvez :

Contrairement à la méthode Combine, la méthode Join n’essaie pas de raciner le chemin retourné. (Autrement dit, si l’un des chemins d’accès dans paths, à l’exception du premier, est un chemin absolu, la méthode Join n’ignore pas les chemins précédents comme la méthode Combine le fait.)

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

S’applique à

Join(String, String)

Source:
Path.cs
Source:
Path.cs
Source:
Path.cs

Concatène deux chemins en 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 d’accès à joindre.

path2
String

Deuxième chemin d’accès à joindre.

Retours

String

Chemin concaténé.

Remarques

Cette méthode concatène simplement path et path2 et ajoute un caractère de séparation de répertoire entre les composants du chemin d’accès s’il n’en existe pas déjà un. 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 de séparateur de chemin qui n’est pas approprié pour la plateforme cible, la méthode Join 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 la barre oblique inverse Windows (« \ ») caractère, qui n’est pas reconnu comme séparateur de chemin d’accès sur les systèmes Unix. Pour contourner ce problème, vous pouvez :

Contrairement à la méthode Combine, la méthode Join n’essaie pas de raciner le chemin retourné. (Autrement dit, si path2 est un chemin absolu, la méthode Join n’ignore pas les chemins précédents, car la méthode Combine le fait.)

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

S’applique à