Path.Join Metodo

Definizione

Overload

Join(String, String, String, String)

Concatena quattro percorsi in un unico percorso.Concatenates four paths into a single path.

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

Concatena quattro componenti del percorso in un unico percorso.Concatenates four path components into a single path.

Join(String, String, String)

Concatena tre percorsi in un unico percorso.Concatenates three paths into a single path.

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

Concatena due componenti del percorso in un unico percorso.Concatenates two path components into a single path.

Join(String, String)

Concatena due percorsi in un unico percorso.Concatenates two paths into a single path.

Join(String[])

Concatena una matrice di percorsi in un unico percorso.Concatenates an array of paths into a single path.

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

Concatena tre componenti del percorso in un unico percorso.Concatenates three path components into a single path.

Join(String, String, String, String)

Concatena quattro percorsi in un unico percorso.Concatenates four paths into a single path.

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.The first path to join.

path2
String

Secondo percorso da aggiungere.The second path to join.

path3
String

Terzo percorso da aggiungere.The third path to join.

path4
String

Quarto percorso da aggiungere.The fourth path to join.

Restituisce

Percorso concatenato.The concatenated path.

Commenti

Questo metodo concatena semplicemente path, path2, path3 e path4 e aggiunge un carattere separatore di directory tra i componenti del percorso, se non ne è già presente uno.This method simply concatenates path, path2, path3 and path4 and adds a directory separator character between any of the path components if one is not already present. Se la lunghezza di uno qualsiasi di path1, path2, path3 o path4 argomento è zero, il metodo concatena gli argomenti rimanenti.If the length of any of path1, path2, path3 or path4 argument is zero, the method concatenates the remaining arguments. Se la lunghezza della stringa concatenata risultante è zero, il metodo restituisce String.Empty.If the length of the resulting concatenated string is zero, the method returns String.Empty.

Se path1 o path2 o path3 termina con un carattere separatore di percorso non appropriato per la piattaforma di destinazione, il metodo Join conserva il carattere separatore di percorso originale e ne aggiunge uno supportato.If path1 or path2 or path3 ends in a path separator character that is not appropriate for the target platform, the Join method preserves the original path separator character and appends the supported one. Questo problema si verifica nei percorsi hardcoded che usano il carattere barra rovesciata di Windows (""), che non è riconosciuto come separatore di percorso nei sistemi basati su UNIX.This issue arises in hard-coded paths that use the Windows backslash ("") character, which is not recognized as a path separator on Unix-based systems. Per risolvere il problema, è possibile:To work around this issue, you can:

