Path.Join Metoda

Definice

Obor názvů:

System.IO

Sestavení:

netstandard.dll, System.Runtime.dll

Přetížení

Name	Description
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

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í pathznak a path4path2path3 přidá znak oddělovače adresáře mezi libovolnou z komponent cesty, pokud ještě není k dispozici. Pokud je délka některého z argumentů path1, path2path3 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, vrátí String.Emptymetoda .

Pokud path1 nebo path2 končí path3 znak oddělovače cest, který není vhodný pro cílovou platformu, Join metoda 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 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 Path.DirectorySeparatorChar vlastnosti.

• Jako znak oddělovače adresáře použijte lomítko ("/"). Tento znak vrátí vlastnost Path.DirectorySeparatorChar v systémech unix a vlastnost Path.AltDirectorySeparatorChar v systémech Windows.

Combine Na rozdíl od metody se Join metoda nepokusí kořenit vrácenou cestu. (To znamená, že pokud path2 nebo path3 je path4 absolutní cestou, Join metoda nezahodí předchozí cesty jako Combine metoda.)

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ů. I když Path.Join("c:\\", "temp", "*.txt") může být například při vytváření souboru neplatný, je platný jako hledaný řetězec. Metoda Join ji proto úspěšně interpretuje.

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

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í pathznak a path4path2path3 přidá znak oddělovače adresáře mezi libovolnou z komponent cesty, pokud ještě není k dispozici. Length Pokud některý z path1, path2path3 nebo path4 argument je nula, metoda zřetězí zbývající argumenty. ReadOnlySpan<T>.Length Pokud je všechny komponenty nula, metoda vrátí String.Empty.

Pokud path1 nebo path2 končí path3 znak oddělovače cest, který není vhodný pro cílovou platformu, Join metoda 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 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 Path.DirectorySeparatorChar vlastnosti.

• Jako znak oddělovače adresáře použijte lomítko ("/"). Tento znak vrátí vlastnost Path.DirectorySeparatorChar v systémech unix a vlastnost Path.AltDirectorySeparatorChar v systémech Windows.

Combine Na rozdíl od metody se Join metoda nepokusí kořenit vrácenou cestu. (To znamená, že pokud path2 nebo path3 je path4 absolutní cestou, Join metoda nezahodí předchozí cesty jako Combine metoda.)

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ů. I když Path.Join("c:\\", "temp", "*.txt") může být například při vytváření souboru neplatný, je platný jako hledaný řetězec. Metoda Join ji proto úspěšně interpretuje.

Join(String, String, String)

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í pathznak a path2path3přidá znak oddělovače adresáře mezi libovolnou z komponent cesty, pokud ještě není k dispozici. Pokud je délka některého z argumentů path1nebo path2path3 argument nula, metoda zřetězí zbývající argumenty. Pokud je délka výsledného zřetězeného řetězce nula, vrátí String.Emptymetoda .

Pokud path1 nebo path2 končí znak oddělovače cesty, který není vhodný pro cílovou platformu, Join metoda 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 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 Path.DirectorySeparatorChar vlastnosti.

• Jako znak oddělovače adresáře použijte lomítko ("/"). Tento znak vrátí vlastnost Path.DirectorySeparatorChar v systémech unix a vlastnost Path.AltDirectorySeparatorChar v systémech Windows.

Combine Na rozdíl od metody se Join metoda nepokusí kořenit vrácenou cestu. (To znamená, že pokud path2 nebo path3 je absolutní cestou, Join metoda nezahodí předchozí cesty stejně jako Combine metoda.)

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ů. I když Path.Join("c:\\", "temp", "*.txt") může být například při vytváření souboru neplatný, je platný jako hledaný řetězec. Metoda Join ji proto úspěšně interpretuje.

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

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 metodami 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 rozbíhají. 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 opustí jednotku 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:. Nakonec, protože poslední argument ve třetím volání ShowPathInformation jsou rootovány, Join metoda jednoduše připojí ho k prvním dvěma argumentům a vytvoří nesmyslnou cestu k souboru, zatímco Combine metoda 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í pathznak a path2path3přidá znak oddělovače adresáře mezi libovolnou z komponent cesty, pokud ještě není k dispozici. Length Pokud některý z argumentů path1, path2nebo path3 argument je nula, metoda zřetězí zbývající argumenty. ReadOnlySpan<T>.Length Pokud je všechny komponenty nula, metoda vrátí String.Empty.

