Path.Join Metoda

Reference

Definice

Obor názvů:: System.IO

Sestavení:: System.Runtime.dll

Sestavení:: System.Runtime.Extensions.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Přetížení

Join(String, String, String, String)	Zřetězí čtyři cesty do jedné cesty.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Zřetězí čtyři komponenty cesty do jedné cesty.
Join(String, String, String)	Zřetězí tři cesty do jedné cesty.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Zřetězí tři komponenty cesty do jedné cesty.
Join(ReadOnlySpan<String>)	Zřetězí rozsah cest do jedné cesty.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Zřetězí dvě komponenty cesty do jedné cesty.
Join(String[])	Zřetězí pole cest do jedné cesty.
Join(String, String)	Zřetězí dvě cesty do jedné cesty.

Join(String, String, String, String)

Zdroj:: Path.cs

Zdroj:: Path.cs

Zdroj:: Path.cs

Zřetězí čtyři cesty do jedné cesty.

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

Parametry

path1: String

První cesta, ke které se chcete připojit.

path2: String

Druhá cesta, která se má spojit.

path3: String

Třetí cesta, ke které se chcete připojit.

path4: String

Čtvrtá cesta, která se má spojit.

Návraty

String

Zřetězená cesta.

Poznámky

Tato metoda jednoduše zřetězí path, path2, path3 a path4 a přidá znak oddělovače adresáře mezi některou z komponent cesty, pokud ještě není k dispozici. Pokud je délka některého z path1, path2, path3 nebo path4 argument nula, metoda zřetězí zbývající argumenty. Pokud je délka výsledného zřetězeného řetězce nula, metoda vrátí String.Empty.

Pokud path1 nebo path2 nebo path3 končí znakem oddělovače cest, který není vhodný pro cílovou platformu, metoda Join zachová původní znak oddělovače cesty a připojí podporovaný znak. K tomuto problému dochází v pevně zakódovaných cestách, které používají znak zpětného lomítka systému Windows (\), který není rozpoznán jako oddělovač cest v systémech Unix. Pokud chcete tento problém vyřešit, můžete:

Místo pevného kódování znaku oddělovače adresáře načtěte hodnotu vlastnosti Path.DirectorySeparatorChar.
Jako znak oddělovače adresáře použijte lomítko ("/"). Tento znak je vrácen vlastností Path.DirectorySeparatorChar v systémech Unix a vlastností Path.AltDirectorySeparatorChar v systémech Windows.

Na rozdíl od metody Combine se metoda Join nepokoušá o kořen vrácenou cestu. (To znamená, že pokud path2 nebo path3 nebo path4 je absolutní cesta, metoda Join nezahodí předchozí cesty, jak to dělá metoda Combine.)

Ne všechny neplatné znaky pro názvy adresářů a souborů jsou interpretovány jako nepřijatelné metodou Join, protože tyto znaky můžete použít pro vyhledávání zástupných znaků. Když například Path.Join("c:\\", "temp", "*.txt") může být při vytváření souboru neplatný, je platný jako hledaný řetězec. Metoda Join ji proto úspěšně interpretuje.

Platí pro

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

Zdroj:: Path.cs

Zdroj:: Path.cs

Zdroj:: Path.cs

Zřetězí čtyři komponenty cesty do jedné cesty.

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

Parametry

path1: ReadOnlySpan<Char>

Rozsah znaků, který obsahuje první cestu ke spojení.

path2: ReadOnlySpan<Char>

Rozsah znaků, který obsahuje druhou cestu ke spojení.

path3: ReadOnlySpan<Char>

Rozsah znaků, který obsahuje třetí cestu ke spojení.

path4: ReadOnlySpan<Char>

Rozsah znaků, který obsahuje čtvrtou cestu ke spojení.

Návraty

String

Zřetězená cesta.

Poznámky

Tato metoda jednoduše zřetězí path, path2, path3 a path4 a přidá znak oddělovače adresáře mezi některou z komponent cesty, pokud ještě není k dispozici. Pokud je Length některého z path1, path2, path3 nebo path4 argumentu nula, metoda zřetězí zbývající argumenty. Pokud je ReadOnlySpan<T>.Length všech komponent nula, vrátí metoda String.Empty.

