Path.Join Path.Join Path.Join Path.Join Method

Definition

Überlädt

Join(String, String, String, String) Join(String, String, String, String) Join(String, String, String, String) Join(String, String, String, String)

Verkettet vier Pfade zu einem einzelnen Pfad.Concatenates four paths into a single path.

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

Verkettet vier Pfadkomponenten zu einem einzelnen Pfad.Concatenates four path components into a single path.

Join(String, String, String) Join(String, String, String) Join(String, String, String) Join(String, String, String)

Verkettet drei Pfade zu einem einzelnen Pfad.Concatenates three paths into a single path.

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

Verkettet zwei Pfadkomponenten zu einem einzigen Pfad.Concatenates two path components into a single path.

Join(String, String) Join(String, String) Join(String, String) Join(String, String)

Verkettet zwei Pfade zu einem einzelnen Pfad.Concatenates two paths into a single path.

Join(String[]) Join(String[]) Join(String[]) Join(String[])

Verkettet ein Array von Pfaden zu einem einzelnen Pfad.Concatenates an array of paths into a single path.

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

Verkettet drei Pfadkomponenten zu einem einzigen Pfad.Concatenates three path components into a single path.

Join(String, String, String, String) Join(String, String, String, String) Join(String, String, String, String) Join(String, String, String, String)

Verkettet vier Pfade zu einem einzelnen Pfad.Concatenates four paths into a single path.

public:
 static System::String ^ Join(System::String ^ path1, System::String ^ path2, System::String ^ path3, System::String ^ path4);
public static string Join (string path1, string path2, string path3, string path4);
static member Join : string * string * string * string -> string
Public Shared Function Join (path1 As String, path2 As String, path3 As String, path4 As String) As String

Parameter

path1
String String String String

Der erste Pfad für die Verknüpfung.The first path to join.

path2
String String String String

Der zweite Pfad für die Verknüpfung.The second path to join.

path3
String String String String

Der dritte Pfad für die Verknüpfung.The third path to join.

path4
String String String String

Der vierte Pfad für die Verknüpfung.The fourth path to join.

Gibt zurück

Der verkettete Pfad.The concatenated path.

Hinweise

Diese Methode verkettet einfach path, path2, path3 und path4 und fügt ein Verzeichnis Trennzeichen zwischen allen Pfad Komponenten hinzu, wenn noch keines vorhanden ist.This method simply concatenates path, path2, path3 and path4 and adds a directory separator character between any of the path components if one is not already present. Wenn die Länge eines path1-, path2-, path3-oder path4-Arguments 0 (null) ist, verkettet die Methode die restlichen Argumente.If the length of any of path1, path2, path3 or path4 argument is zero, the method concatenates the remaining arguments. Wenn die Länge der resultierenden verketteten Zeichenfolge 0 (null) ist, gibt die Methode String.Empty zurück.If the length of the resulting concatenated string is zero, the method returns String.Empty.

Wenn path1 oder path2 oder path3 in einem Pfad Trennzeichen endet, das für die Zielplattform nicht geeignet ist, behält die Join-Methode das ursprüngliche Pfad Trennzeichen bei und fügt das unterstützte ein.If path1 or path2 or path3 ends in a path separator character that is not appropriate for the target platform, the Join method preserves the original path separator character and appends the supported one. Dieses Problem tritt in hart codierten Pfaden auf, die den umgekehrten Schrägstrich ("")" von Windows verwenden, der nicht als Pfad Trennzeichen auf UNIX-basierten Systemen erkannt wird.This issue arises in hard-coded paths that use the Windows backslash ("") character, which is not recognized as a path separator on Unix-based systems. Um dieses Problem zu umgehen, können Sie folgende Aktionen ausführen:To work around this issue, you can:

