Path.Join Methode

Definition

Namespace:

System.IO

Assembly:

System.Runtime.dll

Überlädt

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

Join(String, String, String, String)

Quelle:

Path.cs

Verkettet vier Pfade in einen 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 Zutrittspfad.

path2

String

Der zweite Zutrittspfad.

path3

String

Der dritte Zutrittspfad.

path4

String

Der vierte Zutrittspfad.

Gibt zurück

String

Der verkettete Pfad.

Hinweise

Diese Methode verkettet einfach path, path2, path3 und path4 und fügt ein Verzeichnistrennzeichen zwischen einer der Pfadkomponenten hinzu, wenn noch nicht vorhanden ist. Wenn die Länge eines path1, path2, path3 oder path4 Arguments null ist, verkettet die Methode die verbleibenden Argumente. Wenn die Länge der resultierenden verketteten Zeichenfolge null ist, gibt die Methode String.Emptyzurück.

Wenn path1 oder path2 oder path3 auf ein 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 ("\") verwenden, der nicht als Pfadtrennzeichen auf Unix-basierten Systemen erkannt wird. Um dieses Problem zu umgehen, können Sie:

• Rufen Sie den Wert der Path.DirectorySeparatorChar-Eigenschaft ab, anstatt ein Verzeichnistrennzeichen fest 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.

Im Gegensatz zur Combine Methode versucht die Join-Methode nicht, den zurückgegebenen Pfad zu rooten. (Wenn path2 oder path3 oder path4 ein absoluter Pfad ist, verwirft die Join-Methode nicht die vorherigen Pfade, 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 Such-Wildcardzeichen verwenden können. Wenn beispielsweise Path.Join("c:\\", "temp", "*.txt") beim Erstellen einer Datei ungültig sein kann, ist sie 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 in einen 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>

Ein Zeichenbereich, der den ersten zu verbindenden Pfad enthält.

path2

ReadOnlySpan<Char>

Ein Zeichenbereich, der den zweiten zu verbindenden Pfad enthält.

path3

ReadOnlySpan<Char>

Ein Zeichenbereich, der den dritten Zutrittspfad enthält.

path4

ReadOnlySpan<Char>

Ein Zeichenbereich, der den vierten Zutrittspfad enthält.

Gibt zurück

String

Der verkettete Pfad.

Hinweise

Diese Methode verkettet einfach path, path2, path3 und path4 und fügt ein Verzeichnistrennzeichen zwischen einer der Pfadkomponenten hinzu, wenn noch nicht vorhanden ist. Wenn die Length eines path1, path2, path3 oder path4 Arguments null ist, verkettet die Methode die verbleibenden Argumente. Wenn die ReadOnlySpan<T>.Length aller Komponenten null ist, gibt die Methode String.Emptyzurück.

Wenn path1 oder path2 oder path3 auf ein 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 ("\") verwenden, der nicht als Pfadtrennzeichen auf Unix-basierten Systemen erkannt wird. Um dieses Problem zu umgehen, können Sie:

• Rufen Sie den Wert der Path.DirectorySeparatorChar-Eigenschaft ab, anstatt ein Verzeichnistrennzeichen fest 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.

Im Gegensatz zur Combine Methode versucht die Join-Methode nicht, den zurückgegebenen Pfad zu rooten. (Wenn path2 oder path3 oder path4 ein absoluter Pfad ist, verwirft die Join-Methode nicht die vorherigen Pfade, 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 Such-Wildcardzeichen verwenden können. Wenn beispielsweise Path.Join("c:\\", "temp", "*.txt") beim Erstellen einer Datei ungültig sein kann, ist sie als Suchzeichenfolge gültig. Die Join Methode interpretiert sie daher erfolgreich.

Join(String, String, String)

Quelle:

Path.cs

Verkettet drei Pfade mit 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 Zutrittspfad.

path2

String

Der zweite Zutrittspfad.

path3

String

Der dritte Zutrittspfad.

Gibt zurück

String

Der verkettete Pfad.

Hinweise

Diese Methode verkettet einfach path, path2und path3 und fügt ein Verzeichnistrennzeichen zwischen einer der Pfadkomponenten hinzu, wenn noch nicht vorhanden ist. Wenn die Länge eines path1, path2 oder path3 Arguments null ist, verkettet die Methode die verbleibenden Argumente. Wenn die Länge der resultierenden verketteten Zeichenfolge null ist, gibt die Methode String.Emptyzurück.

Wenn path1 oder path2 auf ein 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 ("\") verwenden, der nicht als Pfadtrennzeichen auf Unix-basierten Systemen erkannt wird. Um dieses Problem zu umgehen, können Sie:

• Rufen Sie den Wert der Path.DirectorySeparatorChar-Eigenschaft ab, anstatt ein Verzeichnistrennzeichen fest 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.

Im Gegensatz zur Combine Methode versucht die Join-Methode nicht, den zurückgegebenen Pfad zu rooten. (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 Such-Wildcardzeichen verwenden können. Wenn beispielsweise Path.Join("c:\\", "temp", "*.txt") beim Erstellen einer Datei ungültig sein kann, ist sie als Suchzeichenfolge gültig. Die Join Methode interpretiert sie daher erfolgreich.

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

Quelle:

Path.cs

Verkettet drei Pfadkomponenten in einem einzelnen 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>

Ein Zeichenbereich, der den ersten zu verbindenden Pfad enthält.

path2

ReadOnlySpan<Char>

Ein Zeichenbereich, der den zweiten zu verbindenden Pfad enthält.

path3

ReadOnlySpan<Char>

Ein Zeichenbereich, der den dritten Zutrittspfad enthält.

Gibt zurück

String

Der verkettete Pfad.

Beispiele

Das folgende Beispiel veranschaulicht den Unterschied in den Pfaden, die von den methoden Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) 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 der zweite ein relativer Pfad vom ersten Pfad ist, erzeugen die beiden Methoden identische Ergebnisse. Im 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 der zweite ein rootes Verzeichnis 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 gibt das Laufwerk auf und gibt ein rootes Verzeichnis auf dem aktuellen Laufwerk zurück. Wenn das aktuelle Laufwerk der Anwendung C:\ lautet und die Zeichenfolge für den Zugriff auf eine Datei oder Dateien im Verzeichnis verwendet wird, würde sie auf C: anstelle von D:zugreifen. Da das letzte Argument im dritten Aufruf von ShowPathInformation wurzelt, fügt die Join-Methode sie einfach an die ersten beiden Argumente an, um einen unsinnigen Dateipfad zu erstellen, während die Combine-Methode die ersten beiden Zeichenfolgen verwirft und den dritten 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 einfach path, path2und path3 und fügt ein Verzeichnistrennzeichen zwischen einer der Pfadkomponenten hinzu, wenn noch nicht vorhanden ist. Wenn die Length eines path1, path2oder path3 Argumente null ist, verkettet die Methode die verbleibenden Argumente. Wenn die ReadOnlySpan<T>.Length aller Komponenten null ist, gibt die Methode String.Emptyzurück.

Wenn path1 oder path2 auf ein 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 ("\") verwenden, der nicht als Pfadtrennzeichen auf Unix-basierten Systemen erkannt wird. Um dieses Problem zu umgehen, können Sie:

• Rufen Sie den Wert der Path.DirectorySeparatorChar-Eigenschaft ab, anstatt ein Verzeichnistrennzeichen fest 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.

Im Gegensatz zur Combine Methode versucht die Join-Methode nicht, den zurückgegebenen Pfad zu rooten. (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 Such-Wildcardzeichen verwenden können. Wenn beispielsweise Path.Join("c:\\", "temp", "*.txt") beim Erstellen einer Datei ungültig sein kann, ist sie als Suchzeichenfolge gültig. Die Join Methode interpretiert sie daher erfolgreich.

Weitere Informationen

• Dateiformate auf Windows-Systemen

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

Quelle:

Path.cs

Verkettet zwei Pfadkomponenten in 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>

Ein Zeichenbereich, der den ersten zu verbindenden Pfad enthält.

path2

ReadOnlySpan<Char>

Ein Zeichenbereich, der den zweiten zu verbindenden Pfad enthält.

Gibt zurück

String

Die kombinierten Pfade.

Beispiele

Das folgende Beispiel veranschaulicht den Unterschied in den Pfaden, die von den methoden Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) und Path.Combine(String, String) zurückgegeben werden. Wenn es sich bei der ersten Zeichenfolge um einen vollqualifizierten Pfad handelt, der ein Laufwerk und ein Stammverzeichnis enthält und das zweite ein relativer Pfad vom ersten Pfad ist, erzeugen die beiden Methoden identische Ergebnisse. Im 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 der zweite ein rootes Verzeichnis ist. Die Join-Methode verkettet die beiden Zeichenfolgen und behält doppelte Pfadtrennzeichen bei. Die Combine Methode gibt das Laufwerk auf und gibt ein rootes Verzeichnis auf dem aktuellen Laufwerk zurück. Wenn das aktuelle Laufwerk der Anwendung C:\ lautet und die Zeichenfolge für den Zugriff auf eine Datei oder Dateien im Verzeichnis verwendet wird, würde sie auf C: anstelle von D:zugreifen. Da beide Argumente im dritten Aufruf von ShowPathInformation root sind, fügt die Join Methode sie einfach an, um einen nichtsensischen 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 einfach path und path2 und fügt ein Verzeichnistrennzeichen zwischen den beiden Pfadkomponenten hinzu, wenn eine noch nicht am Ende path1 oder am Anfang der path2vorhanden ist. Wenn die Length eines path1 oder path2 null ist, gibt die Methode den anderen Pfad zurück. Wenn die Length von path1 und path2 null ist, gibt die Methode String.Emptyzurück.

Wenn path1 auf ein 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 ("\") verwenden, der nicht als Pfadtrennzeichen auf Unix-basierten Systemen erkannt wird. Um dieses Problem zu umgehen, können Sie:

• Rufen Sie den Wert der Path.DirectorySeparatorChar-Eigenschaft ab, anstatt ein Verzeichnistrennzeichen fest 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.

Im Gegensatz zur Combine Methode versucht die Join-Methode nicht, den zurückgegebenen Pfad zu rooten. (Wenn path2 ein absoluter Pfad ist, verwirft die Join-Methode nicht path1 und gibt path2 zurück, wie die Combine Methode.) Das folgende Beispiel veranschaulicht den Unterschied in den Pfaden, die von den beiden Methoden zurückgegeben werden. Wenn die Quelle von path2 Benutzereingaben ist, ermöglicht die Combine Methode, dass ein Benutzer auf eine Dateisystemressource (z. B. C:/Users/User1/Documents/Financial/ im Fall des Beispiels) zugreifen kann, die die Anwendung nicht barrierefrei 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 Such-Wildcardzeichen verwenden können. Wenn beispielsweise Path.Join("c:\\", "*.txt") beim Erstellen einer Datei ungültig sein kann, ist sie als Suchzeichenfolge gültig. Die Join Methode interpretiert sie daher erfolgreich.

Weitere Informationen

• Dateiformate auf Windows-Systemen

Join(String[])

Quelle:

Path.cs

Verkettet ein Array von Pfaden in einen 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, wenn noch nicht vorhanden ist. Wenn die Length eines der Pfade in paths null ist, verkettet die Methode die verbleibenden Argumente. Wenn die resultierende Länge der verketteten Zeichenfolge null ist, gibt die Methode String.Emptyzurück.

Wenn eines der Pfade in pathsmit Ausnahme des letzten Pfads auf ein 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 ("\") verwenden, der nicht als Pfadtrennzeichen auf Unix-basierten Systemen erkannt wird. Um dieses Problem zu umgehen, können Sie:

• Rufen Sie den Wert der Path.DirectorySeparatorChar-Eigenschaft ab, anstatt ein Verzeichnistrennzeichen fest 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.

Im Gegensatz zur Combine Methode versucht die Join-Methode nicht, den zurückgegebenen Pfad zu rooten. (Wenn einer der Pfade in paths, mit Ausnahme des ersten Pfads, ein absoluter Pfad ist, verwirft die Join-Methode nicht die vorherigen Pfade, 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 Such-Wildcardzeichen verwenden können. Wenn beispielsweise Path.Join("c:\\", "temp", "*.txt") beim Erstellen einer Datei ungültig sein kann, ist sie als Suchzeichenfolge gültig. Die Join Methode interpretiert sie daher erfolgreich.

Join(String, String)

Quelle:

Path.cs

Verkettet zwei Pfade in einem einzigen 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 Zutrittspfad.

path2

String

Der zweite Zutrittspfad.

Gibt zurück

String

Der verkettete Pfad.

Hinweise

Diese Methode verkettet einfach path und path2 und fügt ein Verzeichnistrennzeichen zwischen einer der Pfadkomponenten hinzu, wenn noch nicht vorhanden ist. Wenn die Länge eines path1 oder path2 null ist, verkettet die Methode das verbleibende Argument. Wenn die Länge der resultierenden verketteten Zeichenfolge null ist, gibt die Methode String.Emptyzurück.

Wenn path1 auf ein 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 ("\") verwenden, der nicht als Pfadtrennzeichen auf Unix-basierten Systemen erkannt wird. Um dieses Problem zu umgehen, können Sie:

• Rufen Sie den Wert der Path.DirectorySeparatorChar-Eigenschaft ab, anstatt ein Verzeichnistrennzeichen fest 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.

Im Gegensatz zur Combine Methode versucht die Join-Methode nicht, den zurückgegebenen Pfad zu rooten. (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 Such-Wildcardzeichen verwenden können. Wenn beispielsweise Path.Join("c:\\", "temp", "*.txt") beim Erstellen einer Datei ungültig sein kann, ist sie als Suchzeichenfolge gültig. Die Join Methode interpretiert sie daher erfolgreich.