Path.Join Méthode
Définition
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
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(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) |
Concatène trois composants de chemin d'accès en un seul chemin. |
Join(ReadOnlySpan<String>) | |
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) |
Concatène deux composants de chemin d'accès en 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(String, String, String, String)
- Source:
- Path.cs
- Source:
- Path.cs
- 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
Chemin concaténé.
Remarques
Cette méthode concatène path
simplement , path2
path3
et path4
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 la longueur de l’un des path1
arguments , path2
path3
ou est path4
é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 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
path4
est un chemin 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.
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 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
Chemin concaténé.
Remarques
Cette méthode concatène path
simplement , path2
path3
et path4
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 path1
arguments , path2
path3
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 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
path4
est un chemin 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.
S’applique à
Join(String, String, String)
- Source:
- Path.cs
- Source:
- Path.cs
- 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
Chemin concaténé.
Remarques
Cette méthode concatène path
simplement , path2
et 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 la longueur de l’un des path1
arguments ou path2
path3
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 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.
S’applique à
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)
- Source:
- Path.cs
- Source:
- Path.cs
- 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
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 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 à 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 path
simplement , path2
et 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 path1
arguments , path2
ou 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
S’applique à
Join(ReadOnlySpan<String>)
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>
Retours
S’applique à
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)
- Source:
- Path.cs
- Source:
- Path.cs
- 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
Chemins d'accès combinés.
Exemples
L’exemple suivant illustre la différence entre 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 inclut 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 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, il 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 path2
est égal à zéro, la méthode retourne l’autre chemin. Si le Length de path1
et path2
est égal à 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 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
est un chemin absolu, la Join
méthode ne l’ignore path1
pas et ne retourne path2
pas comme la Combine méthode.) L’exemple suivant illustre la différence entre les chemins 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 la recherche de caractères génériques. Par exemple, bien qu’il Path.Join("c:\\", "*.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.
Voir aussi
S’applique à
Join(String[])
- Source:
- Path.cs
- Source:
- Path.cs
- 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
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.
S’applique à
Join(String, String)
- Source:
- Path.cs
- Source:
- Path.cs
- 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
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 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
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.
S’applique à
Commentaires
https://aka.ms/ContentUserFeedback.
Bientôt disponible : Tout au long de l’année 2024, nous abandonnerons progressivement le mécanisme de retour d’information GitHub Issues pour le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez :Soumettre et afficher des commentaires pour