Path.Join Méthode

Définition

Espace de noms:: System.IO

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Surcharges

Nom	Description
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatène deux composants de chemin en un seul chemin.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatène trois composants de chemin en un seul chemin.

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

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 et Path.Combine(String, String) les Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) méthodes. 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 ShowPathInformation méthode, 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 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 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 sont ShowPathInformation rootés, la Join méthode les ajoute simplement pour créer un chemin d’accès de fichier nonsensique, 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 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 path et path2 ajoute simplement 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 ou path1 au début de path2. Si l’un Length ou l’autre path1 est égal à path2 zéro, la méthode retourne l’autre chemin d’accès. Si la Length valeur des deux path1 et est égale à path2 zéro, la méthode retourne String.Empty.

Si path1 se termine par un caractère de séparateur de chemin d’accès 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 Windows barre oblique inverse (« \ »), 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 :

Récupérez la valeur de la Path.DirectorySeparatorChar propriété plutôt que de coder en dur un caractère de séparation de répertoire.
Utilisez une barre oblique (« / ») comme caractère de séparateur de répertoire. Ce caractère est retourné par la propriété Path.DirectorySeparatorChar sur les systèmes Unix et par la propriété Path.AltDirectorySeparatorChar sur les systèmes Windows.

Contrairement à la Combine méthode, la Join méthode ne tente pas de raciner le chemin retourné. (Autrement dit, s’il path2 s’agit d’un chemin absolu, la Join méthode n’ignore path1 pas et ne retourne path2 pas comme la Combine méthode le fait.) L’exemple suivant illustre la différence dans les chemins retournés par les deux méthodes. Si la source d’entrée path2 utilisateur est une entrée, la Combine méthode 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 fichier 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, bien qu’il 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 Join méthode l’interprète donc correctement.

Voir aussi

formats de chemin d’accès Fichier sur les systèmes Windows

S’applique à

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

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 et Path.Combine(String, String, String) les Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) méthodes. 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 ShowPathInformation méthode, 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 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 élimine la duplication. La Combine méthode 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 du troisième appel est ShowPathInformation rooté, la Join méthode l’ajoute simplement aux deux premiers arguments pour créer un chemin d’accès de fichier nonsensique, 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 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 pathsimplement , path2et path3 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 l’un Length des path1arguments ou path3path2des arguments est égal à zéro, la méthode concatène les arguments restants. Si l’ensemble ReadOnlySpan<T>.Length des composants est égal à zéro, la méthode retourne String.Empty.

Si path1 ou path2 se termine par un caractère de séparateur de chemin d’accès 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 le caractère pris en charge. Ce problème se produit dans les chemins codés en dur qui utilisent le caractère Windows barre oblique inverse (« \ »), 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 :

Récupérez la valeur de la Path.DirectorySeparatorChar propriété plutôt que de coder en dur un caractère de séparation de répertoire.
Utilisez une barre oblique (« / ») comme caractère de séparateur de répertoire. Ce caractère est retourné par la propriété Path.DirectorySeparatorChar sur les systèmes Unix et par la propriété Path.AltDirectorySeparatorChar sur les systèmes Windows.

Contrairement à la Combine méthode, la Join méthode ne tente pas de raciner le chemin retourné. (Autrement dit, s’il s’agit path2 d’un path3 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épertoire et de fichier 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, bien qu’il 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 Join méthode l’interprète donc correctement.

Voir aussi

formats de chemin d’accès Fichier sur les systèmes Windows

S’applique à

Commentaires

Cette page a-t-elle été utile ?