Místo pevného kódování znaku oddělovače adresáře načtěte hodnotu vlastnosti Path.DirectorySeparatorChar.
Jako znak oddělovače adresáře použijte lomítko ("/"). Tento znak je vrácen vlastností Path.DirectorySeparatorChar v systémech Unix a vlastností Path.AltDirectorySeparatorChar v systémech Windows.

Platí pro

Join(String, String, String)

Zdroj:: Path.cs

Zdroj:: Path.cs

Zdroj:: Path.cs

Zřetězí tři cesty do jedné cesty.

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

Parametry

path1: String

První cesta, ke které se chcete připojit.

path2: String

Druhá cesta, která se má spojit.

path3: String

Třetí cesta, ke které se chcete připojit.

Návraty

String

Zřetězená cesta.

Poznámky

Tato metoda jednoduše zřetězí path, path2a path3 a přidá znak oddělovače adresáře mezi některou z komponent cesty, pokud ještě není k dispozici. Pokud je délka některého z path1, path2 nebo path3 argument nula, metoda zřetězí zbývající argumenty. Pokud je délka výsledného zřetězeného řetězce nula, metoda vrátí String.Empty.

Pokud path1 nebo path2 končí znak oddělovače cesty, který není vhodný pro cílovou platformu, metoda Join zachová původní znak oddělovače cesty a připojí podporovaný znak. K tomuto problému dochází v pevně zakódovaných cestách, které používají znak zpětného lomítka systému Windows (\), který není rozpoznán jako oddělovač cest v systémech Unix. Pokud chcete tento problém vyřešit, můžete:

Místo pevného kódování znaku oddělovače adresáře načtěte hodnotu vlastnosti Path.DirectorySeparatorChar.
Jako znak oddělovače adresáře použijte lomítko ("/"). Tento znak je vrácen vlastností Path.DirectorySeparatorChar v systémech Unix a vlastností Path.AltDirectorySeparatorChar v systémech Windows.

Na rozdíl od metody Combine se metoda Join nepokoušá o kořen vrácenou cestu. (To znamená, že pokud path2 nebo path3 je absolutní cesta, metoda Join nezahodí předchozí cesty, jak to dělá metoda Combine.)

Platí pro

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

Zdroj:: Path.cs

Zdroj:: Path.cs

Zdroj:: Path.cs

Zřetězí tři komponenty cesty do jedné cesty.

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

Parametry

path1: ReadOnlySpan<Char>

Rozsah znaků, který obsahuje první cestu ke spojení.

path2: ReadOnlySpan<Char>

Rozsah znaků, který obsahuje druhou cestu ke spojení.

path3: ReadOnlySpan<Char>

Rozsah znaků, který obsahuje třetí cestu ke spojení.

Návraty

String

Zřetězená cesta.

Příklady

Následující příklad ukazuje rozdíl v cestách vrácených Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) a Path.Combine(String, String, String) metodami. Pokud je první řetězec plně kvalifikovaná cesta, která obsahuje jednotku a kořenový adresář a druhá je relativní cesta z první cesty, tyto dvě metody vytvoří identické výsledky. Ve druhém a třetím volání metody ShowPathInformation se řetězce vrácené dvěma metodami liší. Ve druhém volání metody je prvním řetězcovým argumentem jednotka, zatímco druhý je kořenový adresář. Metoda Join zřetězí dva řetězce a zachová duplicitní oddělovače cest. Volání metody GetFullPath by eliminovalo duplikaci. Metoda Combine disk opustí a vrátí kořenový adresář na aktuální jednotce. Pokud je aktuální jednotka aplikace C:\ a řetězec se používá pro přístup k souboru nebo souborům v adresáři, bude přistupovat k jazyku C: místo D:. A konečně, protože poslední argument ve třetím volání ShowPathInformation jsou rootovány, metoda Join ji jednoduše připojí k prvním dvěma argumentům a vytvoří nesmyslnou cestu k souboru, zatímco metoda Combine zahodí první dva řetězce a vrátí třetí. Použití tohoto řetězce pro přístup k souborům by mohlo aplikaci udělit nezamýšlený přístup k citlivým souborům.

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'

Poznámky

Tato metoda jednoduše zřetězí path, path2a path3 a přidá znak oddělovače adresáře mezi některou z komponent cesty, pokud ještě není k dispozici. Pokud je Length některého z path1, path2nebo path3 argumentů nula, metoda zřetězí zbývající argumenty. Pokud je ReadOnlySpan<T>.Length všech komponent nula, vrátí metoda String.Empty.

