Path.Join Metodo

Riferimento

Definizione

Spazio dei nomi:: System.IO

Assembly:: System.Runtime.dll

Assembly:: System.Runtime.Extensions.dll

Assembly:: netstandard.dll

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(String[])	Concatena una matrice di percorsi in un unico percorso.
Join(String, String)	Concatena due percorsi in un unico percorso.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatena due componenti del percorso in un unico percorso.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatena tre componenti del percorso 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

String

Percorso concatenato.

Commenti

Questo metodo consente semplicemente di concatenare path, path2path3 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, path3path2o 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 path2path3 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 path3path4 è 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

String

Percorso concatenato.

Commenti

Questo metodo consente semplicemente di concatenare path, path2path3 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, path2path3 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.

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.

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

String

Percorso concatenato.

Commenti

Questo metodo consente semplicemente di concatenare path, path2e 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 path1o path3path2 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.

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

String

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 ne è già presente uno. Se l'oggetto Length di uno 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 con 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 uno qualsiasi dei percorsi in paths, ad eccezione del primo, è un percorso assoluto, il Join metodo non rimuove i percorsi precedenti come fa il Combine metodo .

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

String

Percorso concatenato.

Commenti

Questo metodo concatena path semplicemente e path2 aggiunge un carattere separatore di directory tra uno dei componenti del percorso, se non ne è già presente uno. 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 con 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 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 Combine Join 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

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

String

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 JoinCombine 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 Combine Join 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

Formati dei percorsi di file nei sistemi Windows

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

String

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 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. Una chiamata al GetFullPath metodo eliminerebbe la duplicazione. 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é l'argomento finale della terza chiamata a ShowPathInformation è root, il Join metodo lo aggiunge semplicemente ai primi due argomenti per creare un percorso file non dissensico, mentre il Combine metodo ignora 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 previsto 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 concatena pathsemplicemente , path2e path3 aggiunge un carattere separatore di directory tra uno dei componenti del percorso se non è già presente. Se uno Length degli path1argomenti , path2o 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 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 Combine Join metodo non tenta di radicere il percorso restituito. Ovvero, se path2 o path3 è un percorso assoluto, il Join metodo non elimina i percorsi precedenti come fa il Combine metodo.

Vedi anche

Formati dei percorsi di file nei sistemi Windows

Si applica a

Path.Join Metodo

Definizione

Overload

Join(String, String, String, String)

Parametri

Restituisce

Commenti

Si applica a

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

Parametri

Restituisce

Commenti

Si applica a

Join(String, String, String)

Parametri

Restituisce

Commenti

Si applica a

Join(String[])

Parametri

Restituisce

Commenti

Si applica a

Join(String, String)

Parametri

Restituisce

Commenti

Si applica a

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

Parametri

Restituisce

Esempio

Commenti

Vedi anche

Si applica a

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

Parametri

Restituisce

Esempio

Commenti

Vedi anche

Si applica a

Commenti e suggerimenti

Risorse aggiuntive