Pokud path1 nebo path2 končí znak oddělovače cesty, který není vhodný pro cílovou platformu, Join metoda 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 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 Path.DirectorySeparatorChar vlastnosti.

• Jako znak oddělovače adresáře použijte lomítko ("/"). Tento znak vrátí vlastnost Path.DirectorySeparatorChar v systémech unix a vlastnost Path.AltDirectorySeparatorChar v systémech Windows.

Combine Na rozdíl od metody se Join metoda nepokusí kořenit vrácenou cestu. (To znamená, že pokud path2 nebo path3 je absolutní cestou, Join metoda nezahodí předchozí cesty stejně jako Combine metoda.)

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ů. I když Path.Join("c:\\", "temp", "*.txt") může být například při vytváření souboru neplatný, je platný jako hledaný řetězec. Metoda Join ji proto úspěšně interpretuje.

Viz také

• formáty cest Soubory v systémech Windows

Join(ReadOnlySpan<String>)

Zdroj:

Path.cs

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.

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

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 metodami 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 rozbíhají. 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 opustí jednotku 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, Join metoda 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 přidá znak oddělovače adresáře mezi dvě součásti cesty, pokud jeden ještě není k dispozici na konci path1 nebo na začátku path2. Length Pokud je hodnota buď path1 nebo path2 nula, vrátí metoda jinou cestu. Pokud je Length obě path1 a path2 je nula, vrátí String.Emptymetoda .

Pokud path1 končí znak oddělovače cesty, který není vhodný pro cílovou platformu, Join metoda 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 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 Path.DirectorySeparatorChar vlastnosti.

• Jako znak oddělovače adresáře použijte lomítko ("/"). Tento znak vrátí vlastnost Path.DirectorySeparatorChar v systémech unix a vlastnost Path.AltDirectorySeparatorChar v systémech Windows.

Combine Na rozdíl od metody se Join metoda nepokusí kořenit vrácenou cestu. (To znamená, že pokud path2 je absolutní cesta, Join metoda se nezahodí path1 a vrátí path2 jako Combine metoda.) 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ého vstupu, Combine umožňuje metoda 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ů. I když Path.Join("c:\\", "*.txt") může být například při vytváření souboru neplatný, je platný jako hledaný řetězec. Metoda Join ji proto úspěšně interpretuje.

Viz také

• formáty cest Soubory v systémech Windows

Join(String[])

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 libovolnou z komponent cesty, pokud ještě není k dispozici. Length Pokud je některá z cest v paths nule, metoda zřetězí zbývající argumenty. Pokud je výsledná délka zřetězeného řetězce nula, vrátí String.Emptymetoda .

Pokud některé z cest v paths, s výjimkou poslední, končí znak oddělovače cesty, který není vhodný pro cílovou platformu, Join metoda 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 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 Path.DirectorySeparatorChar vlastnosti.

• Jako znak oddělovače adresáře použijte lomítko ("/"). Tento znak vrátí vlastnost Path.DirectorySeparatorChar v systémech unix a vlastnost Path.AltDirectorySeparatorChar v systémech Windows.

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

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ů. I když Path.Join("c:\\", "temp", "*.txt") může být například při vytváření souboru neplatný, je platný jako hledaný řetězec. Metoda Join ji proto úspěšně interpretuje.

Join(String, String)

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 přidá znak oddělovače adresáře mezi některou z komponent cesty, pokud ještě není k dispozici. Pokud je délka buď 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, vrátí String.Emptymetoda .

Pokud path1 končí znak oddělovače cesty, který není vhodný pro cílovou platformu, Join metoda 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 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 Path.DirectorySeparatorChar vlastnosti.

• Jako znak oddělovače adresáře použijte lomítko ("/"). Tento znak vrátí vlastnost Path.DirectorySeparatorChar v systémech unix a vlastnost Path.AltDirectorySeparatorChar v systémech Windows.

Combine Na rozdíl od metody se Join metoda nepokusí kořenit vrácenou cestu. (To znamená, že pokud path2 je absolutní cesta, Join metoda nezahodí předchozí cesty jako Combine metoda.)

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ů. I když Path.Join("c:\\", "temp", "*.txt") může být například při vytváření souboru neplatný, je platný jako hledaný řetězec. Metoda Join ji proto úspěšně interpretuje.