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

Join(String, String, String, String)

Origine:: Path.cs

Origine:: Path.cs

Origine:: Path.cs

Concatena quattro percorsi in un singolo 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 unire.

path2: String

Secondo percorso da unire.

path3: String

Terzo percorso da unire.

path4: String

Quarto percorso da unire.

Restituisce

String

Percorso concatenato.

Commenti

Questo metodo concatena semplicemente path, path2, path3 e path4 e aggiunge un carattere separatore di directory tra uno dei componenti del percorso, se non ne è già presente uno. Se la lunghezza di uno qualsiasi path1, path2, path3 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 o path3 termina con un carattere separatore di percorso non appropriato per la piattaforma di destinazione, il metodo Join 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 proprietà Path.DirectorySeparatorChar anziché impostare come hardcoded un carattere separatore di directory.
Usare una barra ("/") come carattere separatore di directory. Questo carattere viene restituito dalla proprietà Path.DirectorySeparatorChar nei sistemi basati su Unix e dalla proprietà Path.AltDirectorySeparatorChar nei sistemi Windows.

A differenza del metodo Combine, il metodo Join non tenta di eseguire la radice del percorso restituito. Ovvero, se path2 o path3 o path4 è un percorso assoluto, il metodo Join non rimuove i percorsi precedenti perché il metodo Combine esegue.

Non tutti i caratteri non validi per i nomi di directory e file vengono interpretati come non accettabili dal metodo Join, perché è possibile usare questi caratteri per la ricerca di caratteri jolly. Ad esempio, mentre Path.Join("c:\\", "temp", "*.txt") potrebbe non essere valido durante la creazione di un file, è valido come stringa di ricerca. Il metodo Join 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 di percorso in un singolo 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 di join.

path2: ReadOnlySpan<Char>

Intervallo di caratteri che contiene il secondo percorso da unire.

path3: ReadOnlySpan<Char>

Intervallo di caratteri che contiene il terzo percorso da unire.

path4: ReadOnlySpan<Char>

Intervallo di caratteri che contiene il quarto percorso da unire.

Restituisce

String

Percorso concatenato.

Commenti

Questo metodo concatena semplicemente path, path2, path3 e path4 e aggiunge un carattere separatore di directory tra uno dei componenti del percorso, se non ne è già presente uno. Se il Length di uno dei path1, path2, path3 o path4 argomento è zero, il metodo concatena gli argomenti rimanenti. Se il ReadOnlySpan<T>.Length di tutti i componenti è zero, il metodo restituisce String.Empty.

Recuperare il valore della proprietà Path.DirectorySeparatorChar anziché impostare come hardcoded un carattere separatore di directory.
Usare una barra ("/") come carattere separatore di directory. Questo carattere viene restituito dalla proprietà Path.DirectorySeparatorChar nei sistemi basati su Unix e dalla proprietà Path.AltDirectorySeparatorChar nei sistemi Windows.

Si applica a

Join(String, String, String)

Origine:: Path.cs

Origine:: Path.cs

Origine:: Path.cs

Concatena tre percorsi in un singolo 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 unire.

path2: String

Secondo percorso da unire.

path3: String

Terzo percorso da unire.

Restituisce

String

Percorso concatenato.

Commenti

Questo metodo concatena semplicemente path, path2e path3 e aggiunge un carattere separatore di directory tra uno dei componenti del percorso, se non ne è già presente uno. Se la lunghezza di uno qualsiasi path1, path2 o path3 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 con un carattere separatore di percorso non appropriato per la piattaforma di destinazione, il metodo Join 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 proprietà Path.DirectorySeparatorChar anziché impostare come hardcoded un carattere separatore di directory.
Usare una barra ("/") come carattere separatore di directory. Questo carattere viene restituito dalla proprietà Path.DirectorySeparatorChar nei sistemi basati su Unix e dalla proprietà Path.AltDirectorySeparatorChar nei sistemi Windows.

A differenza del metodo Combine, il metodo Join non tenta di eseguire la radice del percorso restituito. In altri caso, se path2 o path3 è un percorso assoluto, il metodo Join non rimuove i percorsi precedenti perché il metodo Combine esegue.

Si applica a

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

Origine:: Path.cs

Origine:: Path.cs

Origine:: Path.cs

Concatena tre componenti di percorso in un singolo 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 di join.

path2: ReadOnlySpan<Char>

Intervallo di caratteri che contiene il secondo percorso da unire.

path3: ReadOnlySpan<Char>

Intervallo di caratteri che contiene il terzo percorso da unire.

Restituisce

String

Percorso concatenato.

Esempio

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). Quando la prima stringa è un percorso completo che include un'unità e una directory radice e il secondo è un percorso relativo del primo percorso, i due metodi producono risultati identici. Nella seconda e nella terza chiamata al metodo ShowPathInformation 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 metodo Join concatena le due stringhe e mantiene i separatori di percorso duplicati. Una chiamata al metodo GetFullPath eliminerebbe la duplicazione. Il metodo Combine 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 metodo Join lo aggiunge semplicemente ai primi due argomenti per creare un percorso di file senza senso, mentre il metodo Combine rimuove 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 concatena semplicemente path, path2e path3 e aggiunge un carattere separatore di directory tra uno dei componenti del percorso, se non ne è già presente uno. Se l'Length di uno dei path1, path2o path3 argomenti è zero, il metodo concatena gli argomenti rimanenti. Se il ReadOnlySpan<T>.Length di tutti i componenti è zero, il metodo restituisce String.Empty.