A differenza del metodo Combine, il metodo Join non tenta di eseguire la radice del percorso restituito.Unlike the Combine method, the Join method does not attempt to root the returned path. Ovvero, se path2 o path2 o path3 è un percorso assoluto, il metodo Join non rimuove i percorsi precedenti come fa il metodo Combine.(That is, if path2 or path2 or path3 is an absolute path, the Join method does not discard the previous paths as the Combine method does.

Non tutti i caratteri non validi per i nomi di directory e file vengono interpretati come inaccettabili dal metodo di Join, perché è possibile usare questi caratteri per i caratteri jolly di ricerca.Not all invalid characters for directory and file names are interpreted as unacceptable by the Join method, because you can use these characters for search wildcard characters. Ad esempio, mentre Path.Join("c:\\", "temp", "*.txt") potrebbe non essere valido durante la creazione di un file, è valido come stringa di ricerca.For example, while Path.Join("c:\\", "temp", "*.txt") might be invalid when creating a file, it is valid as a search string. Il metodo Join pertanto lo interpreta correttamente.The Join method therefore successfully interprets it.

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

Concatena quattro componenti del percorso in un unico percorso.Concatenates four path components into a single path.

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.A character span that contains the first path to join.

path2
ReadOnlySpan<Char>

Intervallo di caratteri che contiene il secondo percorso da aggiungere.A character span that contains the second path to join.

path3
ReadOnlySpan<Char>

Intervallo di caratteri che contiene il terzo percorso da aggiungere.A character span that contains the third path to join.

path4
ReadOnlySpan<Char>

Intervallo di caratteri che contiene il quarto percorso da aggiungere.A character span that contains the fourth path to join.

Restituisce

Percorso concatenato.The concatenated path.

Commenti

Questo metodo concatena semplicemente path, path2, path3 e path4 e aggiunge un carattere separatore di directory tra i componenti del percorso, se non ne è già presente uno.This method simply concatenates path, path2, path3 and path4 and adds a directory separator character between any of the path components if one is not already present. Se il Length di uno degli path1, path2, path3 o path4 argomento è zero, il metodo concatena gli argomenti rimanenti.If the Length of any of path1, path2, path3 or path4 argument is zero, the method concatenates the remaining arguments. Se il ReadOnlySpan<T>.Length di tutti i componenti è zero, il metodo restituisce String.Empty.If the ReadOnlySpan<T>.Length of all components is zero, the method returns String.Empty.

Se path1 o path2 o path3 termina con un carattere separatore di percorso non appropriato per la piattaforma di destinazione, il metodo Join conserva il carattere separatore di percorso originale e ne aggiunge uno supportato.If path1 or path2 or path3 ends in a path separator character that is not appropriate for the target platform, the Join method preserves the original path separator character and appends the supported one. Questo problema si verifica nei percorsi hardcoded che usano il carattere barra rovesciata di Windows (""), che non è riconosciuto come separatore di percorso nei sistemi basati su UNIX.This issue arises in hard-coded paths that use the Windows backslash ("") character, which is not recognized as a path separator on Unix-based systems. Per risolvere il problema, è possibile:To work around this issue, you can:

A differenza del metodo Combine, il metodo Join non tenta di eseguire la radice del percorso restituito.Unlike the Combine method, the Join method does not attempt to root the returned path. Ovvero, se path2 o path2 o path3 è un percorso assoluto, il metodo Join non rimuove i percorsi precedenti come fa il metodo Combine.(That is, if path2 or path2 or path3 is an absolute path, the Join method does not discard the previous paths as the Combine method does.

Non tutti i caratteri non validi per i nomi di directory e file vengono interpretati come inaccettabili dal metodo di Join, perché è possibile usare questi caratteri per i caratteri jolly di ricerca.Not all invalid characters for directory and file names are interpreted as unacceptable by the Join method, because you can use these characters for search wildcard characters. Ad esempio, mentre Path.Join("c:\\", "temp", "*.txt") potrebbe non essere valido durante la creazione di un file, è valido come stringa di ricerca.For example, while Path.Join("c:\\", "temp", "*.txt") might be invalid when creating a file, it is valid as a search string. Il metodo Join pertanto lo interpreta correttamente.The Join method therefore successfully interprets it.

Join(String, String, String)

Concatena tre percorsi in un unico percorso.Concatenates three paths into a single path.

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.The first path to join.

path2
String

Secondo percorso da aggiungere.The second path to join.

path3
String

Terzo percorso da aggiungere.The third path to join.

Restituisce

Percorso concatenato.The concatenated path.

Commenti

Questo metodo concatena semplicemente path, path2e path3 e aggiunge un carattere separatore di directory tra i componenti del percorso, se non ne è già presente uno.This method simply concatenates path, path2, and path3 and adds a directory separator character between any of the path components if one is not already present. Se la lunghezza di uno qualsiasi di path1, path2 o path3 argomento è zero, il metodo concatena gli argomenti rimanenti.If the length of any of path1, path2 or path3 argument is zero, the method concatenates the remaining arguments. Se la lunghezza della stringa concatenata risultante è zero, il metodo restituisce String.Empty.If the length of the resulting concatenated string is zero, the method returns String.Empty.

Se path1 o path2 termina con un carattere separatore di percorso non appropriato per la piattaforma di destinazione, il metodo Join conserva il carattere separatore di percorso originale e ne aggiunge uno supportato.If path1 or path2 ends in a path separator character that is not appropriate for the target platform, the Join method preserves the original path separator character and appends the supported one. Questo problema si verifica nei percorsi hardcoded che usano il carattere barra rovesciata di Windows (""), che non è riconosciuto come separatore di percorso nei sistemi basati su UNIX.This issue arises in hard-coded paths that use the Windows backslash ("") character, which is not recognized as a path separator on Unix-based systems. Per risolvere il problema, è possibile:To work around this issue, you can:

A differenza del metodo Combine, il metodo Join non tenta di eseguire la radice del percorso restituito.Unlike the Combine method, the Join method does not attempt to root the returned path. Ovvero, se path2 o path2 è un percorso assoluto, il metodo Join non rimuove i percorsi precedenti come il metodo Combine.(That is, if path2 or path2 is an absolute path, the Join method does not discard the previous paths as the Combine method does.

Non tutti i caratteri non validi per i nomi di directory e file vengono interpretati come inaccettabili dal metodo di Join, perché è possibile usare questi caratteri per i caratteri jolly di ricerca.Not all invalid characters for directory and file names are interpreted as unacceptable by the Join method, because you can use these characters for search wildcard characters. Ad esempio, mentre Path.Join("c:\\", "temp", "*.txt") potrebbe non essere valido durante la creazione di un file, è valido come stringa di ricerca.For example, while Path.Join("c:\\", "temp", "*.txt") might be invalid when creating a file, it is valid as a search string. Il metodo Join pertanto lo interpreta correttamente.The Join method therefore successfully interprets it.

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

Concatena due componenti del percorso in un unico percorso.Concatenates two path components into a single path.

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.A character span that contains the first path to join.

path2
ReadOnlySpan<Char>

Intervallo di caratteri che contiene il secondo percorso da aggiungere.A character span that contains the second path to join.

Restituisce

Percorsi combinati.The combined paths.

Commenti

Questo metodo concatena semplicemente path e path2 e aggiunge un carattere separatore di directory tra i due componenti del percorso, se non ne è già presente uno alla fine del path1 o l'inizio della path2.This method simply concatenates path and path2 and adds a directory separator character between the two path components if one is not already present at the end of path1 or the beginning of path2. Se il Length di path1 o path2 è zero, il metodo restituisce l'altro percorso.If the Length of either path1 or path2 is zero, the method returns the other path. Se il Length di path1 e path2 è zero, il metodo restituisce String.Empty.If the Length of both path1 and path2 is zero, the method returns String.Empty.

Se path1 termina con un carattere separatore di percorso non appropriato per la piattaforma di destinazione, il metodo Join conserva il carattere separatore di percorso originale e ne aggiunge uno supportato.If path1 ends in a path separator character that is not appropriate for the target platform, the Join method preserves the original path separator character and appends the supported one. Questo problema si verifica nei percorsi hardcoded che usano il carattere barra rovesciata di Windows (""), che non è riconosciuto come separatore di percorso nei sistemi basati su UNIX.This issue arises in hard-coded paths that use the Windows backslash ("") character, which is not recognized as a path separator on Unix-based systems. Per risolvere il problema, è possibile:To work around this issue, you can:

A differenza del metodo Combine, il metodo Join non tenta di eseguire la radice del percorso restituito.Unlike the Combine method, the Join method does not attempt to root the returned path. (Ovvero, se path2 è un percorso assoluto, il metodo Join non Elimina path1 e restituisce path2 come fa il metodo Combine). Nell'esempio seguente viene illustrata la differenza nei percorsi restituiti dai due metodi.(That is, if path2 is an absolute path, the Join method does not discard path1 and return path2 as the Combine method does.) The following example illustrates the difference in the paths returned by the two methods. Se l'origine del path2 è l'input dell'utente, il metodo Combine consente a un utente di accedere a una risorsa file system (ad esempio C:/users/user1/Documents/Financial/ nel caso dell'esempio) che l'applicazione non intendeva rendere accessibile.If the source of path2 is user input, the Combine method makes it possible for a user to access a file system resource (such as C:/Users/User1/Documents/Financial/ in the case of the example) that the application did not intend to make accessible.

Non tutti i caratteri non validi per i nomi di directory e file vengono interpretati come inaccettabili dal metodo di Join, perché è possibile usare questi caratteri per i caratteri jolly di ricerca.Not all invalid characters for directory and file names are interpreted as unacceptable by the Join method, because you can use these characters for search wildcard characters. Ad esempio, mentre Path.Join("c:\\", "*.txt") potrebbe non essere valido durante la creazione di un file, è valido come stringa di ricerca.For example, while Path.Join("c:\\", "*.txt") might be invalid when creating a file, it is valid as a search string. Il metodo Join pertanto lo interpreta correttamente.The Join method therefore successfully interprets it.

EsempioExample

Nell'esempio seguente viene illustrata la differenza nei percorsi restituiti dai metodi Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) e Path.Combine(String, String).The following example illustrates the difference in the paths returned by the Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) and Path.Combine(String, String) methods. 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.When the first string is an fully qualified path that includes a drive and root directory and the second is a relative path from the first path, the two methods produce identical results. Nella seconda e terza chiamata al metodo ShowPathInformation, le stringhe restituite dai due metodi diSono diverse.In the second and third calls to the ShowPathInformation method, the strings returned by the two methods diverge. Nella seconda chiamata al metodo, il primo argomento stringa è un'unità, mentre la seconda è una directory radice.In the second method call, the first string argument is a drive, while the second is a rooted directory. Il metodo Join concatena le due stringhe e conserva i separatori di percorso duplicati.The Join method concatenates the two strings and preserves duplicate path separators. Il metodo Combine abbandona l'unità e restituisce una directory radice nell'unità corrente.The Combine method abandons the drive and returns a rooted directory on the current drive. Se l'unità corrente dell'applicazione è C:\ e la stringa viene usata per accedere a un file o a un file nella directory, ad accedere a C: anziché a D:.If the application's current drive is C:\ and the string is used to access a file or files in the directory, it would access C: instead of D:. Infine, poiché entrambi gli argomenti della terza chiamata a ShowPathInformation hanno una radice, il metodo Join li aggiunge semplicemente per creare un percorso di file non necessario, mentre il metodo Combine rimuove la prima stringa e restituisce il secondo.Finally, because both arguments in the third call to ShowPathInformation are rooted, the Join method simply appends them to create a nonsensical file path, while the Combine method discards the first string and returns the second. L'uso di questa stringa per l'accesso ai file potrebbe consentire all'applicazione di accedere a file riservati in modo imprevisto.Using this string for file access could give the application unintended access to sensitive files.

using System;
using System.IO;

class Program
{
    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/'

Vedi anche

Join(String, String)

Concatena due percorsi in un unico percorso.Concatenates two paths into a single path.

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.The first path to join.

path2
String

Secondo percorso da aggiungere.The second path to join.

Restituisce

Percorso concatenato.The concatenated path.

Commenti

Questo metodo concatena semplicemente path e path2 e aggiunge un carattere separatore di directory tra i componenti del percorso, se non ne è già presente uno.This method simply concatenates path and path2 and adds a directory separator character between any of the path components if one is not already present. Se la lunghezza di path1 o path2 è zero, il metodo concatena l'argomento rimanente.If the length of either path1 or path2 is zero, the method concatenates the remaining argument. Se la lunghezza della stringa concatenata risultante è zero, il metodo restituisce String.Empty.If the length of the resulting concatenated string is zero, the method returns String.Empty.

Se path1 termina con un carattere separatore di percorso non appropriato per la piattaforma di destinazione, il metodo Join conserva il carattere separatore di percorso originale e ne aggiunge uno supportato.If path1 ends in a path separator character that is not appropriate for the target platform, the Join method preserves the original path separator character and appends the supported one. Questo problema si verifica nei percorsi hardcoded che usano il carattere barra rovesciata di Windows (""), che non è riconosciuto come separatore di percorso nei sistemi basati su UNIX.This issue arises in hard-coded paths that use the Windows backslash ("") character, which is not recognized as a path separator on Unix-based systems. Per risolvere il problema, è possibile:To work around this issue, you can:

A differenza del metodo Combine, il metodo Join non tenta di eseguire la radice del percorso restituito.Unlike the Combine method, the Join method does not attempt to root the returned path. Ovvero, se path2 è un percorso assoluto, il metodo Join non rimuove i percorsi precedenti come avviene Combine metodo.(That is, if path2 is an absolute path, the Join method does not discard the previous paths as the Combine method does.

Non tutti i caratteri non validi per i nomi di directory e file vengono interpretati come inaccettabili dal metodo di Join, perché è possibile usare questi caratteri per i caratteri jolly di ricerca.Not all invalid characters for directory and file names are interpreted as unacceptable by the Join method, because you can use these characters for search wildcard characters. Ad esempio, mentre Path.Join("c:\\", "temp", "*.txt") potrebbe non essere valido durante la creazione di un file, è valido come stringa di ricerca.For example, while Path.Join("c:\\", "temp", "*.txt") might be invalid when creating a file, it is valid as a search string. Il metodo Join pertanto lo interpreta correttamente.The Join method therefore successfully interprets it.

Join(String[])

Concatena una matrice di percorsi in un unico percorso.Concatenates an array of paths into a single path.

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.An array of paths.

Restituisce

Percorso concatenato.The concatenated path.

Commenti

Questo metodo concatena semplicemente tutte le stringhe in paths e aggiunge un carattere separatore di directory tra i componenti del percorso, se non ne è già presente uno.This method simply concatenates all the strings in paths and adds a directory separator character between any of the path components if one is not already present. Se il Length di uno dei percorsi in paths è zero, il metodo concatena gli argomenti rimanenti.If the Length of any of the paths in paths is zero, the method concatenates the remaining arguments. Se la lunghezza della stringa concatenata risultante è zero, il metodo restituisce String.Empty.If the resulting concatenated string's length is zero, the method returns 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 metodo Join conserva il carattere separatore di percorso originale e ne Accoda uno supportato.If any of the paths in paths, except for the last one, ends in a path separator character that is not appropriate for the target platform, the Join method preserves the original path separator character and appends the supported one. Questo problema si verifica nei percorsi hardcoded che usano il carattere barra rovesciata di Windows (""), che non è riconosciuto come separatore di percorso nei sistemi basati su UNIX.This issue arises in hard-coded paths that use the Windows backslash ("") character, which is not recognized as a path separator on Unix-based systems. Per risolvere il problema, è possibile:To work around this issue, you can:

A differenza del metodo Combine, il metodo Join non tenta di eseguire la radice del percorso restituito.Unlike the Combine method, the Join method does not attempt to root the returned path. Ovvero, se uno dei percorsi in paths, ad eccezione dell'ultimo, è un percorso assoluto, il metodo Join non rimuove i percorsi precedenti come avviene Combine metodo.(That is, if any of the paths in paths, except for the last one, is an absolute path, the Join method does not discard the previous paths as the Combine method does.

Non tutti i caratteri non validi per i nomi di directory e file vengono interpretati come inaccettabili dal metodo di Join, perché è possibile usare questi caratteri per i caratteri jolly di ricerca.Not all invalid characters for directory and file names are interpreted as unacceptable by the Join method, because you can use these characters for search wildcard characters. Ad esempio, mentre Path.Join("c:\\", "temp", "*.txt") potrebbe non essere valido durante la creazione di un file, è valido come stringa di ricerca.For example, while Path.Join("c:\\", "temp", "*.txt") might be invalid when creating a file, it is valid as a search string. Il metodo Join pertanto lo interpreta correttamente.The Join method therefore successfully interprets it.

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

Concatena tre componenti del percorso in un unico percorso.Concatenates three path components into a single path.

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.A character span that contains the first path to join.

path2
ReadOnlySpan<Char>

Intervallo di caratteri che contiene il secondo percorso da aggiungere.A character span that contains the second path to join.

path3
ReadOnlySpan<Char>

Intervallo di caratteri che contiene il terzo percorso da aggiungere.A character span that contains the third path to join.

Restituisce

Percorso concatenato.The concatenated path.

Commenti

Questo metodo concatena semplicemente path, path2e path3 e aggiunge un carattere separatore di directory tra i componenti del percorso, se non ne è già presente uno.This method simply concatenates path, path2, and path3 and adds a directory separator character between any of the path components if one is not already present. Se il Length di uno degli argomenti path1, path2o path3 è zero, il metodo concatena gli argomenti rimanenti.If the Length of any of path1, path2, or path3 arguments is zero, the method concatenates the remaining arguments. Se il ReadOnlySpan<T>.Length di tutti i componenti è zero, il metodo restituisce String.Empty.If the ReadOnlySpan<T>.Length of all components is zero, the method returns String.Empty.

Se path1 o path2 termina con un carattere separatore di percorso non appropriato per la piattaforma di destinazione, il metodo Join conserva il carattere separatore di percorso originale e ne aggiunge uno supportato.If path1 or path2 ends in a path separator character that is not appropriate for the target platform, the Join method preserves the original path separator character and appends the supported one. Questo problema si verifica nei percorsi hardcoded che usano il carattere barra rovesciata di Windows (""), che non è riconosciuto come separatore di percorso nei sistemi basati su UNIX.This issue arises in hard-coded paths that use the Windows backslash ("") character, which is not recognized as a path separator on Unix-based systems. Per risolvere il problema, è possibile:To work around this issue, you can:

A differenza del metodo Combine, il metodo Join non tenta di eseguire la radice del percorso restituito.Unlike the Combine method, the Join method does not attempt to root the returned path. Ovvero, se path2 o path2 è un percorso assoluto, il metodo Join non rimuove i percorsi precedenti come il metodo Combine.(That is, if path2 or path2 is an absolute path, the Join method does not discard the previous paths as the Combine method does.

Non tutti i caratteri non validi per i nomi di directory e file vengono interpretati come inaccettabili dal metodo di Join, perché è possibile usare questi caratteri per i caratteri jolly di ricerca.Not all invalid characters for directory and file names are interpreted as unacceptable by the Join method, because you can use these characters for search wildcard characters. Ad esempio, mentre Path.Join("c:\\", "temp", "*.txt") potrebbe non essere valido durante la creazione di un file, è valido come stringa di ricerca.For example, while Path.Join("c:\\", "temp", "*.txt") might be invalid when creating a file, it is valid as a search string. Il metodo Join pertanto lo interpreta correttamente.The Join method therefore successfully interprets it.

EsempioExample

Nell'esempio seguente viene illustrata la differenza nei percorsi restituiti dai metodi Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) e Path.Combine(String, String, String).The following example illustrates the difference in the paths returned by the Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) and Path.Combine(String, String, String) methods. 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.When the first string is a fully qualified path that includes a drive and root directory and the second is a relative path from the first path, the two methods produce identical results. Nella seconda e terza chiamata al metodo ShowPathInformation, le stringhe restituite dai due metodi diSono diverse.In the second and third calls to the ShowPathInformation method, the strings returned by the two methods diverge. Nella seconda chiamata al metodo, il primo argomento stringa è un'unità, mentre la seconda è una directory radice.In the second method call, the first string argument is a drive, while the second is a rooted directory. Il metodo Join concatena le due stringhe e conserva i separatori di percorso duplicati.The Join method concatenates the two strings and preserves duplicate path separators. Una chiamata al metodo GetFullPath eliminerà la duplicazione.A call to the GetFullPath method would eliminate the duplication. Il metodo Combine abbandona l'unità e restituisce una directory radice nell'unità corrente.The Combine method abandons the drive and returns a rooted directory on the current drive. Se l'unità corrente dell'applicazione è C:\ e la stringa viene usata per accedere a un file o a un file nella directory, ad accedere a C: anziché a D:.If the application's current drive is C:\ and the string is used to access a file or files in the directory, it would access C: instead of D:. Infine, poiché l'argomento finale della terza chiamata a ShowPathInformation è radicato, il metodo Join lo aggiunge semplicemente ai primi due argomenti per creare un percorso di file non necessario, mentre il metodo di Combine rimuove le prime due stringhe e restituisce il terzo.Finally, because the final argument in the third call to ShowPathInformation are rooted, the Join method simply appends it to the first two arguments to create a nonsensical file path, while the Combine method discards the first two strings and returns the third. L'uso di questa stringa per l'accesso ai file potrebbe consentire all'applicazione di accedere a file riservati in modo imprevisto.Using this string for file access could give the application unintended access to sensitive files.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string path1 = "C:/";
        string path2 = "users/user1/documents";
        string path3 = "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);
    }

   private static void ShowPathInformation(string path1, string path2, string path3)
    {
        var 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)}'");
        Console.WriteLine($"   {Path.GetFullPath(result)}");
    }
}
// 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'
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'
 

Vedi anche

Si applica a