Path.Join Methode

Definition

Namespace:

System.IO

Assembly:

System.Runtime.dll

Überlädt

Join(String, String, String, String)	Verkettet vier Pfade zu einem einzelnen Pfad.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Verkettet vier Pfadkomponenten zu einem einzelnen Pfad.
Join(String, String, String)	Verkettet drei Pfade zu einem einzelnen Pfad.
Join(String[])	Verkettet ein Array von Pfaden zu einem einzelnen Pfad.
Join(String, String)	Verkettet zwei Pfade zu einem einzelnen Pfad.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Verkettet zwei Pfadkomponenten zu einem einzigen Pfad.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Verkettet drei Pfadkomponenten zu einem einzigen Pfad.

Join(String, String, String, String)

Quelle:

Path.cs

Verkettet vier Pfade zu einem einzelnen Pfad.

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

Parameter

path1

String

Der erste Pfad für die Verknüpfung.

path2

String

Der zweite Pfad für die Verknüpfung.

path3

String

Der dritte Pfad für die Verknüpfung.

path4

String

Der vierte Pfad für die Verknüpfung.

Gibt zurück

String

Der verkettete Pfad.

Hinweise

Diese Methode verkettet patheinfach , path2und path3path4 fügt ein Verzeichnistrennzeichen zwischen einer der Pfadkomponenten hinzu, sofern noch keine vorhanden ist. Wenn die Länge eines der path1Argumente , path2path3 oder path4 null ist, verkettet die Methode die verbleibenden Argumente. Wenn die Länge der resultierenden verketteten Zeichenfolge null ist, gibt die -Methode zurück String.Empty.