Místo pevného kódování znaku oddělovače adresáře načtěte hodnotu vlastnosti Path.DirectorySeparatorChar.
Jako znak oddělovače adresáře použijte lomítko ("/"). Tento znak je vrácen vlastností Path.DirectorySeparatorChar v systémech Unix a vlastností Path.AltDirectorySeparatorChar v systémech Windows.

Viz také

formáty cest k souborům v systémech Windows

Platí pro

Join(ReadOnlySpan<String>)

Zřetězí rozsah cest do jedné cesty.

public:
 static System::String ^ Join(ReadOnlySpan<System::String ^> paths);

public static string Join (scoped ReadOnlySpan<string?> paths);

static member Join : ReadOnlySpan<string> -> string

Public Shared Function Join (paths As ReadOnlySpan(Of String)) As String

Parametry

paths: ReadOnlySpan<String>

Rozsah cest.

Návraty

String

Zřetězená cesta.

Platí pro

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

Zdroj:: Path.cs

Zdroj:: Path.cs

Zdroj:: Path.cs

Zřetězí dvě komponenty cesty do jedné cesty.

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

Parametry

path1: ReadOnlySpan<Char>

Rozsah znaků, který obsahuje první cestu ke spojení.

path2: ReadOnlySpan<Char>

Rozsah znaků, který obsahuje druhou cestu ke spojení.

Návraty

String

Kombinované cesty.

Příklady

Následující příklad ukazuje rozdíl v cestách vrácených Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) a Path.Combine(String, String) metodami. Pokud je první řetězec plně kvalifikovaná cesta, která obsahuje jednotku a kořenový adresář a druhá je relativní cesta z první cesty, tyto dvě metody vytvoří identické výsledky. Ve druhém a třetím volání metody ShowPathInformation se řetězce vrácené dvěma metodami liší. Ve druhém volání metody je prvním řetězcovým argumentem jednotka, zatímco druhý je kořenový adresář. Metoda Join zřetězí dva řetězce a zachová duplicitní oddělovače cest. Metoda Combine disk opustí a vrátí kořenový adresář na aktuální jednotce. Pokud je aktuální jednotka aplikace C:\ a řetězec se používá pro přístup k souboru nebo souborům v adresáři, bude přistupovat k jazyku C: místo D:. A konečně, protože oba argumenty ve třetím volání ShowPathInformation jsou rootovány, metoda Join je jednoduše připojí k vytvoření nesmyslné cesty k souboru, zatímco Combine metoda zahodí první řetězec a vrátí druhou. Použití tohoto řetězce pro přístup k souborům by mohlo aplikaci udělit nezamýšlený přístup k citlivým souborům.

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

Poznámky

Tato metoda jednoduše zřetězí path a path2 a přidá znak oddělovače adresáře mezi dvě součásti cesty, pokud jeden ještě není na konci path1 nebo začátek path2. Pokud je Lengthpath1 nebo path2 nula, vrátí metoda druhou cestu. Pokud je Lengthpath1 i path2 nula, vrátí metoda String.Empty.

Pokud path1 končí znakem oddělovače cest, který není vhodný pro cílovou platformu, metoda Join zachová původní znak oddělovače cest a připojí podporovaný znak. K tomuto problému dochází v pevně zakódovaných cestách, které používají znak zpětného lomítka systému Windows (\), který není rozpoznán jako oddělovač cest v systémech Unix. Pokud chcete tento problém vyřešit, můžete:

Místo pevného kódování znaku oddělovače adresáře načtěte hodnotu vlastnosti Path.DirectorySeparatorChar.
Jako znak oddělovače adresáře použijte lomítko ("/"). Tento znak je vrácen vlastností Path.DirectorySeparatorChar v systémech Unix a vlastností Path.AltDirectorySeparatorChar v systémech Windows.

Na rozdíl od metody Combine se metoda Join nepokoušá o kořen vrácenou cestu. (To znamená, že pokud je path2 absolutní cestou, metoda Join nezahodí path1 a vrátí path2 jako metoda Combine.) Následující příklad znázorňuje rozdíl v cestách vrácených dvěma metodami. Pokud je zdrojem path2 uživatelský vstup, Combine metoda umožňuje uživateli přístup k prostředku systému souborů (například C:/Users/User1/Documents/Financial/ v případě příkladu), že aplikace neměla v úmyslu zpřístupnit.