Recuperare il valore della proprietà Path.DirectorySeparatorChar anziché impostare come hardcoded un carattere separatore di directory.
Usare una barra ("/") come carattere separatore di directory. Questo carattere viene restituito dalla proprietà Path.DirectorySeparatorChar nei sistemi basati su Unix e dalla proprietà Path.AltDirectorySeparatorChar nei sistemi Windows.

Vedi anche

formati di percorso file nei sistemi Windows

Si applica a

Join(ReadOnlySpan<String>)

Concatena un intervallo di percorsi in un singolo percorso.

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>

Intervallo di percorsi.

Restituisce

String

Percorso concatenato.

Si applica a

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

Origine:: Path.cs

Origine:: Path.cs

Origine:: Path.cs

Concatena due componenti di percorso in un singolo 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 di join.

path2: ReadOnlySpan<Char>

Intervallo di caratteri che contiene il secondo percorso da unire.

Restituisce

String

Percorsi combinati.

Esempio

Nell'esempio seguente viene illustrata la differenza nei percorsi restituiti dai metodi Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) 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 del primo percorso, i due metodi producono risultati identici. Nella seconda e nella terza chiamata al metodo ShowPathInformation 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 metodo Join concatena le due stringhe e mantiene i separatori di percorso duplicati. Il metodo Combine 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é entrambi gli argomenti nella terza chiamata a ShowPathInformation sono rooted, il metodo Join li aggiunge semplicemente per creare un percorso di file senza senso, mentre il metodo Combine rimuove la prima stringa e restituisce il secondo. 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 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 consente semplicemente di concatenare path e path2 e aggiunge un carattere separatore di directory tra i due componenti del percorso se uno non è già presente alla fine di path1 o all'inizio di path2. Se il Length di path1 o path2 è zero, il metodo restituisce l'altro percorso. Se il Length di path1 e path2 è zero, il metodo restituisce String.Empty.

Se path1 termina con un carattere separatore di percorso non appropriato per la piattaforma di destinazione, il metodo Join 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 proprietà Path.DirectorySeparatorChar anziché impostare come hardcoded un carattere separatore di directory.
Usare una barra ("/") come carattere separatore di directory. Questo carattere viene restituito dalla proprietà Path.DirectorySeparatorChar nei sistemi basati su Unix e dalla proprietà Path.AltDirectorySeparatorChar nei sistemi Windows.

A differenza del metodo Combine, il metodo Join non tenta di eseguire la radice del percorso restituito. Ovvero, se path2 è un percorso assoluto, il metodo Join non rimuove path1 e restituisce path2 come fa il metodo Combine. Nell'esempio seguente viene illustrata la differenza nei percorsi restituiti dai due metodi. Se l'origine di path2 è l'input dell'utente, il metodo Combine 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 metodo Join, perché è possibile usare questi caratteri per la ricerca di caratteri jolly. Ad esempio, mentre Path.Join("c:\\", "*.txt") potrebbe non essere valido durante la creazione di un file, è valido come stringa di ricerca. Il metodo Join lo interpreta correttamente.

Vedi anche

formati di percorso file nei sistemi Windows

Si applica a

Join(String[])

Origine:: Path.cs

Origine:: Path.cs

Origine:: Path.cs

Concatena una matrice di percorsi in un singolo 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 il 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 metodo Join 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 proprietà Path.DirectorySeparatorChar anziché impostare come hardcoded un carattere separatore di directory.
Usare una barra ("/") come carattere separatore di directory. Questo carattere viene restituito dalla proprietà Path.DirectorySeparatorChar nei sistemi basati su Unix e dalla proprietà Path.AltDirectorySeparatorChar nei sistemi Windows.

A differenza del metodo Combine, il metodo Join non tenta di eseguire la radice del percorso restituito. Ovvero, se uno dei percorsi in paths, ad eccezione del primo percorso, è un percorso assoluto, il metodo Join non rimuove i percorsi precedenti perché il metodo Combine esegue.

Si applica a

Join(String, String)

Origine:: Path.cs

Origine:: Path.cs

Origine:: Path.cs

Concatena due percorsi in un singolo 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 unire.

path2: String

Secondo percorso da unire.

Restituisce

String

Percorso concatenato.

Commenti

Questo metodo concatena semplicemente path e path2 e 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.

Recuperare il valore della proprietà Path.DirectorySeparatorChar anziché impostare come hardcoded un carattere separatore di directory.
Usare una barra ("/") come carattere separatore di directory. Questo carattere viene restituito dalla proprietà Path.DirectorySeparatorChar nei sistemi basati su Unix e dalla proprietà Path.AltDirectorySeparatorChar nei sistemi Windows.

A differenza del metodo Combine, il metodo Join non tenta di eseguire la radice del percorso restituito. In altri caso, se path2 è un percorso assoluto, il metodo Join non rimuove i percorsi precedenti perché il metodo Combine esegue.

Si applica a

Condividi tramite

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(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Parametri

Restituisce

Esempio

Commenti

Vedi anche

Si applica a

Join(ReadOnlySpan<String>)

Parametri

Restituisce

Si applica a

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

Parametri

Restituisce

Esempio

Commenti

Vedi anche

Si applica a

Join(String[])

Parametri

Restituisce

Commenti

Si applica a

Join(String, String)

Parametri

Restituisce

Commenti

Si applica a

Risorse aggiuntive