Wenn path1 oder oder path3path2 mit einem Pfadtrennzeichen endet, das für die Zielplattform nicht geeignet ist, behält die Join Methode das ursprüngliche Pfadtrennzeichen bei und fügt das unterstützte an. Dieses Problem tritt in hartcodierten Pfaden auf, die den umgekehrten Schrägstrich ("\") von Windows verwenden, der auf Unix-basierten Systemen nicht als Pfadtrennzeichen erkannt wird. Um dieses Problem zu umgehen, haben Sie folgende Möglichkeiten:

• Rufen Sie den Wert der Path.DirectorySeparatorChar Eigenschaft ab, anstatt ein Verzeichnistrennzeichen hart zu codieren.

• Verwenden Sie einen Schrägstrich ("/") als Verzeichnistrennzeichen. Dieses Zeichen wird von der Path.DirectorySeparatorChar -Eigenschaft auf Unix-basierten Systemen und von der Path.AltDirectorySeparatorChar -Eigenschaft auf Windows-Systemen zurückgegeben.

Combine Im Gegensatz zur -Methode versucht die Join -Methode nicht, den zurückgegebenen Pfad zu rooten. (Das heißt, wenn path2 oder oder path4path3 ein absoluter Pfad ist, verwirft die Join Methode die vorherigen Pfade nicht wie die Combine Methode.)

Nicht alle ungültigen Zeichen für Verzeichnis- und Dateinamen werden von der Join -Methode als inakzeptabel interpretiert, da Sie diese Zeichen für Suchplatzhalterzeichen verwenden können. Beispielsweise Path.Join("c:\\", "temp", "*.txt") kann beim Erstellen einer Datei ungültig sein, sie ist aber als Suchzeichenfolge gültig. Die Join Methode interpretiert sie daher erfolgreich.

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

Quelle:

Path.cs

Verkettet vier Pfadkomponenten zu einem einzelnen Pfad.

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

Parameter

path1

ReadOnlySpan<Char>

Eine Zeichenspanne, die den ersten Pfad für die Verknüpfung enthält.

path2

ReadOnlySpan<Char>

Eine Zeichenspanne, die den zweiten Pfad für die Verknüpfung enthält.

path3

ReadOnlySpan<Char>

Eine Zeichenspanne, die den dritten Pfad für die Verknüpfung enthält.

path4

ReadOnlySpan<Char>

Eine Zeichenspanne, die den vierten zu verknüpfenden Pfad enthält.

Gibt zurück

String

Der verkettete Pfad.

Hinweise

Diese Methode verkettet patheinfach , path2und path3path4 fügt ein Verzeichnistrennzeichen zwischen einer der Pfadkomponenten hinzu, sofern noch keine vorhanden ist. Wenn das von Length einem der path1Argumente , path3path2oder path4 null ist, verkettet die -Methode die verbleibenden Argumente. Wenn der ReadOnlySpan<T>.Length aller Komponenten null ist, gibt die -Methode zurück String.Empty.

Wenn path1 oder oder path3path2 mit einem Pfadtrennzeichen endet, das für die Zielplattform nicht geeignet ist, behält die Join Methode das ursprüngliche Pfadtrennzeichen bei und fügt das unterstützte an. Dieses Problem tritt in hartcodierten Pfaden auf, die den umgekehrten Schrägstrich ("\") von Windows verwenden, der auf Unix-basierten Systemen nicht als Pfadtrennzeichen erkannt wird. Um dieses Problem zu umgehen, haben Sie folgende Möglichkeiten:

• Rufen Sie den Wert der Path.DirectorySeparatorChar Eigenschaft ab, anstatt ein Verzeichnistrennzeichen hart zu codieren.

• Verwenden Sie einen Schrägstrich ("/") als Verzeichnistrennzeichen. Dieses Zeichen wird von der Path.DirectorySeparatorChar -Eigenschaft auf Unix-basierten Systemen und von der Path.AltDirectorySeparatorChar -Eigenschaft auf Windows-Systemen zurückgegeben.

Combine Im Gegensatz zur -Methode versucht die Join -Methode nicht, den zurückgegebenen Pfad zu rooten. (Das heißt, wenn path2 oder oder path4path3 ein absoluter Pfad ist, verwirft die Join Methode die vorherigen Pfade nicht wie die Combine Methode.)

Nicht alle ungültigen Zeichen für Verzeichnis- und Dateinamen werden von der Join -Methode als inakzeptabel interpretiert, da Sie diese Zeichen für Suchplatzhalterzeichen verwenden können. Beispielsweise Path.Join("c:\\", "temp", "*.txt") kann beim Erstellen einer Datei ungültig sein, sie ist aber als Suchzeichenfolge gültig. Die Join Methode interpretiert sie daher erfolgreich.

Join(String, String, String)

Quelle:

Path.cs

Verkettet drei Pfade zu einem einzelnen Pfad.

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

Parameter

path1

String

Der erste Pfad für die Verknüpfung.

path2

String

Der zweite Pfad für die Verknüpfung.

path3

String

Der dritte Pfad für die Verknüpfung.

Gibt zurück

String

Der verkettete Pfad.

Hinweise

Diese Methode verkettet patheinfach , path2und path3 fügt ein Verzeichnistrennzeichen zwischen einer der Pfadkomponenten hinzu, sofern noch keine vorhanden ist. Wenn die Länge eines der path1Argumente oder path2path3 null ist, verkettet die Methode die verbleibenden Argumente. Wenn die Länge der resultierenden verketteten Zeichenfolge null ist, gibt die -Methode zurück String.Empty.

Wenn path1 oder mit einem Pfadtrennzeichen endet, path2 das für die Zielplattform nicht geeignet ist, behält die Join Methode das ursprüngliche Pfadtrennzeichen bei und fügt das unterstützte an. Dieses Problem tritt in hartcodierten Pfaden auf, die den umgekehrten Schrägstrich ("\") von Windows verwenden, der auf Unix-basierten Systemen nicht als Pfadtrennzeichen erkannt wird. Um dieses Problem zu umgehen, haben Sie folgende Möglichkeiten:

• Rufen Sie den Wert der Path.DirectorySeparatorChar Eigenschaft ab, anstatt ein Verzeichnistrennzeichen hart zu codieren.

• Verwenden Sie einen Schrägstrich ("/") als Verzeichnistrennzeichen. Dieses Zeichen wird von der Path.DirectorySeparatorChar -Eigenschaft auf Unix-basierten Systemen und von der Path.AltDirectorySeparatorChar -Eigenschaft auf Windows-Systemen zurückgegeben.

Combine Im Gegensatz zur -Methode versucht die Join -Methode nicht, den zurückgegebenen Pfad zu rooten. (Das heißt, wenn path2 oder path3 ein absoluter Pfad ist, verwirft die Join Methode die vorherigen Pfade nicht wie die Combine -Methode.)

Nicht alle ungültigen Zeichen für Verzeichnis- und Dateinamen werden von der Join -Methode als inakzeptabel interpretiert, da Sie diese Zeichen für Suchplatzhalterzeichen verwenden können. Beispielsweise Path.Join("c:\\", "temp", "*.txt") kann beim Erstellen einer Datei ungültig sein, sie ist aber als Suchzeichenfolge gültig. Die Join Methode interpretiert sie daher erfolgreich.

Join(String[])

Quelle:

Path.cs

Verkettet ein Array von Pfaden zu einem einzelnen Pfad.

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

Parameter

paths

String[]

Ein Array von Pfaden.

Gibt zurück

String

Der verkettete Pfad.

Hinweise

Diese Methode verkettet einfach alle Zeichenfolgen in paths und fügt ein Verzeichnistrennzeichen zwischen einer der Pfadkomponenten hinzu, sofern noch keine vorhanden ist. Wenn der Length von einem der Pfade in paths null ist, verkettet die Methode die verbleibenden Argumente. Wenn die Länge der resultierenden verketteten Zeichenfolge null ist, gibt die -Methode zurück String.Empty.

Wenn einer der Pfade in mit pathsAusnahme des letzten Pfads mit einem Pfadtrennzeichen endet, das für die Zielplattform nicht geeignet ist, behält die Join Methode das ursprüngliche Pfadtrennzeichen bei und fügt das unterstützte an. Dieses Problem tritt in hartcodierten Pfaden auf, die den umgekehrten Schrägstrich ("\") von Windows verwenden, der auf Unix-basierten Systemen nicht als Pfadtrennzeichen erkannt wird. Um dieses Problem zu umgehen, haben Sie folgende Möglichkeiten:

• Rufen Sie den Wert der Path.DirectorySeparatorChar Eigenschaft ab, anstatt ein Verzeichnistrennzeichen hart zu codieren.

• Verwenden Sie einen Schrägstrich ("/") als Verzeichnistrennzeichen. Dieses Zeichen wird von der Path.DirectorySeparatorChar -Eigenschaft auf Unix-basierten Systemen und von der Path.AltDirectorySeparatorChar -Eigenschaft auf Windows-Systemen zurückgegeben.

Combine Im Gegensatz zur -Methode versucht die Join -Methode nicht, den zurückgegebenen Pfad zu rooten. (Das heißt, wenn einer der Pfade in mit pathsAusnahme des ersten pfads ein absoluter Pfad ist, verwirft die Join Methode die vorherigen Pfade nicht wie die Combine -Methode.)

Nicht alle ungültigen Zeichen für Verzeichnis- und Dateinamen werden von der Join -Methode als inakzeptabel interpretiert, da Sie diese Zeichen für Suchplatzhalterzeichen verwenden können. Beispielsweise Path.Join("c:\\", "temp", "*.txt") kann beim Erstellen einer Datei ungültig sein, sie ist aber als Suchzeichenfolge gültig. Die Join Methode interpretiert sie daher erfolgreich.

Join(String, String)

Quelle:

Path.cs

Verkettet zwei Pfade zu einem einzelnen Pfad.

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

Parameter

path1

String

Der erste Pfad für die Verknüpfung.

path2

String

Der zweite Pfad für die Verknüpfung.

Gibt zurück

String

Der verkettete Pfad.

Hinweise

Diese Methode verkettet path einfach und path2 fügt ein Verzeichnistrennzeichen zwischen einer der Pfadkomponenten hinzu, sofern noch keine vorhanden ist. Wenn die Länge von path1 oder path2 null ist, verkettet die Methode das verbleibende Argument. Wenn die Länge der resultierenden verketteten Zeichenfolge null ist, gibt die -Methode zurück String.Empty.

Wenn path1 mit einem Pfadtrennzeichen endet, das nicht für die Zielplattform geeignet ist, behält die Join Methode das ursprüngliche Pfadtrennzeichen bei und fügt das unterstützte an. Dieses Problem tritt in hartcodierten Pfaden auf, die den umgekehrten Schrägstrich ("\") von Windows verwenden, der auf Unix-basierten Systemen nicht als Pfadtrennzeichen erkannt wird. Um dieses Problem zu umgehen, haben Sie folgende Möglichkeiten:

• Rufen Sie den Wert der Path.DirectorySeparatorChar Eigenschaft ab, anstatt ein Verzeichnistrennzeichen hart zu codieren.

• Verwenden Sie einen Schrägstrich ("/") als Verzeichnistrennzeichen. Dieses Zeichen wird von der Path.DirectorySeparatorChar -Eigenschaft auf Unix-basierten Systemen und von der Path.AltDirectorySeparatorChar -Eigenschaft auf Windows-Systemen zurückgegeben.

Combine Im Gegensatz zur -Methode versucht die Join -Methode nicht, den zurückgegebenen Pfad zu rooten. (Das heißt, wenn path2 ein absoluter Pfad ist, verwirft die Join Methode die vorherigen Pfade nicht wie die Combine Methode.)

Nicht alle ungültigen Zeichen für Verzeichnis- und Dateinamen werden von der Join -Methode als inakzeptabel interpretiert, da Sie diese Zeichen für Suchplatzhalterzeichen verwenden können. Beispielsweise Path.Join("c:\\", "temp", "*.txt") kann beim Erstellen einer Datei ungültig sein, sie ist aber als Suchzeichenfolge gültig. Die Join Methode interpretiert sie daher erfolgreich.

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

Quelle:

Path.cs

Verkettet zwei Pfadkomponenten zu einem einzigen Pfad.

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

Parameter

path1

ReadOnlySpan<Char>

Eine Zeichenspanne, die den ersten Pfad für die Verknüpfung enthält.

path2

ReadOnlySpan<Char>

Eine Zeichenspanne, die den zweiten Pfad für die Verknüpfung enthält.

Gibt zurück

String

Die kombinierten Pfade.

Beispiele

Das folgende Beispiel veranschaulicht den Unterschied in den Pfaden, die von den Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) Methoden und Path.Combine(String, String) zurückgegeben werden. Wenn die erste Zeichenfolge ein vollqualifizierter Pfad ist, der ein Laufwerk und ein Stammverzeichnis enthält und die zweite ein relativer Pfad vom ersten Pfad ist, erzeugen die beiden Methoden identische Ergebnisse. Beim zweiten und dritten Aufruf der ShowPathInformation -Methode unterscheiden sich die von den beiden Methoden zurückgegebenen Zeichenfolgen. Im zweiten Methodenaufruf ist das erste Zeichenfolgenargument ein Laufwerk, während das zweite ein Rootverzeichnis ist. Die Join -Methode verkettet die beiden Zeichenfolgen und behält doppelte Pfadtrennzeichen bei. Die Combine -Methode verlässt das Laufwerk und gibt ein root-Verzeichnis auf dem aktuellen Laufwerk zurück. Wenn das aktuelle Laufwerk der Anwendung C:\ ist und die Zeichenfolge wird verwendet, um auf eine Datei oder Dateien im Verzeichnis zuzugreifen, sie würde auf C: anstelle von D:zugreifen. Da schließlich beide Argumente im dritten Aufruf von ShowPathInformation gerootet sind, fügt die Join Methode sie einfach an, um einen unsinnigen Dateipfad zu erstellen, während die Combine Methode die erste Zeichenfolge verwirft und die zweite zurückgibt. Die Verwendung dieser Zeichenfolge für den Dateizugriff könnte der Anwendung unbeabsichtigten Zugriff auf vertrauliche Dateien gewähren.

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/'

Hinweise

Diese Methode verkettet path einfach und path2 und fügt ein Verzeichnistrennzeichen zwischen den beiden Pfadkomponenten hinzu, wenn am Ende von oder am Anfang von path1path2noch keines vorhanden ist. Wenn der Length von path1 oder path2 null ist, gibt die Methode den anderen Pfad zurück. Wenn der Length von und path1path2 null ist, gibt die -Methode zurück String.Empty.

Wenn path1 mit einem Pfadtrennzeichen endet, das nicht für die Zielplattform geeignet ist, behält die Join Methode das ursprüngliche Pfadtrennzeichen bei und fügt das unterstützte an. Dieses Problem tritt in hartcodierten Pfaden auf, die den umgekehrten Schrägstrich ("\") von Windows verwenden, der auf Unix-basierten Systemen nicht als Pfadtrennzeichen erkannt wird. Um dieses Problem zu umgehen, haben Sie folgende Möglichkeiten:

• Rufen Sie den Wert der Path.DirectorySeparatorChar Eigenschaft ab, anstatt ein Verzeichnistrennzeichen hart zu codieren.

• Verwenden Sie einen Schrägstrich ("/") als Verzeichnistrennzeichen. Dieses Zeichen wird von der Path.DirectorySeparatorChar -Eigenschaft auf Unix-basierten Systemen und von der Path.AltDirectorySeparatorChar -Eigenschaft auf Windows-Systemen zurückgegeben.

Combine Im Gegensatz zur -Methode versucht die Join -Methode nicht, den zurückgegebenen Pfad zu rooten. (Das heißt, wenn path2 es sich um einen absoluten Pfad handelt, verwirft path1 und gibt die Join Methode nicht wie die Combine Methode zurückpath2.) Das folgende Beispiel veranschaulicht den Unterschied in den Pfaden, die von den beiden Methoden zurückgegeben werden. Wenn die Quelle der path2 Benutzereingabe ist, ermöglicht die Combine -Methode einem Benutzer den Zugriff auf eine Dateisystemressource (z. B . C:/Users/User1/Documents/Financial/ im Fall des Beispiels), die die Anwendung nicht zugänglich machen wollte.

Nicht alle ungültigen Zeichen für Verzeichnis- und Dateinamen werden von der Join -Methode als inakzeptabel interpretiert, da Sie diese Zeichen für Suchplatzhalterzeichen verwenden können. Beispielsweise Path.Join("c:\\", "*.txt") kann beim Erstellen einer Datei ungültig sein, sie ist aber als Suchzeichenfolge gültig. Die Join Methode interpretiert sie daher erfolgreich.

Weitere Informationen

• Formate von Dateipfaden unter Windows-Systemen

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

Quelle:

Path.cs

Verkettet drei Pfadkomponenten zu einem einzigen Pfad.

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

Parameter

path1

ReadOnlySpan<Char>

Eine Zeichenspanne, die den ersten Pfad für die Verknüpfung enthält.

path2

ReadOnlySpan<Char>

Eine Zeichenspanne, die den zweiten Pfad für die Verknüpfung enthält.

path3

ReadOnlySpan<Char>

Eine Zeichenspanne, die den dritten Pfad für die Verknüpfung enthält.

Gibt zurück

String

Der verkettete Pfad.

Beispiele

Das folgende Beispiel veranschaulicht den Unterschied in den Pfaden, die von den Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Methoden und Path.Combine(String, String, String) zurückgegeben werden. Wenn die erste Zeichenfolge ein vollqualifizierter Pfad ist, der ein Laufwerk und ein Stammverzeichnis enthält, und die zweite ein relativer Pfad vom ersten Pfad ist, erzeugen die beiden Methoden identische Ergebnisse. Beim zweiten und dritten Aufruf der ShowPathInformation -Methode unterscheiden sich die von den beiden Methoden zurückgegebenen Zeichenfolgen. Im zweiten Methodenaufruf ist das erste Zeichenfolgenargument ein Laufwerk, während das zweite ein Rootverzeichnis ist. Die Join -Methode verkettet die beiden Zeichenfolgen und behält doppelte Pfadtrennzeichen bei. Ein Aufruf der GetFullPath -Methode würde die Duplizierung beseitigen. Die Combine -Methode verlässt das Laufwerk und gibt ein root-Verzeichnis auf dem aktuellen Laufwerk zurück. Wenn das aktuelle Laufwerk der Anwendung C:\ ist und die Zeichenfolge wird verwendet, um auf eine Datei oder Dateien im Verzeichnis zuzugreifen, sie würde auf C: anstelle von D:zugreifen. Da schließlich das letzte Argument im dritten Aufruf ShowPathInformation von gerootet ist, fügt die Join Methode es einfach an die ersten beiden Argumente an, um einen unsinnigen Dateipfad zu erstellen, während die Combine Methode die ersten beiden Zeichenfolgen verwirft und die dritte zurückgibt. Die Verwendung dieser Zeichenfolge für den Dateizugriff könnte der Anwendung unbeabsichtigten Zugriff auf vertrauliche Dateien gewähren.

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'

Hinweise

Diese Methode verkettet patheinfach , path2und path3 fügt ein Verzeichnistrennzeichen zwischen einer der Pfadkomponenten hinzu, sofern noch keine vorhanden ist. Wenn die Length eines der path1Argumente , path2oder path3 null ist, verkettet die -Methode die verbleibenden Argumente. Wenn der ReadOnlySpan<T>.Length aller Komponenten null ist, gibt die -Methode zurück String.Empty.

Wenn path1 oder mit einem Pfadtrennzeichen endet, path2 das für die Zielplattform nicht geeignet ist, behält die Join Methode das ursprüngliche Pfadtrennzeichen bei und fügt das unterstützte an. Dieses Problem tritt in hartcodierten Pfaden auf, die den umgekehrten Schrägstrich ("\") von Windows verwenden, der auf Unix-basierten Systemen nicht als Pfadtrennzeichen erkannt wird. Um dieses Problem zu umgehen, haben Sie folgende Möglichkeiten:

• Rufen Sie den Wert der Path.DirectorySeparatorChar Eigenschaft ab, anstatt ein Verzeichnistrennzeichen hart zu codieren.

• Verwenden Sie einen Schrägstrich ("/") als Verzeichnistrennzeichen. Dieses Zeichen wird von der Path.DirectorySeparatorChar -Eigenschaft auf Unix-basierten Systemen und von der Path.AltDirectorySeparatorChar -Eigenschaft auf Windows-Systemen zurückgegeben.

Combine Im Gegensatz zur -Methode versucht die Join -Methode nicht, den zurückgegebenen Pfad zu rooten. (Das heißt, wenn path2 oder path3 ein absoluter Pfad ist, verwirft die Join Methode die vorherigen Pfade nicht wie die Combine -Methode.)

Nicht alle ungültigen Zeichen für Verzeichnis- und Dateinamen werden von der Join -Methode als inakzeptabel interpretiert, da Sie diese Zeichen für Suchplatzhalterzeichen verwenden können. Beispielsweise Path.Join("c:\\", "temp", "*.txt") kann beim Erstellen einer Datei ungültig sein, sie ist aber als Suchzeichenfolge gültig. Die Join Methode interpretiert sie daher erfolgreich.

Weitere Informationen

• Formate von Dateipfaden unter Windows-Systemen