Ne všechny neplatné znaky pro názvy adresářů a souborů jsou interpretovány jako nepřijatelné metodou Join, protože tyto znaky můžete použít pro vyhledávání zástupných znaků. Když například Path.Join("c:\\", "*.txt") může být při vytváření souboru neplatný, je platný jako hledaný řetězec. Metoda Join ji proto úspěšně interpretuje.

Viz také

formáty cest k souborům v systémech Windows

Platí pro

Join(String[])

Zdroj:: Path.cs

Zdroj:: Path.cs

Zdroj:: Path.cs

Zřetězí pole cest do jedné cesty.

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

Parametry

paths: String[]

Pole cest.

Návraty

String

Zřetězená cesta.

Poznámky

Tato metoda jednoduše zřetězí všechny řetězce v paths a přidá znak oddělovače adresáře mezi některou z komponent cesty, pokud ještě není k dispozici. Pokud je Length některé z cest v paths nula, metoda zřetězí zbývající argumenty. Pokud je výsledná délka zřetězeného řetězce nula, vrátí metoda String.Empty.

Pokud některé z cest v paths, s výjimkou poslední, končí znak oddělovače cest, který není vhodný pro cílovou platformu, metoda Join zachová původní znak oddělovače cesty a připojí podporovaný znak. K tomuto problému dochází v pevně zakódovaných cestách, které používají znak zpětného lomítka systému Windows (\), který není rozpoznán jako oddělovač cest v systémech Unix. Pokud chcete tento problém vyřešit, můžete:

Místo pevného kódování znaku oddělovače adresáře načtěte hodnotu vlastnosti Path.DirectorySeparatorChar.
Jako znak oddělovače adresáře použijte lomítko ("/"). Tento znak je vrácen vlastností Path.DirectorySeparatorChar v systémech Unix a vlastností Path.AltDirectorySeparatorChar v systémech Windows.

Na rozdíl od metody Combine se metoda Join nepokoušá o kořen vrácenou cestu. (To znamená, že pokud některé z cest v paths, s výjimkou první cesty, je absolutní cesta, Join metoda nezahodí předchozí cesty jako Combine metoda.)

Platí pro

Join(String, String)

Zdroj:: Path.cs

Zdroj:: Path.cs

Zdroj:: Path.cs

Zřetězí dvě cesty do jedné cesty.

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

Parametry

path1: String

První cesta, ke které se chcete připojit.

path2: String

Druhá cesta, která se má spojit.

Návraty

String

Zřetězená cesta.

Poznámky

Tato metoda jednoduše zřetězí path a path2 a přidá znak oddělovače adresáře mezi některou z komponent cesty, pokud ještě není k dispozici. Pokud je délka path1 nebo path2 nula, metoda zřetězí zbývající argument. Pokud je délka výsledného zřetězeného řetězce nula, metoda vrátí String.Empty.

Místo pevného kódování znaku oddělovače adresáře načtěte hodnotu vlastnosti Path.DirectorySeparatorChar.
Jako znak oddělovače adresáře použijte lomítko ("/"). Tento znak je vrácen vlastností Path.DirectorySeparatorChar v systémech Unix a vlastností Path.AltDirectorySeparatorChar v systémech Windows.

Na rozdíl od metody Combine se metoda Join nepokoušá o kořen vrácenou cestu. (To znamená, že pokud je path2 absolutní cestou, metoda Join nezahodí předchozí cesty, jak to dělá metoda Combine.)

Platí pro

Sdílet prostřednictvím

Path.Join Metoda

Definice

Přetížení

Join(String, String, String, String)

Parametry

Návraty

Poznámky

Platí pro

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

Parametry

Návraty

Poznámky

Platí pro

Join(String, String, String)

Parametry

Návraty

Poznámky

Platí pro

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

Parametry

Návraty

Příklady

Poznámky

Viz také

Platí pro

Join(ReadOnlySpan<String>)

Parametry

Návraty

Platí pro

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

Parametry

Návraty

Příklady

Poznámky

Viz také

Platí pro

Join(String[])

Parametry

Návraty

Poznámky

Platí pro

Join(String, String)

Parametry

Návraty

Poznámky

Platí pro

Další materiály