Path.Join Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Overload
Join(String, String, String, String) |
Concatena quattro percorsi in un unico percorso. |
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) |
Concatena quattro componenti del percorso in un unico percorso. |
Join(String, String, String) |
Concatena tre percorsi in un unico percorso. |
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) |
Concatena tre componenti del percorso in un unico percorso. |
Join(ReadOnlySpan<String>) | |
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) |
Concatena due componenti del percorso in un unico percorso. |
Join(String[]) |
Concatena una matrice di percorsi in un unico percorso. |
Join(String, String) |
Concatena due percorsi in un unico percorso. |
Join(String, String, String, String)
- Origine:
- Path.cs
- Origine:
- Path.cs
- Origine:
- Path.cs
Concatena quattro percorsi in un unico percorso.
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
Parametri
- path1
- String
Primo percorso da aggiungere.
- path2
- String
Secondo percorso da aggiungere.
- path3
- String
Terzo percorso da aggiungere.
- path4
- String
Quarto percorso da aggiungere.
Restituisce
Percorso concatenato.
Commenti
Questo metodo consente semplicemente di concatenare path
, path2
path3
e path4
e aggiunge un carattere di separatore di directory tra uno dei componenti del percorso, se non ne è già presente uno. Se la lunghezza di uno qualsiasi di path1
, path3
path2
o path4
argomento è zero, il metodo concatena gli argomenti rimanenti. Se la lunghezza della stringa concatenata risultante è zero, il metodo restituisce String.Empty.
Se path1
o path2
path3
termina in un carattere separatore di percorso non appropriato per la piattaforma di destinazione, il Join
metodo mantiene il carattere separatore di percorso originale e aggiunge quello supportato. Questo problema si verifica in percorsi hardcoded che usano il carattere barra rovesciata di Windows ("\"), che non viene riconosciuto come separatore di percorso nei sistemi basati su Unix. Per risolvere questo problema, è possibile:
Recuperare il valore della Path.DirectorySeparatorChar proprietà anziché impostare come hardcoded un carattere separatore di directory.
Usare una barra ("/") come carattere separatore di directory. Questo carattere viene restituito dalla Path.DirectorySeparatorChar proprietà nei sistemi basati su Unix e dalla Path.AltDirectorySeparatorChar proprietà nei sistemi Windows.
A differenza del Combine metodo , il Join metodo non tenta di radicere il percorso restituito. Ovvero, se path2
o path3
path4
è un percorso assoluto, il Join
metodo non rimuove i percorsi precedenti come fa il Combine metodo.
Non tutti i caratteri non validi per i nomi di directory e file vengono interpretati come inaccettabili dal Join
metodo , perché è possibile usare questi caratteri per la ricerca di caratteri jolly. Ad esempio, anche se Path.Join("c:\\", "temp", "*.txt")
potrebbe non essere valido durante la creazione di un file, è valido come stringa di ricerca. Il Join
metodo lo interpreta correttamente.
Si applica a
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)
- Origine:
- Path.cs
- Origine:
- Path.cs
- Origine:
- Path.cs
Concatena quattro componenti del percorso in un unico percorso.
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
Parametri
- path1
- ReadOnlySpan<Char>
Intervallo di caratteri che contiene il primo percorso da aggiungere.
- path2
- ReadOnlySpan<Char>
Intervallo di caratteri che contiene il secondo percorso da aggiungere.
- path3
- ReadOnlySpan<Char>
Intervallo di caratteri che contiene il terzo percorso da aggiungere.
- path4
- ReadOnlySpan<Char>
Intervallo di caratteri che contiene il quarto percorso da aggiungere.
Restituisce
Percorso concatenato.
Commenti
Questo metodo consente semplicemente di concatenare path
, path2
path3
e path4
e aggiunge un carattere di separatore di directory tra uno dei componenti del percorso, se non ne è già presente uno. Se l'oggetto Length di uno qualsiasi di path1
, path2
path3
o path4
è zero, il metodo concatena gli argomenti rimanenti. Se l'oggetto ReadOnlySpan<T>.Length di tutti i componenti è zero, il metodo restituisce String.Empty.
Se path1
o path2
path3
termina in un carattere separatore di percorso non appropriato per la piattaforma di destinazione, il Join
metodo mantiene il carattere separatore di percorso originale e aggiunge quello supportato. Questo problema si verifica in percorsi hardcoded che usano il carattere barra rovesciata di Windows ("\"), che non viene riconosciuto come separatore di percorso nei sistemi basati su Unix. Per risolvere questo problema, è possibile:
Recuperare il valore della Path.DirectorySeparatorChar proprietà anziché impostare come hardcoded un carattere separatore di directory.
Usare una barra ("/") come carattere separatore di directory. Questo carattere viene restituito dalla Path.DirectorySeparatorChar proprietà nei sistemi basati su Unix e dalla Path.AltDirectorySeparatorChar proprietà nei sistemi Windows.
A differenza del Combine metodo , il Join metodo non tenta di radicere il percorso restituito. Ovvero, se path2
o path3
path4
è un percorso assoluto, il Join
metodo non rimuove i percorsi precedenti come fa il Combine metodo.
Non tutti i caratteri non validi per i nomi di directory e file vengono interpretati come inaccettabili dal Join
metodo , perché è possibile usare questi caratteri per la ricerca di caratteri jolly. Ad esempio, anche se Path.Join("c:\\", "temp", "*.txt")
potrebbe non essere valido durante la creazione di un file, è valido come stringa di ricerca. Il Join
metodo lo interpreta correttamente.
Si applica a
Join(String, String, String)
- Origine:
- Path.cs
- Origine:
- Path.cs
- Origine:
- Path.cs
Concatena tre percorsi in un unico percorso.
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
Parametri
- path1
- String
Primo percorso da aggiungere.
- path2
- String
Secondo percorso da aggiungere.
- path3
- String
Terzo percorso da aggiungere.
Restituisce
Percorso concatenato.
Commenti
Questo metodo consente semplicemente di concatenare path
, path2
e path3
e aggiunge un carattere di separatore di directory tra uno dei componenti del percorso, se non ne è già presente uno. Se la lunghezza di uno qualsiasi di path1
o path3
path2
argomento è zero, il metodo concatena gli argomenti rimanenti. Se la lunghezza della stringa concatenata risultante è zero, il metodo restituisce String.Empty.
Se path1
o path2
termina in un carattere separatore di percorso non appropriato per la piattaforma di destinazione, il Join
metodo mantiene il carattere separatore di percorso originale e aggiunge quello supportato. Questo problema si verifica in percorsi hardcoded che usano il carattere barra rovesciata di Windows ("\"), che non viene riconosciuto come separatore di percorso nei sistemi basati su Unix. Per risolvere questo problema, è possibile:
Recuperare il valore della Path.DirectorySeparatorChar proprietà anziché impostare come hardcoded un carattere separatore di directory.
Usare una barra ("/") come carattere separatore di directory. Questo carattere viene restituito dalla Path.DirectorySeparatorChar proprietà nei sistemi basati su Unix e dalla Path.AltDirectorySeparatorChar proprietà nei sistemi Windows.
A differenza del Combine metodo , il Join metodo non tenta di radicere il percorso restituito. Ovvero, se path2
o path3
è un percorso assoluto, il Join
metodo non rimuove i percorsi precedenti come fa il Combine metodo.
Non tutti i caratteri non validi per i nomi di directory e file vengono interpretati come inaccettabili dal Join
metodo , perché è possibile usare questi caratteri per la ricerca di caratteri jolly. Ad esempio, anche se Path.Join("c:\\", "temp", "*.txt")
potrebbe non essere valido durante la creazione di un file, è valido come stringa di ricerca. Il Join
metodo lo interpreta correttamente.
Si applica a
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)
- Origine:
- Path.cs
- Origine:
- Path.cs
- Origine:
- Path.cs
Concatena tre componenti del percorso in un unico percorso.
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
Parametri
- path1
- ReadOnlySpan<Char>
Intervallo di caratteri che contiene il primo percorso da aggiungere.
- path2
- ReadOnlySpan<Char>
Intervallo di caratteri che contiene il secondo percorso da aggiungere.
- path3
- ReadOnlySpan<Char>
Intervallo di caratteri che contiene il terzo percorso da aggiungere.
Restituisce
Percorso concatenato.
Esempio
Nell'esempio seguente viene illustrata la differenza nei percorsi restituiti dai Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) metodi e Path.Combine(String, String, String) . Quando la prima stringa è un percorso completo che include un'unità e una directory radice e il secondo è un percorso relativo dal primo percorso, i due metodi producono risultati identici. Nella seconda e nella terza chiamata al ShowPathInformation
metodo le stringhe restituite dai due metodi divergono. Nella seconda chiamata al metodo, il primo argomento stringa è un'unità, mentre il secondo è una directory rooted. Il Join
metodo concatena le due stringhe e mantiene i separatori di percorso duplicati. Una chiamata al GetFullPath metodo eliminerebbe la duplicazione. Il Combine
metodo abbandona l'unità e restituisce una directory rooted nell'unità corrente. Se l'unità corrente dell'applicazione è C:\ e la stringa viene usata per accedere a un file o file nella directory, accederà a C: invece di D:. Infine, poiché l'argomento finale nella terza chiamata a ShowPathInformation
è rooted, il Join
metodo lo aggiunge semplicemente ai primi due argomenti per creare un percorso di file senza distinzione, mentre il Combine
metodo elimina le prime due stringhe e restituisce il terzo. L'uso di questa stringa per l'accesso ai file potrebbe concedere all'applicazione l'accesso non intenzionale ai file sensibili.
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'
Commenti
Questo metodo consente semplicemente di concatenare path
, path2
e path3
e aggiunge un carattere di separatore di directory tra uno dei componenti del percorso, se non ne è già presente uno. Se l'oggetto Length di uno degli path1
argomenti , path2
o path3
è zero, il metodo concatena gli argomenti rimanenti. Se l'oggetto ReadOnlySpan<T>.Length di tutti i componenti è zero, il metodo restituisce String.Empty.
Se path1
o path2
termina in un carattere separatore di percorso non appropriato per la piattaforma di destinazione, il Join
metodo mantiene il carattere separatore di percorso originale e aggiunge quello supportato. Questo problema si verifica in percorsi hardcoded che usano il carattere barra rovesciata di Windows ("\"), che non viene riconosciuto come separatore di percorso nei sistemi basati su Unix. Per risolvere questo problema, è possibile:
Recuperare il valore della Path.DirectorySeparatorChar proprietà anziché impostare come hardcoded un carattere separatore di directory.
Usare una barra ("/") come carattere separatore di directory. Questo carattere viene restituito dalla Path.DirectorySeparatorChar proprietà nei sistemi basati su Unix e dalla Path.AltDirectorySeparatorChar proprietà nei sistemi Windows.
A differenza del Combine metodo , il Join metodo non tenta di radicere il percorso restituito. Ovvero, se path2
o path3
è un percorso assoluto, il Join
metodo non rimuove i percorsi precedenti come fa il Combine metodo.
Non tutti i caratteri non validi per i nomi di directory e file vengono interpretati come inaccettabili dal Join
metodo , perché è possibile usare questi caratteri per la ricerca di caratteri jolly. Ad esempio, anche se Path.Join("c:\\", "temp", "*.txt")
potrebbe non essere valido durante la creazione di un file, è valido come stringa di ricerca. Il Join
metodo lo interpreta correttamente.
Vedi anche
Si applica a
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
Parametri
- paths
- ReadOnlySpan<String>
Restituisce
Si applica a
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)
- Origine:
- Path.cs
- Origine:
- Path.cs
- Origine:
- Path.cs
Concatena due componenti del percorso in un unico percorso.
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
Parametri
- path1
- ReadOnlySpan<Char>
Intervallo di caratteri che contiene il primo percorso da aggiungere.
- path2
- ReadOnlySpan<Char>
Intervallo di caratteri che contiene il secondo percorso da aggiungere.
Restituisce
Percorsi combinati.
Esempio
Nell'esempio seguente viene illustrata la differenza nei percorsi restituiti dai Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) metodi e Path.Combine(String, String) . Quando la prima stringa è un percorso completo che include un'unità e una directory radice e il secondo è un percorso relativo dal primo percorso, i due metodi producono risultati identici. Nella seconda e nella terza chiamata al ShowPathInformation
metodo le stringhe restituite dai due metodi differiscono. Nella seconda chiamata al metodo, il primo argomento stringa è un'unità, mentre il secondo è una directory radice. Il Join
metodo concatena le due stringhe e mantiene i separatori di percorso duplicati. Il Combine
metodo abbandona l'unità e restituisce una directory radice nell'unità corrente. Se l'unità corrente dell'applicazione è C:\ e la stringa viene usata per accedere a un file o file nella directory, accederà a C: anziché D:. Infine, poiché entrambi gli argomenti della terza chiamata a ShowPathInformation
sono root, il metodo li aggiunge semplicemente per creare un percorso di file non dissensibile, mentre il Join
Combine
metodo ignora la prima stringa e restituisce la seconda. L'uso di questa stringa per l'accesso ai file potrebbe concedere all'applicazione l'accesso non previsto ai file sensibili.
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/'
Commenti
Questo metodo concatena semplicemente e path2
aggiunge un carattere separatore di directory tra i due componenti del percorso se non è già presente alla fine di path1
o all'inizio di path2
.path
Se l'oggetto di path1
o path2
è zero, il metodo restituisce l'altro Length percorso. Se l'oggetto Length di entrambi e path2
è zero, il metodo restituisce String.Emptypath1
.
Se path1
termina in un carattere separatore di percorso non appropriato per la piattaforma di destinazione, il Join
metodo mantiene il carattere separatore di percorso originale e aggiunge quello supportato. Questo problema si verifica nei percorsi hardcoded che usano il carattere ("\") di Windows, che non viene riconosciuto come separatore di percorso nei sistemi basati su Unix. Per risolvere questo problema, è possibile:
Recuperare il valore della Path.DirectorySeparatorChar proprietà anziché scrivere un carattere separatore di directory.
Usare una barra ("/") come carattere separatore della directory. Questo carattere viene restituito dalla Path.DirectorySeparatorChar proprietà nei sistemi basati su Unix e dalla Path.AltDirectorySeparatorChar proprietà nei sistemi Windows.
A differenza del metodo, il CombineJoin metodo non tenta di radicere il percorso restituito. Ovvero, se path2
è un percorso assoluto, il Join
metodo non elimina path1
e restituisce path2
come fa il Combine metodo. Nell'esempio seguente viene illustrata la differenza nei percorsi restituiti dai due metodi. Se l'origine di path2
è input utente, il Combine metodo consente a un utente di accedere a una risorsa del file system (ad esempio C:/Users/User1/Documents/Financial/ nel caso dell'esempio) che l'applicazione non intende rendere accessibile.
Non tutti i caratteri non validi per i nomi di directory e file vengono interpretati come non accettabili dal Join
metodo, perché è possibile usare questi caratteri per la ricerca di caratteri jolly. Ad esempio, anche se Path.Join("c:\\", "*.txt")
potrebbe non essere valido durante la creazione di un file, è valido come stringa di ricerca. Il Join
metodo lo interpreta correttamente.
Vedi anche
Si applica a
Join(String[])
- Origine:
- Path.cs
- Origine:
- Path.cs
- Origine:
- Path.cs
Concatena una matrice di percorsi in un unico percorso.
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
Parametri
- paths
- String[]
Matrice di percorsi.
Restituisce
Percorso concatenato.
Commenti
Questo metodo concatena semplicemente tutte le stringhe in paths
e aggiunge un carattere separatore di directory tra uno dei componenti del percorso se non è già presente. Se uno Length dei percorsi in paths
è zero, il metodo concatena gli argomenti rimanenti. Se la lunghezza della stringa concatenata risultante è zero, il metodo restituisce String.Empty.
Se uno dei percorsi in paths
, ad eccezione dell'ultimo, termina in un carattere separatore di percorso non appropriato per la piattaforma di destinazione, il Join
metodo mantiene il carattere separatore di percorso originale e aggiunge quello supportato. Questo problema si verifica nei percorsi hardcoded che usano il carattere ("\") di Windows, che non viene riconosciuto come separatore di percorso nei sistemi basati su Unix. Per risolvere questo problema, è possibile:
Recuperare il valore della Path.DirectorySeparatorChar proprietà anziché scrivere un carattere separatore di directory.
Usare una barra ("/") come carattere separatore della directory. Questo carattere viene restituito dalla Path.DirectorySeparatorChar proprietà nei sistemi basati su Unix e dalla Path.AltDirectorySeparatorChar proprietà nei sistemi Windows.
A differenza del metodo, il CombineJoin metodo non tenta di radicere il percorso restituito. Ovvero, se uno dei percorsi in paths
, ad eccezione del primo, è un percorso assoluto, il Join
metodo non elimina i percorsi precedenti come fa il Combine metodo.
Non tutti i caratteri non validi per i nomi di directory e file vengono interpretati come non accettabili dal Join
metodo, perché è possibile usare questi caratteri per la ricerca di caratteri jolly. Ad esempio, anche se Path.Join("c:\\", "temp", "*.txt")
potrebbe non essere valido durante la creazione di un file, è valido come stringa di ricerca. Il Join
metodo lo interpreta correttamente.
Si applica a
Join(String, String)
- Origine:
- Path.cs
- Origine:
- Path.cs
- Origine:
- Path.cs
Concatena due percorsi in un unico percorso.
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
Parametri
- path1
- String
Primo percorso da aggiungere.
- path2
- String
Secondo percorso da aggiungere.
Restituisce
Percorso concatenato.
Commenti
Questo metodo concatena path
semplicemente e path2
aggiunge un carattere separatore di directory tra uno dei componenti del percorso se non è già presente. Se la lunghezza di path1
o path2
è zero, il metodo concatena l'argomento rimanente. Se la lunghezza della stringa concatenata risultante è zero, il metodo restituisce String.Empty.
Se path1
termina in un carattere separatore di percorso non appropriato per la piattaforma di destinazione, il Join
metodo mantiene il carattere separatore di percorso originale e aggiunge quello supportato. Questo problema si verifica nei percorsi hardcoded che usano il carattere ("\") di Windows, che non viene riconosciuto come separatore di percorso nei sistemi basati su Unix. Per risolvere questo problema, è possibile:
Recuperare il valore della Path.DirectorySeparatorChar proprietà anziché scrivere un carattere separatore di directory.
Usare una barra ("/") come carattere separatore della directory. Questo carattere viene restituito dalla Path.DirectorySeparatorChar proprietà nei sistemi basati su Unix e dalla Path.AltDirectorySeparatorChar proprietà nei sistemi Windows.
A differenza del metodo, il CombineJoin metodo non tenta di radicere il percorso restituito. Ovvero, se path2
è un percorso assoluto, il Join
metodo non elimina i percorsi precedenti come fa il Combine metodo.
Non tutti i caratteri non validi per i nomi di directory e file vengono interpretati come non accettabili dal Join
metodo, perché è possibile usare questi caratteri per la ricerca di caratteri jolly. Ad esempio, anche se Path.Join("c:\\", "temp", "*.txt")
potrebbe non essere valido durante la creazione di un file, è valido come stringa di ricerca. Il Join
metodo lo interpreta correttamente.
Si applica a
Commenti e suggerimenti
https://aka.ms/ContentUserFeedback.
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedereInvia e visualizza il feedback per