Path.Join Metodo

Definizione

Spazio dei nomi:: System.IO

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

Nome	Descrizione
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatena due componenti di percorso in un singolo percorso.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatena tre componenti di percorso in un singolo percorso.

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

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.

Valori restituiti

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 del primo percorso, i due metodi producono risultati identici. Nella seconda e nella terza chiamata al ShowPathInformation metodo le stringhe restituite dai due metodi divergono. Nella seconda chiamata al metodo, il primo argomento stringa è un'unità, mentre il secondo è una directory rooted. Il Join metodo concatena le due stringhe e mantiene i separatori di percorso duplicati. Il Combine metodo abbandona l'unità e restituisce una directory rooted nell'unità corrente. Se l'unità corrente dell'applicazione è C:\ e la stringa viene usata per accedere a un file o file nella directory, accederà a C: invece di D:. Infine, poiché entrambi gli argomenti nella terza chiamata a ShowPathInformation sono rooted, il Join metodo li aggiunge semplicemente per creare un percorso di file senza senso, mentre il Combine metodo elimina 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 semplicemente concatena path e path2 aggiunge un carattere separatore di directory tra i due componenti del percorso se non ne è già presente uno alla fine di path1 o all'inizio di path2. Se l'oggetto Length di path1 o path2 è zero, il metodo restituisce l'altro percorso. Se l'oggetto 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 Join metodo mantiene il carattere separatore di percorso originale e aggiunge quello supportato. Questo problema si verifica in percorsi hardcoded che usano il carattere Windows barra rovesciata ("\"), 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 proprietà Path.DirectorySeparatorChar nei sistemi basati su Unix e dalla proprietà Path.AltDirectorySeparatorChar nei sistemi Windows.

A differenza del Combine metodo , il Join metodo non tenta di eseguire la radice del percorso restituito. Ovvero, se path2 è un percorso assoluto, il Join metodo non rimuove 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 è l'input dell'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 di percorso File nei sistemi Windows

Si applica a

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

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.

Valori restituiti

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 del primo percorso, i due metodi producono risultati identici. Nella seconda e nella terza chiamata al ShowPathInformation metodo le stringhe restituite dai due metodi divergono. Nella seconda chiamata al metodo, il primo argomento stringa è un'unità, mentre il secondo è una directory rooted. Il Join metodo concatena le due stringhe e mantiene i separatori di percorso duplicati. Una chiamata al GetFullPath metodo eliminerebbe la duplicazione. Il Combine metodo abbandona l'unità e restituisce una directory rooted nell'unità corrente. Se l'unità corrente dell'applicazione è C:\ e la stringa viene usata per accedere a un file o file nella directory, accederà a C: invece di D:. Infine, poiché l'argomento finale nella terza chiamata a ShowPathInformation è rooted, il Join metodo lo aggiunge semplicemente ai primi due argomenti per creare un percorso di file senza senso, mentre il Combine metodo 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 consente semplicemente di concatenare path, path2e e path3 aggiunge un carattere separatore di directory tra uno dei componenti del percorso, se non ne è già presente uno. Se l'oggetto Length di uno 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 in percorsi hardcoded che usano il carattere Windows barra rovesciata ("\"), 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 proprietà Path.DirectorySeparatorChar nei sistemi basati su Unix e dalla proprietà Path.AltDirectorySeparatorChar nei sistemi Windows.

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

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.

Vedi anche

formati di percorso File nei sistemi Windows

Si applica a

Commenti e suggerimenti

Questa pagina è stata utile?