Path.Join Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Ü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
- Quelle:
- Path.cs
- 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
Der verkettete Pfad.
Hinweise
Diese Methode verkettet path
einfach , path2
und path3
path4
fügt ein Verzeichnistrennzeichen zwischen einer der Pfadkomponenten hinzu, sofern noch keine vorhanden ist. Wenn die Länge eines der path1
Argumente , path2
path3
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 path3
path2
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 path4
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.
Gilt für:
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)
- Quelle:
- Path.cs
- Quelle:
- Path.cs
- 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
Der verkettete Pfad.
Hinweise
Diese Methode verkettet path
einfach , path2
und path3
path4
fügt ein Verzeichnistrennzeichen zwischen einer der Pfadkomponenten hinzu, sofern noch keine vorhanden ist. Wenn das von Length einem der path1
Argumente , path3
path2
oder 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 path3
path2
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 path4
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.
Gilt für:
Join(String, String, String)
- Quelle:
- Path.cs
- Quelle:
- Path.cs
- 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
Der verkettete Pfad.
Hinweise
Diese Methode verkettet path
einfach , path2
und path3
fügt ein Verzeichnistrennzeichen zwischen einer der Pfadkomponenten hinzu, sofern noch keine vorhanden ist. Wenn die Länge eines der path1
Argumente oder path2
path3
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.
Gilt für:
Join(String[])
- Quelle:
- Path.cs
- Quelle:
- Path.cs
- 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
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 paths
Ausnahme 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 paths
Ausnahme 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.
Gilt für:
Join(String, String)
- Quelle:
- Path.cs
- Quelle:
- Path.cs
- 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
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 es sich um path2
einen absoluten Pfad handelt, 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. Path.Join("c:\\", "temp", "*.txt")
Beispielsweise kann beim Erstellen einer Datei möglicherweise ungültig sein, sie ist aber als Suchzeichenfolge gültig. Die Join
Methode interpretiert sie daher erfolgreich.
Gilt für:
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)
- Quelle:
- Path.cs
- Quelle:
- Path.cs
- 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
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, führen die beiden Methoden zu identischen Ergebnissen. Beim zweiten und dritten Aufruf der ShowPathInformation
-Methode unterscheiden sich die von den beiden Methoden zurückgegebenen Zeichenfolgen. Beim zweiten Methodenaufruf ist das erste Zeichenfolgenargument ein Laufwerk, während das zweite ein rootes Verzeichnis ist. Die Join
-Methode verkettet die beiden Zeichenfolgen und behält doppelte Pfadtrennzeichen bei. Die Combine
-Methode verlässt das Laufwerk und gibt ein rootes Verzeichnis auf dem aktuellen Laufwerk zurück. Wenn das aktuelle Laufwerk der Anwendung C:\ ist 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 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 ermöglichen.
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
fügt ein Verzeichnistrennzeichen zwischen den beiden Pfadkomponenten hinzu, wenn am Ende oder Am Anfang von path1
path2
nicht bereits ein Verzeichnistrennzeichen vorhanden ist. Wenn der Length von oder path1
path2
null ist, gibt die Methode den anderen Pfad zurück. Wenn der Length von und path1
path2
0 ist, gibt die -Methode zurück String.Empty.
Wenn path1
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 Windows-Schrägstrich ("\") verwenden, der auf Unix-basierten Systemen nicht als Pfadtrennzeichen erkannt wird. Um dieses Problem zu umgehen, können Sie Folgendes ausführen:
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 es sich um path2
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:/Benutzer/Benutzer1/Dokumente/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. Path.Join("c:\\", "*.txt")
Beispielsweise kann beim Erstellen einer Datei möglicherweise ungültig sein, sie ist aber als Suchzeichenfolge gültig. Die Join
Methode interpretiert sie daher erfolgreich.
Weitere Informationen
Gilt für:
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)
- Quelle:
- Path.cs
- Quelle:
- Path.cs
- 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
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, führen die beiden Methoden zu identischen Ergebnissen. Beim zweiten und dritten Aufruf der ShowPathInformation
-Methode unterscheiden sich die von den beiden Methoden zurückgegebenen Zeichenfolgen. Beim zweiten Methodenaufruf ist das erste Zeichenfolgenargument ein Laufwerk, während das 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 verlässt das Laufwerk und gibt ein rootes Verzeichnis auf dem aktuellen Laufwerk zurück. Wenn das aktuelle Laufwerk der Anwendung C:\ ist 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 schließlich das letzte Argument im dritten Aufruf von ShowPathInformation
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 ermöglichen.
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 path
einfach , path2
und path3
fügt ein Verzeichnistrennzeichen zwischen einer der Pfadkomponenten hinzu, wenn noch keins vorhanden ist. Wenn eines Length der path1
Argumente , path2
oder path3
00 ist, verkettet die -Methode die verbleibenden Argumente. Wenn die ReadOnlySpan<T>.Length aller Komponenten 0 ist, gibt die -Methode zurück String.Empty.
Wenn path1
oder path2
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 Windows-Schrägstrich ("\") verwenden, der auf Unix-basierten Systemen nicht als Pfadtrennzeichen erkannt wird. Um dieses Problem zu umgehen, können Sie Folgendes ausführen:
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. Path.Join("c:\\", "temp", "*.txt")
Beispielsweise kann beim Erstellen einer Datei möglicherweise ungültig sein, sie ist aber als Suchzeichenfolge gültig. Die Join
Methode interpretiert sie daher erfolgreich.
Weitere Informationen
Gilt für:
Feedback
https://aka.ms/ContentUserFeedback.
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unterFeedback senden und anzeigen für