Anders als bei der Combine-Methode versucht die Join-Methode nicht, den zurückgegebenen Pfad zu finden.Unlike the Combine method, the Join method does not attempt to root the returned path. (Das heißt, wenn path2 oder path2 oder path3 ein absoluter Pfad ist, werden die vorherigen Pfade von der Join-Methode nicht verworfen, wenn die Combine-Methode dies tut.(That is, if path2 or path2 or path3 is an absolute path, the Join method does not discard the previous paths as the Combine method does.

Nicht alle ungültigen Zeichen für Verzeichnis-und Dateinamen werden von der Join-Methode als unzulässig interpretiert, da Sie diese Zeichen für Such Platzhalter Zeichen verwenden können.Not all invalid characters for directory and file names are interpreted as unacceptable by the Join method, because you can use these characters for search wildcard characters. Wenn beispielsweise Path.Join("c:\\", "temp", "*.txt") beim Erstellen einer Datei ungültig sein kann, ist Sie als Such Zeichenfolge gültig.For example, while Path.Join("c:\\", "temp", "*.txt") might be invalid when creating a file, it is valid as a search string. Diese Methode wird von der Join-Methode daher erfolgreich interpretiert.The Join method therefore successfully interprets it.

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

Verkettet vier Pfadkomponenten zu einem einzelnen Pfad.Concatenates four path components into a single path.

public:
 static System::String ^ Join(ReadOnlySpan<char> path1, ReadOnlySpan<char> path2, ReadOnlySpan<char> path3, ReadOnlySpan<char> path4);
public static string Join (ReadOnlySpan<char> path1, ReadOnlySpan<char> path2, ReadOnlySpan<char> path3, ReadOnlySpan<char> path4);
static member Join : ReadOnlySpan<char> * ReadOnlySpan<char> * ReadOnlySpan<char> * ReadOnlySpan<char> -> string
Public Shared Function Join (path1 As ReadOnlySpan(Of Char), path2 As ReadOnlySpan(Of Char), path3 As ReadOnlySpan(Of Char), path4 As ReadOnlySpan(Of Char)) As String

Parameter

path1
ReadOnlySpan<Char>

Eine Zeichenspanne, die den ersten Pfad für die Verknüpfung enthält.A character span that contains the first path to join.

path2
ReadOnlySpan<Char>

Eine Zeichenspanne, die den zweiten Pfad für die Verknüpfung enthält.A character span that contains the second path to join.

path3
ReadOnlySpan<Char>

Eine Zeichenspanne, die den dritten Pfad für die Verknüpfung enthält.A character span that contains the third path to join.

path4
ReadOnlySpan<Char>

Eine Zeichenspanne, die den vierten zu verknüpfenden Pfad enthält.A character span that contains the fourth path to join.

Gibt zurück

Der verkettete Pfad.The concatenated path.

Hinweise

Diese Methode verkettet einfach path, path2, path3 und path4 und fügt ein Verzeichnis Trennzeichen zwischen allen Pfad Komponenten hinzu, wenn noch keines vorhanden ist.This method simply concatenates path, path2, path3 and path4 and adds a directory separator character between any of the path components if one is not already present. Wenn die Length eines path1-, path2-, path3-oder path4-Arguments 0 (null) ist, verkettet die Methode die restlichen Argumente.If the Length of any of path1, path2, path3 or path4 argument is zero, the method concatenates the remaining arguments. Wenn die @no__t 0 (null) aller Komponenten 0 (null) ist, gibt die Methode String.Empty zurück.If the ReadOnlySpan<T>.Length of all components is zero, the method returns String.Empty.

Wenn path1 oder path2 oder path3 in einem Pfad Trennzeichen endet, das für die Zielplattform nicht geeignet ist, behält die Join-Methode das ursprüngliche Pfad Trennzeichen bei und fügt das unterstützte ein.If path1 or path2 or path3 ends in a path separator character that is not appropriate for the target platform, the Join method preserves the original path separator character and appends the supported one. Dieses Problem tritt in hart codierten Pfaden auf, die den umgekehrten Schrägstrich ("")" von Windows verwenden, der nicht als Pfad Trennzeichen auf UNIX-basierten Systemen erkannt wird.This issue arises in hard-coded paths that use the Windows backslash ("") character, which is not recognized as a path separator on Unix-based systems. Um dieses Problem zu umgehen, können Sie folgende Aktionen ausführen:To work around this issue, you can:

Anders als bei der Combine-Methode versucht die Join-Methode nicht, den zurückgegebenen Pfad zu finden.Unlike the Combine method, the Join method does not attempt to root the returned path. (Das heißt, wenn path2 oder path2 oder path3 ein absoluter Pfad ist, werden die vorherigen Pfade von der Join-Methode nicht verworfen, wenn die Combine-Methode dies tut.(That is, if path2 or path2 or path3 is an absolute path, the Join method does not discard the previous paths as the Combine method does.

Nicht alle ungültigen Zeichen für Verzeichnis-und Dateinamen werden von der Join-Methode als unzulässig interpretiert, da Sie diese Zeichen für Such Platzhalter Zeichen verwenden können.Not all invalid characters for directory and file names are interpreted as unacceptable by the Join method, because you can use these characters for search wildcard characters. Wenn beispielsweise Path.Join("c:\\", "temp", "*.txt") beim Erstellen einer Datei ungültig sein kann, ist Sie als Such Zeichenfolge gültig.For example, while Path.Join("c:\\", "temp", "*.txt") might be invalid when creating a file, it is valid as a search string. Diese Methode wird von der Join-Methode daher erfolgreich interpretiert.The Join method therefore successfully interprets it.

Join(String, String, String) Join(String, String, String) Join(String, String, String) Join(String, String, String)

Verkettet drei Pfade zu einem einzelnen Pfad.Concatenates three paths into a single path.

public:
 static System::String ^ Join(System::String ^ path1, System::String ^ path2, System::String ^ path3);
public static string Join (string path1, string path2, string path3);
static member Join : string * string * string -> string
Public Shared Function Join (path1 As String, path2 As String, path3 As String) As String

Parameter

path1
String String String String

Der erste Pfad für die Verknüpfung.The first path to join.

path2
String String String String

Der zweite Pfad für die Verknüpfung.The second path to join.

path3
String String String String

Der dritte Pfad für die Verknüpfung.The third path to join.

Gibt zurück

Der verkettete Pfad.The concatenated path.

Hinweise

Diese Methode verkettet einfach path, path2 und path3 und fügt ein Verzeichnis Trennzeichen zwischen allen Pfad Komponenten hinzu, wenn noch keines vorhanden ist.This method simply concatenates path, path2, and path3 and adds a directory separator character between any of the path components if one is not already present. Wenn die Länge eines path1-, path2-oder path3-Arguments 0 (null) ist, verkettet die Methode die restlichen Argumente.If the length of any of path1, path2 or path3 argument is zero, the method concatenates the remaining arguments. Wenn die Länge der resultierenden verketteten Zeichenfolge 0 (null) ist, gibt die Methode String.Empty zurück.If the length of the resulting concatenated string is zero, the method returns String.Empty.

Wenn path1 oder path2 ein Pfad Trennzeichen endet, das für die Zielplattform nicht geeignet ist, behält die Join-Methode das ursprüngliche Pfad Trennzeichen bei und fügt das unterstützte ein.If path1 or path2 ends in a path separator character that is not appropriate for the target platform, the Join method preserves the original path separator character and appends the supported one. Dieses Problem tritt in hart codierten Pfaden auf, die den umgekehrten Schrägstrich ("")" von Windows verwenden, der nicht als Pfad Trennzeichen auf UNIX-basierten Systemen erkannt wird.This issue arises in hard-coded paths that use the Windows backslash ("") character, which is not recognized as a path separator on Unix-based systems. Um dieses Problem zu umgehen, können Sie folgende Aktionen ausführen:To work around this issue, you can:

Anders als bei der Combine-Methode versucht die Join-Methode nicht, den zurückgegebenen Pfad zu finden.Unlike the Combine method, the Join method does not attempt to root the returned path. (Das heißt, wenn path2 oder path2 ein absoluter Pfad ist, werden die vorherigen Pfade von der Join-Methode nicht verworfen, weil die Combine-Methode dies tut.(That is, if path2 or path2 is an absolute path, the Join method does not discard the previous paths as the Combine method does.

Nicht alle ungültigen Zeichen für Verzeichnis-und Dateinamen werden von der Join-Methode als unzulässig interpretiert, da Sie diese Zeichen für Such Platzhalter Zeichen verwenden können.Not all invalid characters for directory and file names are interpreted as unacceptable by the Join method, because you can use these characters for search wildcard characters. Wenn beispielsweise Path.Join("c:\\", "temp", "*.txt") beim Erstellen einer Datei ungültig sein kann, ist Sie als Such Zeichenfolge gültig.For example, while Path.Join("c:\\", "temp", "*.txt") might be invalid when creating a file, it is valid as a search string. Diese Methode wird von der Join-Methode daher erfolgreich interpretiert.The Join method therefore successfully interprets it.

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

Verkettet zwei Pfadkomponenten zu einem einzigen Pfad.Concatenates two path components into a single path.

public:
 static System::String ^ Join(ReadOnlySpan<char> path1, ReadOnlySpan<char> path2);
public static string Join (ReadOnlySpan<char> path1, ReadOnlySpan<char> path2);
static member Join : ReadOnlySpan<char> * ReadOnlySpan<char> -> string
Public Shared Function Join (path1 As ReadOnlySpan(Of Char), path2 As ReadOnlySpan(Of Char)) As String

Parameter

path1
ReadOnlySpan<Char>

Eine Zeichenspanne, die den ersten Pfad für die Verknüpfung enthält.A character span that contains the first path to join.

path2
ReadOnlySpan<Char>

Eine Zeichenspanne, die den zweiten Pfad für die Verknüpfung enthält.A character span that contains the second path to join.

Gibt zurück

Die kombinierten Pfade.The combined paths.

Hinweise

Diese Methode verkettet einfach path und path2 und fügt ein Verzeichnis Trennzeichen zwischen den beiden Pfad Komponenten hinzu, wenn noch nicht am Ende von path1 oder am Anfang path2 vorhanden ist.This method simply concatenates path and path2 and adds a directory separator character between the two path components if one is not already present at the end of path1 or the beginning of path2. Wenn die Length von path1 oder path2 0 (null) ist, gibt die Methode den anderen Pfad zurück.If the Length of either path1 or path2 is zero, the method returns the other path. Wenn die Length von path1 und path2 0 (null) ist, gibt die Methode String.Empty zurück.If the Length of both path1 and path2 is zero, the method returns String.Empty.

Wenn path1 mit einem Pfad Trennzeichen endet, das für die Zielplattform nicht geeignet ist, behält die Join-Methode das ursprüngliche Pfad Trennzeichen bei und fügt das unterstützte ein.If path1 ends in a path separator character that is not appropriate for the target platform, the Join method preserves the original path separator character and appends the supported one. Dieses Problem tritt in hart codierten Pfaden auf, die den umgekehrten Schrägstrich ("")" von Windows verwenden, der nicht als Pfad Trennzeichen auf UNIX-basierten Systemen erkannt wird.This issue arises in hard-coded paths that use the Windows backslash ("") character, which is not recognized as a path separator on Unix-based systems. Um dieses Problem zu umgehen, können Sie folgende Aktionen ausführen:To work around this issue, you can:

Anders als bei der Combine-Methode versucht die Join-Methode nicht, den zurückgegebenen Pfad zu finden.Unlike the Combine method, the Join method does not attempt to root the returned path. (Das heißt, wenn path2 ein absoluter Pfad ist, wird die Join-Methode nicht path1 verworfen und path2 zurückgegeben, wenn die Combine-Methode dies tut.) Das folgende Beispiel veranschaulicht den Unterschied in den Pfaden, die von den beiden Methoden zurückgegeben werden.(That is, if path2 is an absolute path, the Join method does not discard path1 and return path2 as the Combine method does.) The following example illustrates the difference in the paths returned by the two methods. Wenn die Quelle von path2 Benutzereingaben ist, ermöglicht die Combine-Methode einem Benutzer den Zugriff auf eine Dateisystem Ressource (z. b. C:/users/user1/Documents/Financial/ im Fall des Beispiels), auf die die Anwendung nicht zugreifen konnte.If the source of path2 is user input, the Combine method makes it possible for a user to access a file system resource (such as C:/Users/User1/Documents/Financial/ in the case of the example) that the application did not intend to make accessible.

Nicht alle ungültigen Zeichen für Verzeichnis-und Dateinamen werden von der Join-Methode als unzulässig interpretiert, da Sie diese Zeichen für Such Platzhalter Zeichen verwenden können.Not all invalid characters for directory and file names are interpreted as unacceptable by the Join method, because you can use these characters for search wildcard characters. Wenn beispielsweise Path.Join("c:\\", "*.txt") beim Erstellen einer Datei ungültig sein kann, ist Sie als Such Zeichenfolge gültig.For example, while Path.Join("c:\\", "*.txt") might be invalid when creating a file, it is valid as a search string. Diese Methode wird von der Join-Methode daher erfolgreich interpretiert.The Join method therefore successfully interprets it.

BeispielExample

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.The following example illustrates the difference in the paths returned by the Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) and Path.Combine(String, String) methods. Wenn die erste Zeichenfolge ein voll qualifizierter Pfad ist, der ein Laufwerk und ein Stammverzeichnis enthält und der zweite ein relativer Pfad vom ersten Pfad ist, führen die beiden Methoden zu identischen Ergebnissen.When the first string is an fully qualified path that includes a drive and root directory and the second is a relative path from the first path, the two methods produce identical results. In den zweiten und dritten Aufrufen der ShowPathInformation-Methode weichen die von den beiden Methoden zurückgegebenen Zeichen folgen ab.In the second and third calls to the ShowPathInformation method, the strings returned by the two methods diverge. Beim zweiten Methoden aufrufist das erste Zeichen folgen Argument ein Laufwerk, während das zweite ein Stammverzeichnis ist.In the second method call, the first string argument is a drive, while the second is a rooted directory. Die Join-Methode verkettet die beiden Zeichen folgen und bewahrt doppelte Pfad Trennzeichen auf.The Join method concatenates the two strings and preserves duplicate path separators. Mit der Combine-Methode wird das Laufwerk abgebrochen, und es wird ein Stammverzeichnis auf dem aktuellen Laufwerk zurückgegeben.The Combine method abandons the drive and returns a rooted directory on the current drive. Wenn das aktuelle Laufwerk der Anwendung C:\ ist und die Zeichenfolge wird für den Zugriff auf eine Datei oder auf Dateien im Verzeichnis verwendet. der Zugriff auf C: anstelle von d:.If the application's current drive is C:\ and the string is used to access a file or files in the directory, it would access C: instead of D:. Da beide Argumente im dritten ShowPathInformation-aufrufswert 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.Finally, because both arguments in the third call to ShowPathInformation are rooted, the Join method simply appends them to create a nonsensical file path, while the Combine method discards the first string and returns the second. Wenn diese Zeichenfolge für den Dateizugriff verwendet wird, kann die Anwendung unbeabsichtigten Zugriff auf sensible Dateien erhalten.Using this string for file access could give the application unintended access to sensitive files.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        var path1 = "C:/Program Files/";
        var path2 = "Utilities/SystemUtilities";
        ShowPathInformation(path1, path2);

        path1 = "C:/";
        path2 = "/Program Files";
        ShowPathInformation(path1, path2);

        path1 = "C:/Users/Public/Documents/";
        path2 = "C:/Users/User1/Documents/Financial/";
        ShowPathInformation(path1, path2);
    }

    private static void ShowPathInformation(string path1, string path2)
    {
        var result = Path.Join(path1.AsSpan(), path2.AsSpan());
        Console.WriteLine($"Concatenating  '{path1}' and '{path2}'");
        Console.WriteLine($"   Path.Join:     '{result}'");
        Console.WriteLine($"   Path.Combine:  '{Path.Combine(path1, path2)}'");
    }
}
// The example displays the following output if run on a Windows system:
//    Concatenating  'C:/Program Files/' and 'Utilities/SystemUtilities'
//       Path.Join:     'C:/Program Files/Utilities/SystemUtilities'
//       Path.Combine:  'C:/Program Files/Utilities/SystemUtilities'
//
//    Concatenating  'C:/' and '/Program Files'
//       Path.Join:     'C://Program Files'
//       Path.Combine:  '/Program Files'
//
//    Concatenating  'C:/Users/Public/Documents/' and 'C:/Users/User1/Documents/Financial/'
//       Path.Join:     'C:/Users/Public/Documents/C:/Users/User1/Documents/Financial/'
//       Path.Combine:  'C:/Users/User1/Documents/Financial/'

Imports System.IO

Module Example
    Public Sub Main()
        Dim path1 = "C:/Program Files/"
        Dim path2 = "Utilities/SystemUtilities"
        ShowPathInformation(path1, path2)

        path1 = "C:/"
        path2 = "/Program Files"
        ShowPathInformation(path1, path2)

        path1 = "C:/Users/Public/Documents/"
        path2 = "C:/Users/User1/Documents/Financial/"
        ShowPathInformation(path1, path2)
    End Sub

    Private Sub ShowPathInformation(path1 As String, path2 As String)
        Dim result = Path.Join(path1.AsSpan(), path2.AsSpan())
        Console.WriteLine($"Concatenating  '{path1}' and '{path2}'")
        Console.WriteLine($"   Path.Join:     '{result}'")
        Console.WriteLine($"   Path.Combine:  '{Path.Combine(path1, path2)}'")
        Console.WriteLine()
    End Sub
End Module
' The example displays the following output if run on a Windows system:
'    Concatenating  'C:/Program Files/' and 'Utilities/SystemUtilities'
'       Path.Join:     'C:/Program Files/Utilities/SystemUtilities'
'       Path.Combine:  'C:/Program Files/Utilities/SystemUtilities'
'
'    Concatenating  'C:/' and '/Program Files'
'       Path.Join:     'C:'Program Files'
'       Path.Combine:  '/Program Files'
'
'    Concatenating  'C:/Users/Public/Documents/' and 'C:/Users/User1/Documents/Financial/'
'       Path.Join:     'C:/Users/Public/Documents/C:/Users/User1/Documents/Financial/'
'       Path.Combine:  'C:/Users/User1/Documents/Financial/'

Siehe auch

Join(String, String) Join(String, String) Join(String, String) Join(String, String)

Verkettet zwei Pfade zu einem einzelnen Pfad.Concatenates two paths into a single path.

public:
 static System::String ^ Join(System::String ^ path1, System::String ^ path2);
public static string Join (string path1, string path2);
static member Join : string * string -> string
Public Shared Function Join (path1 As String, path2 As String) As String

Parameter

path1
String String String String

Der erste Pfad für die Verknüpfung.The first path to join.

path2
String String String String

Der zweite Pfad für die Verknüpfung.The second path to join.

Gibt zurück

Der verkettete Pfad.The concatenated path.

Hinweise

Diese Methode verkettet einfach path und path2 und fügt ein Verzeichnis Trennzeichen zwischen allen Pfad Komponenten hinzu, wenn noch keines vorhanden ist.This method simply concatenates path and path2 and adds a directory separator character between any of the path components if one is not already present. Wenn die Länge von path1 oder path2 NULL ist, verkettet die Methode das verbleibende Argument.If the length of either path1 or path2 is zero, the method concatenates the remaining argument. Wenn die Länge der resultierenden verketteten Zeichenfolge 0 (null) ist, gibt die Methode String.Empty zurück.If the length of the resulting concatenated string is zero, the method returns String.Empty.

Wenn path1 mit einem Pfad Trennzeichen endet, das für die Zielplattform nicht geeignet ist, behält die Join-Methode das ursprüngliche Pfad Trennzeichen bei und fügt das unterstützte ein.If path1 ends in a path separator character that is not appropriate for the target platform, the Join method preserves the original path separator character and appends the supported one. Dieses Problem tritt in hart codierten Pfaden auf, die den umgekehrten Schrägstrich ("")" von Windows verwenden, der nicht als Pfad Trennzeichen auf UNIX-basierten Systemen erkannt wird.This issue arises in hard-coded paths that use the Windows backslash ("") character, which is not recognized as a path separator on Unix-based systems. Um dieses Problem zu umgehen, können Sie folgende Aktionen ausführen:To work around this issue, you can:

Anders als bei der Combine-Methode versucht die Join-Methode nicht, den zurückgegebenen Pfad zu finden.Unlike the Combine method, the Join method does not attempt to root the returned path. (Das heißt, wenn path2 ein absoluter Pfad ist, werden die vorherigen Pfade von der Join-Methode nicht verworfen, wenn die Combine-Methode dies tut.(That is, if path2 is an absolute path, the Join method does not discard the previous paths as the Combine method does.

Nicht alle ungültigen Zeichen für Verzeichnis-und Dateinamen werden von der Join-Methode als unzulässig interpretiert, da Sie diese Zeichen für Such Platzhalter Zeichen verwenden können.Not all invalid characters for directory and file names are interpreted as unacceptable by the Join method, because you can use these characters for search wildcard characters. Wenn beispielsweise Path.Join("c:\\", "temp", "*.txt") beim Erstellen einer Datei ungültig sein kann, ist Sie als Such Zeichenfolge gültig.For example, while Path.Join("c:\\", "temp", "*.txt") might be invalid when creating a file, it is valid as a search string. Diese Methode wird von der Join-Methode daher erfolgreich interpretiert.The Join method therefore successfully interprets it.

Join(String[]) Join(String[]) Join(String[]) Join(String[])

Verkettet ein Array von Pfaden zu einem einzelnen Pfad.Concatenates an array of paths into a single path.

public:
 static System::String ^ Join(... cli::array <System::String ^> ^ paths);
public static string Join (params string[] paths);
static member Join : string[] -> string
Public Shared Function Join (ParamArray paths As String()) As String

Parameter

paths
String[]

Ein Array von Pfaden.An array of paths.

Gibt zurück

Der verkettete Pfad.The concatenated path.

Hinweise

Diese Methode verkettet einfach alle Zeichen folgen in paths und fügt ein Verzeichnis Trennzeichen zwischen allen Pfad Komponenten hinzu, wenn noch keines vorhanden ist.This method simply concatenates all the strings in paths and adds a directory separator character between any of the path components if one is not already present. Wenn die Length eines der Pfade in paths NULL ist, verkettet die Methode die restlichen Argumente.If the Length of any of the paths in paths is zero, the method concatenates the remaining arguments. Wenn die resultierende verketteten Zeichen folgen Länge 0 (null) ist, gibt die Methode String.Empty zurück.If the resulting concatenated string's length is zero, the method returns String.Empty.

Wenn einer der Pfade in paths, mit Ausnahme des letzten, mit einem Pfad Trennzeichen endet, das für die Zielplattform nicht geeignet ist, behält die Join-Methode das ursprüngliche Pfad Trennzeichen bei und fügt das unterstützte ein.If any of the paths in paths, except for the last one, ends in a path separator character that is not appropriate for the target platform, the Join method preserves the original path separator character and appends the supported one. Dieses Problem tritt in hart codierten Pfaden auf, die den umgekehrten Schrägstrich ("")" von Windows verwenden, der nicht als Pfad Trennzeichen auf UNIX-basierten Systemen erkannt wird.This issue arises in hard-coded paths that use the Windows backslash ("") character, which is not recognized as a path separator on Unix-based systems. Um dieses Problem zu umgehen, können Sie folgende Aktionen ausführen:To work around this issue, you can:

Anders als bei der Combine-Methode versucht die Join-Methode nicht, den zurückgegebenen Pfad zu finden.Unlike the Combine method, the Join method does not attempt to root the returned path. (Das heißt, wenn einer der Pfade in paths, mit Ausnahme des letzten, ein absoluter Pfad ist, werden die vorherigen Pfade von der Join-Methode nicht verworfen, wenn die Combine-Methode dies tut.(That is, if any of the paths in paths, except for the last one, is an absolute path, the Join method does not discard the previous paths as the Combine method does.

Nicht alle ungültigen Zeichen für Verzeichnis-und Dateinamen werden von der Join-Methode als unzulässig interpretiert, da Sie diese Zeichen für Such Platzhalter Zeichen verwenden können.Not all invalid characters for directory and file names are interpreted as unacceptable by the Join method, because you can use these characters for search wildcard characters. Wenn beispielsweise Path.Join("c:\\", "temp", "*.txt") beim Erstellen einer Datei ungültig sein kann, ist Sie als Such Zeichenfolge gültig.For example, while Path.Join("c:\\", "temp", "*.txt") might be invalid when creating a file, it is valid as a search string. Diese Methode wird von der Join-Methode daher erfolgreich interpretiert.The Join method therefore successfully interprets it.

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

Verkettet drei Pfadkomponenten zu einem einzigen Pfad.Concatenates three path components into a single path.

public:
 static System::String ^ Join(ReadOnlySpan<char> path1, ReadOnlySpan<char> path2, ReadOnlySpan<char> path3);
public static string Join (ReadOnlySpan<char> path1, ReadOnlySpan<char> path2, ReadOnlySpan<char> path3);
static member Join : ReadOnlySpan<char> * ReadOnlySpan<char> * ReadOnlySpan<char> -> string
Public Shared Function Join (path1 As ReadOnlySpan(Of Char), path2 As ReadOnlySpan(Of Char), path3 As ReadOnlySpan(Of Char)) As String

Parameter

path1
ReadOnlySpan<Char>

Eine Zeichenspanne, die den ersten Pfad für die Verknüpfung enthält.A character span that contains the first path to join.

path2
ReadOnlySpan<Char>

Eine Zeichenspanne, die den zweiten Pfad für die Verknüpfung enthält.A character span that contains the second path to join.

path3
ReadOnlySpan<Char>

Eine Zeichenspanne, die den dritten Pfad für die Verknüpfung enthält.A character span that contains the third path to join.

Gibt zurück

Der verkettete Pfad.The concatenated path.

Hinweise

Diese Methode verkettet einfach path, path2 und path3 und fügt ein Verzeichnis Trennzeichen zwischen allen Pfad Komponenten hinzu, wenn noch keines vorhanden ist.This method simply concatenates path, path2, and path3 and adds a directory separator character between any of the path components if one is not already present. Wenn die Length eines path1-, path2-oder path3-Arguments 0 (null) ist, verkettet die Methode die restlichen Argumente.If the Length of any of path1, path2, or path3 arguments is zero, the method concatenates the remaining arguments. Wenn die @no__t 0 (null) aller Komponenten 0 (null) ist, gibt die Methode String.Empty zurück.If the ReadOnlySpan<T>.Length of all components is zero, the method returns String.Empty.

Wenn path1 oder path2 ein Pfad Trennzeichen endet, das für die Zielplattform nicht geeignet ist, behält die Join-Methode das ursprüngliche Pfad Trennzeichen bei und fügt das unterstützte ein.If path1 or path2 ends in a path separator character that is not appropriate for the target platform, the Join method preserves the original path separator character and appends the supported one. Dieses Problem tritt in hart codierten Pfaden auf, die den umgekehrten Schrägstrich ("")" von Windows verwenden, der nicht als Pfad Trennzeichen auf UNIX-basierten Systemen erkannt wird.This issue arises in hard-coded paths that use the Windows backslash ("") character, which is not recognized as a path separator on Unix-based systems. Um dieses Problem zu umgehen, können Sie folgende Aktionen ausführen:To work around this issue, you can:

Anders als bei der Combine-Methode versucht die Join-Methode nicht, den zurückgegebenen Pfad zu finden.Unlike the Combine method, the Join method does not attempt to root the returned path. (Das heißt, wenn path2 oder path2 ein absoluter Pfad ist, werden die vorherigen Pfade von der Join-Methode nicht verworfen, weil die Combine-Methode dies tut.(That is, if path2 or path2 is an absolute path, the Join method does not discard the previous paths as the Combine method does.

Nicht alle ungültigen Zeichen für Verzeichnis-und Dateinamen werden von der Join-Methode als unzulässig interpretiert, da Sie diese Zeichen für Such Platzhalter Zeichen verwenden können.Not all invalid characters for directory and file names are interpreted as unacceptable by the Join method, because you can use these characters for search wildcard characters. Wenn beispielsweise Path.Join("c:\\", "temp", "*.txt") beim Erstellen einer Datei ungültig sein kann, ist Sie als Such Zeichenfolge gültig.For example, while Path.Join("c:\\", "temp", "*.txt") might be invalid when creating a file, it is valid as a search string. Diese Methode wird von der Join-Methode daher erfolgreich interpretiert.The Join method therefore successfully interprets it.

BeispielExample

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.The following example illustrates the difference in the paths returned by the Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) and Path.Combine(String, String, String) methods. Wenn die erste Zeichenfolge ein voll qualifizierter Pfad ist, der ein Laufwerk und ein Stammverzeichnis enthält und der zweite ein relativer Pfad vom ersten Pfad ist, führen die beiden Methoden zu identischen Ergebnissen.When the first string is a fully qualified path that includes a drive and root directory and the second is a relative path from the first path, the two methods produce identical results. In den zweiten und dritten Aufrufen der ShowPathInformation-Methode weichen die von den beiden Methoden zurückgegebenen Zeichen folgen ab.In the second and third calls to the ShowPathInformation method, the strings returned by the two methods diverge. Beim zweiten Methoden aufrufist das erste Zeichen folgen Argument ein Laufwerk, während das zweite ein Stammverzeichnis ist.In the second method call, the first string argument is a drive, while the second is a rooted directory. Die Join-Methode verkettet die beiden Zeichen folgen und bewahrt doppelte Pfad Trennzeichen auf.The Join method concatenates the two strings and preserves duplicate path separators. Durch einen aufzurufenden GetFullPath-Methode wird die Duplizierung vermieden.A call to the GetFullPath method would eliminate the duplication. Mit der Combine-Methode wird das Laufwerk abgebrochen, und es wird ein Stammverzeichnis auf dem aktuellen Laufwerk zurückgegeben.The Combine method abandons the drive and returns a rooted directory on the current drive. Wenn das aktuelle Laufwerk der Anwendung C:\ ist und die Zeichenfolge wird für den Zugriff auf eine Datei oder auf Dateien im Verzeichnis verwendet. der Zugriff auf C: anstelle von d:.If the application's current drive is C:\ and the string is used to access a file or files in the directory, it would access C: instead of D:. Da das letzte Argument im dritten ShowPathInformation-aufrufswert ist, 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 Zeichen folgen verwirft und die dritte zurückgibt.Finally, because the final argument in the third call to ShowPathInformation are rooted, the Join method simply appends it to the first two arguments to create a nonsensical file path, while the Combine method discards the first two strings and returns the third. Wenn diese Zeichenfolge für den Dateizugriff verwendet wird, kann die Anwendung unbeabsichtigten Zugriff auf sensible Dateien erhalten.Using this string for file access could give the application unintended access to sensitive files.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string path1 = "C:/";
        string path2 = "users/user1/documents";
        string path3 = "letters";
        ShowPathInformation(path1, path2, path3);
        
        path1 = "D:/";
        path2 =  "/users/user1/documents";
        path3 = "letters";
        ShowPathInformation(path1, path2, path3);

        path1 = "D:/";
        path2 =  "users/user1/documents";
        path3 = "C:/users/user1/documents/data";
        ShowPathInformation(path1, path2, path3);
    }

   private static void ShowPathInformation(string path1, string path2, string path3)
    {
        var result = Path.Join(path1.AsSpan(), path2.AsSpan(), path3.AsSpan());
        Console.WriteLine($"Concatenating  '{path1}, '{path2}', and `{path3}'");
        Console.WriteLine($"   Path.Join:     '{result}'");
        Console.WriteLine($"   Path.Combine:  '{Path.Combine(path1, path2, path3)}'");
        Console.WriteLine($"   {Path.GetFullPath(result)}");
    }
}
// The example displays the following output if run on a Windows system:
//   Concatenating  'C:/, 'users/user1/documents', and `letters'
//      Path.Join:     'C:/users/user1/documents\letters'
//      Path.Combine:  'C:/users/user1/documents\letters'
//
//   Concatenating  'D:/, '/users/user1/documents', and `letters'
//      Path.Join:     'D://users/user1/documents\letters'
//      Path.Combine:  '/users/user1/documents\letters'
//
//   Concatenating  'D:/, 'users/user1/documents', and `C:/users/user1/documents/data'
//      Path.Join:     'D:/users/user1/documents\C:/users/user1/documents/data'
//      Path.Combine:  'C:/users/user1/documents/data'
Imports System.IO

Module Program
    Public Sub Main()
        Dim path1 As String = "C:/"
        Dim path2 As String = "users/user1/documents"
        Dim path3 As String = "letters"
        ShowPathInformation(path1, path2, path3)
        
        path1 = "D:/"
        path2 =  "/users/user1/documents"
        path3 = "letters"
        ShowPathInformation(path1, path2, path3)

        path1 = "D:/"
        path2 =  "users/user1/documents"
        path3 = "C:/users/user1/documents/data"
        ShowPathInformation(path1, path2, path3)
    End Sub

   Private Sub ShowPathInformation(path1 As String, path2 As String, path3 As String)
        Dim result = Path.Join(path1.AsSpan(), path2.AsSpan(), path3.AsSpan())
        Console.WriteLine($"Concatenating  '{path1}, '{path2}', and `{path3}'")
        Console.WriteLine($"   Path.Join:     '{result}'")
        Console.WriteLine($"   Path.Combine:  '{Path.Combine(path1, path2, path3)}'")
    End Sub
End Module
' The example displays the following output if run on a Windows system:
'   Concatenating  'C:/, 'users/user1/documents', and `letters'
'      Path.Join:     'C:/users/user1/documents\letters'
'      Path.Combine:  'C:/users/user1/documents\letters'
'
'   Concatenating  'D:/, '/users/user1/documents', and `letters'
'      Path.Join:     'D:'users/user1/documents\letters'
'      Path.Combine:  '/users/user1/documents\letters'
'
'   Concatenating  'D:/, 'users/user1/documents', and `C:/users/user1/documents/data'
'      Path.Join:     'D:/users/user1/documents\C:/users/user1/documents/data'
'      Path.Combine:  'C:/users/user1/documents/data'
 
Siehe auch

Gilt für: