Path.Join Método

Definición

Espacio de nombres:

System.IO

Ensamblado:

System.Runtime.dll

Sobrecargas

Join(String, String, String, String)	Concatena cuatro rutas de acceso en una sola ruta de acceso.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatena cuatro componentes de ruta de acceso en una sola ruta de acceso.
Join(String, String, String)	Concatena tres rutas de acceso en una sola ruta de acceso.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatena tres componentes de ruta de acceso en una sola ruta de acceso.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatena dos componentes de ruta de acceso en una sola ruta de acceso.
Join(String[])	Concatena una matriz de rutas de acceso en una sola ruta de acceso.
Join(String, String)	Concatena dos rutas de acceso en una sola ruta de acceso.

Join(String, String, String, String)

Source:

Path.cs

Concatena cuatro rutas de acceso en una sola ruta de acceso.

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

Parámetros

path1

String

Primera ruta de acceso que se va a unir.

path2

String

Segunda ruta de acceso que se va a unir.

path3

String

Tercera ruta de acceso que se va a unir.

path4

String

Cuarta ruta de acceso que se va a unir.

Devoluciones

String

Ruta de acceso concatenada.

Comentarios

Este método simplemente concatena path, path2, path3 y path4 y agrega un carácter separador de directorio entre cualquiera de los componentes de ruta de acceso si aún no está presente. Si la longitud de cualquiera de path1, path2, path3 o path4 argumento es cero, el método concatena los argumentos restantes. Si la longitud de la cadena concatenada resultante es cero, el método devuelve String.Empty.

Si path1 o path2 o path3 termina en un carácter separador de ruta de acceso que no es adecuado para la plataforma de destino, el método Join conserva el carácter separador de ruta de acceso original y anexa el admitido. Este problema se produce en rutas de acceso codificadas de forma rígida que usan el carácter de barra diagonal inversa de Windows ("\"), que no se reconoce como separador de ruta de acceso en sistemas basados en Unix. Para solucionar este problema, puede hacer lo siguiente:

• Recupere el valor de la propiedad Path.DirectorySeparatorChar en lugar de codificar de forma rígida un carácter separador de directorio.

• Use una barra diagonal ("/") como carácter separador de directorio. Este carácter lo devuelve la propiedad Path.DirectorySeparatorChar en sistemas basados en Unix y por la propiedad Path.AltDirectorySeparatorChar en sistemas Windows.

A diferencia del método Combine, el método Join no intenta raíz la ruta de acceso devuelta. (Es decir, si path2 o path3 o path4 es una ruta de acceso absoluta, el método Join no descarta las rutas de acceso anteriores como lo hace el método Combine).

No todos los caracteres no válidos para los nombres de directorio y archivo se interpretan como inaceptables por el método Join, ya que puede usar estos caracteres para los caracteres comodín de búsqueda. Por ejemplo, aunque Path.Join("c:\\", "temp", "*.txt") podría no ser válido al crear un archivo, es válido como una cadena de búsqueda. Por lo tanto, el método Join lo interpreta correctamente.

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

Source:

Path.cs

Concatena cuatro componentes de ruta de acceso en una sola ruta de acceso.

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

Parámetros

path1

ReadOnlySpan<Char>

Intervalo de caracteres que contiene la primera ruta de acceso que se va a combinar.

path2

ReadOnlySpan<Char>

Intervalo de caracteres que contiene la segunda ruta de acceso que se va a combinar.

path3

ReadOnlySpan<Char>

Intervalo de caracteres que contiene la tercera ruta de acceso que se va a combinar.

path4

ReadOnlySpan<Char>

Intervalo de caracteres que contiene la cuarta ruta de acceso que se va a combinar.

Devoluciones

String

Ruta de acceso concatenada.

Comentarios

Este método simplemente concatena path, path2, path3 y path4 y agrega un carácter separador de directorio entre cualquiera de los componentes de ruta de acceso si aún no está presente. Si el Length de cualquiera de path1, path2, path3 o path4 argumento es cero, el método concatena los argumentos restantes. Si el ReadOnlySpan<T>.Length de todos los componentes es cero, el método devuelve String.Empty.

Si path1 o path2 o path3 termina en un carácter separador de ruta de acceso que no es adecuado para la plataforma de destino, el método Join conserva el carácter separador de ruta de acceso original y anexa el admitido. Este problema se produce en rutas de acceso codificadas de forma rígida que usan el carácter de barra diagonal inversa de Windows ("\"), que no se reconoce como separador de ruta de acceso en sistemas basados en Unix. Para solucionar este problema, puede hacer lo siguiente:

• Recupere el valor de la propiedad Path.DirectorySeparatorChar en lugar de codificar de forma rígida un carácter separador de directorio.

• Use una barra diagonal ("/") como carácter separador de directorio. Este carácter lo devuelve la propiedad Path.DirectorySeparatorChar en sistemas basados en Unix y por la propiedad Path.AltDirectorySeparatorChar en sistemas Windows.

A diferencia del método Combine, el método Join no intenta raíz la ruta de acceso devuelta. (Es decir, si path2 o path3 o path4 es una ruta de acceso absoluta, el método Join no descarta las rutas de acceso anteriores como lo hace el método Combine).

No todos los caracteres no válidos para los nombres de directorio y archivo se interpretan como inaceptables por el método Join, ya que puede usar estos caracteres para los caracteres comodín de búsqueda. Por ejemplo, aunque Path.Join("c:\\", "temp", "*.txt") podría no ser válido al crear un archivo, es válido como una cadena de búsqueda. Por lo tanto, el método Join lo interpreta correctamente.

Join(String, String, String)

Source:

Path.cs

Concatena tres rutas de acceso en una sola ruta de acceso.

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

Parámetros

path1

String

Primera ruta de acceso que se va a unir.

path2

String

Segunda ruta de acceso que se va a unir.

path3

String

Tercera ruta de acceso que se va a unir.

Devoluciones

String

Ruta de acceso concatenada.

Comentarios

Este método simplemente concatena path, path2y path3 y agrega un carácter separador de directorio entre cualquiera de los componentes de ruta de acceso si aún no está presente. Si la longitud de cualquiera de path1, path2 o path3 argumento es cero, el método concatena los argumentos restantes. Si la longitud de la cadena concatenada resultante es cero, el método devuelve String.Empty.

Si path1 o path2 termina en un carácter separador de ruta de acceso que no es adecuado para la plataforma de destino, el método Join conserva el carácter separador de ruta de acceso original y anexa el admitido. Este problema se produce en rutas de acceso codificadas de forma rígida que usan el carácter de barra diagonal inversa de Windows ("\"), que no se reconoce como separador de ruta de acceso en sistemas basados en Unix. Para solucionar este problema, puede hacer lo siguiente:

• Recupere el valor de la propiedad Path.DirectorySeparatorChar en lugar de codificar de forma rígida un carácter separador de directorio.

• Use una barra diagonal ("/") como carácter separador de directorio. Este carácter lo devuelve la propiedad Path.DirectorySeparatorChar en sistemas basados en Unix y por la propiedad Path.AltDirectorySeparatorChar en sistemas Windows.

A diferencia del método Combine, el método Join no intenta raíz la ruta de acceso devuelta. (Es decir, si path2 o path3 es una ruta de acceso absoluta, el método Join no descarta las rutas de acceso anteriores como lo hace el método Combine).

No todos los caracteres no válidos para los nombres de directorio y archivo se interpretan como inaceptables por el método Join, ya que puede usar estos caracteres para los caracteres comodín de búsqueda. Por ejemplo, aunque Path.Join("c:\\", "temp", "*.txt") podría no ser válido al crear un archivo, es válido como una cadena de búsqueda. Por lo tanto, el método Join lo interpreta correctamente.

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

Source:

Path.cs

Concatena tres componentes de ruta de acceso en una sola ruta de acceso.

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

Parámetros

path1

ReadOnlySpan<Char>

Intervalo de caracteres que contiene la primera ruta de acceso que se va a combinar.

path2

ReadOnlySpan<Char>

Intervalo de caracteres que contiene la segunda ruta de acceso que se va a combinar.

path3

ReadOnlySpan<Char>

Intervalo de caracteres que contiene la tercera ruta de acceso que se va a combinar.

Devoluciones

String

Ruta de acceso concatenada.

Ejemplos

En el ejemplo siguiente se muestra la diferencia en las rutas de acceso devueltas por los métodos Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) y Path.Combine(String, String, String). Cuando la primera cadena es una ruta de acceso completa que incluye una unidad y un directorio raíz y la segunda es una ruta de acceso relativa de la primera ruta de acceso, los dos métodos generan resultados idénticos. En la segunda y tercera llamada al método ShowPathInformation, las cadenas devueltas por los dos métodos se divergen. En la segunda llamada de método, el primer argumento de cadena es una unidad, mientras que el segundo es un directorio raíz. El método Join concatena las dos cadenas y conserva los separadores de ruta de acceso duplicados. Una llamada al método GetFullPath eliminaría la duplicación. El método Combine abandona la unidad y devuelve un directorio raíz en la unidad actual. Si la unidad actual de la aplicación es C:\ y la cadena se usa para acceder a un archivo o archivos del directorio, tendría acceso a C: en lugar de D:. Por último, dado que el argumento final de la tercera llamada a ShowPathInformation está rooteado, el método Join simplemente lo anexa a los dos primeros argumentos para crear una ruta de acceso de archivo sin sentido, mientras que el método Combine descarta las dos primeras cadenas y devuelve la tercera. El uso de esta cadena para el acceso a archivos podría proporcionar a la aplicación acceso no deseado a archivos confidenciales.

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'

Comentarios

Este método simplemente concatena path, path2y path3 y agrega un carácter separador de directorio entre cualquiera de los componentes de ruta de acceso si aún no está presente. Si el Length de cualquiera de path1, path2o path3 argumentos es cero, el método concatena los argumentos restantes. Si el ReadOnlySpan<T>.Length de todos los componentes es cero, el método devuelve String.Empty.

Si path1 o path2 termina en un carácter separador de ruta de acceso que no es adecuado para la plataforma de destino, el método Join conserva el carácter separador de ruta de acceso original y anexa el admitido. Este problema se produce en rutas de acceso codificadas de forma rígida que usan el carácter de barra diagonal inversa de Windows ("\"), que no se reconoce como separador de ruta de acceso en sistemas basados en Unix. Para solucionar este problema, puede hacer lo siguiente:

• Recupere el valor de la propiedad Path.DirectorySeparatorChar en lugar de codificar de forma rígida un carácter separador de directorio.

• Use una barra diagonal ("/") como carácter separador de directorio. Este carácter lo devuelve la propiedad Path.DirectorySeparatorChar en sistemas basados en Unix y por la propiedad Path.AltDirectorySeparatorChar en sistemas Windows.

A diferencia del método Combine, el método Join no intenta raíz la ruta de acceso devuelta. (Es decir, si path2 o path3 es una ruta de acceso absoluta, el método Join no descarta las rutas de acceso anteriores como lo hace el método Combine).

No todos los caracteres no válidos para los nombres de directorio y archivo se interpretan como inaceptables por el método Join, ya que puede usar estos caracteres para los caracteres comodín de búsqueda. Por ejemplo, aunque Path.Join("c:\\", "temp", "*.txt") podría no ser válido al crear un archivo, es válido como una cadena de búsqueda. Por lo tanto, el método Join lo interpreta correctamente.

Consulte también

• formatos de ruta de acceso de archivo en sistemas Windows

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

Source:

Path.cs

Concatena dos componentes de ruta de acceso en una sola ruta de acceso.

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

Parámetros

path1

ReadOnlySpan<Char>

Intervalo de caracteres que contiene la primera ruta de acceso que se va a combinar.

path2

ReadOnlySpan<Char>

Intervalo de caracteres que contiene la segunda ruta de acceso que se va a combinar.

Devoluciones

String

Rutas de acceso combinadas.

Ejemplos

En el ejemplo siguiente se muestra la diferencia en las rutas de acceso devueltas por los métodos Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) y Path.Combine(String, String). Cuando la primera cadena es una ruta de acceso completa que incluye una unidad y un directorio raíz y la segunda es una ruta de acceso relativa de la primera ruta de acceso, los dos métodos generan resultados idénticos. En la segunda y tercera llamada al método ShowPathInformation, las cadenas devueltas por los dos métodos se divergen. En la segunda llamada de método, el primer argumento de cadena es una unidad, mientras que el segundo es un directorio raíz. El método Join concatena las dos cadenas y conserva los separadores de ruta de acceso duplicados. El método Combine abandona la unidad y devuelve un directorio raíz en la unidad actual. Si la unidad actual de la aplicación es C:\ y la cadena se usa para acceder a un archivo o archivos del directorio, tendría acceso a C: en lugar de D:. Por último, dado que los dos argumentos de la tercera llamada a ShowPathInformation están rooteados, el método Join simplemente los anexa para crear una ruta de acceso de archivo no sin sentido, mientras que el método Combine descarta la primera cadena y devuelve la segunda. El uso de esta cadena para el acceso a archivos podría proporcionar a la aplicación acceso no deseado a archivos confidenciales.

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

Comentarios

Este método simplemente concatena path y path2 y agrega un carácter separador de directorio entre los dos componentes de ruta de acceso si uno aún no está presente al final de path1 o el principio de path2. Si el Length de path1 o path2 es cero, el método devuelve la otra ruta de acceso. Si el Length de path1 y path2 es cero, el método devuelve String.Empty.

Si path1 termina en un carácter separador de ruta de acceso que no es adecuado para la plataforma de destino, el método Join conserva el carácter separador de ruta de acceso original y anexa el admitido. Este problema se produce en rutas de acceso codificadas de forma rígida que usan el carácter de barra diagonal inversa de Windows ("\"), que no se reconoce como separador de ruta de acceso en sistemas basados en Unix. Para solucionar este problema, puede hacer lo siguiente:

• Recupere el valor de la propiedad Path.DirectorySeparatorChar en lugar de codificar de forma rígida un carácter separador de directorio.

• Use una barra diagonal ("/") como carácter separador de directorio. Este carácter lo devuelve la propiedad Path.DirectorySeparatorChar en sistemas basados en Unix y por la propiedad Path.AltDirectorySeparatorChar en sistemas Windows.

A diferencia del método Combine, el método Join no intenta raíz la ruta de acceso devuelta. (Es decir, si path2 es una ruta de acceso absoluta, el método Join no descarta path1 y devuelve path2 como lo hace el método Combine). En el ejemplo siguiente se muestra la diferencia en las rutas de acceso devueltas por los dos métodos. Si el origen de path2 es la entrada del usuario, el método Combine permite que un usuario acceda a un recurso del sistema de archivos (por ejemplo, C:/Users/User1/Documents/Financial/ en el caso del ejemplo) que la aplicación no pretende hacer accesible.

No todos los caracteres no válidos para los nombres de directorio y archivo se interpretan como inaceptables por el método Join, ya que puede usar estos caracteres para los caracteres comodín de búsqueda. Por ejemplo, aunque Path.Join("c:\\", "*.txt") podría no ser válido al crear un archivo, es válido como una cadena de búsqueda. Por lo tanto, el método Join lo interpreta correctamente.

Consulte también

• formatos de ruta de acceso de archivo en sistemas Windows

Join(String[])

Source:

Path.cs

Concatena una matriz de rutas de acceso en una sola ruta de acceso.

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

Parámetros

paths

String[]

Matriz de rutas de acceso.

Devoluciones

String

Ruta de acceso concatenada.

Comentarios

Este método simplemente concatena todas las cadenas de paths y agrega un carácter separador de directorio entre cualquiera de los componentes de la ruta de acceso si aún no existe uno. Si el Length de cualquiera de las rutas de acceso de paths es cero, el método concatena los argumentos restantes. Si la longitud de la cadena concatenada resultante es cero, el método devuelve String.Empty.

Si alguna de las rutas de acceso de paths, excepto la última, termina en un carácter separador de ruta que no es adecuado para la plataforma de destino, el método Join conserva el carácter separador de ruta de acceso original y anexa el admitido. Este problema se produce en rutas de acceso codificadas de forma rígida que usan el carácter de barra diagonal inversa de Windows ("\"), que no se reconoce como separador de ruta de acceso en sistemas basados en Unix. Para solucionar este problema, puede hacer lo siguiente:

• Recupere el valor de la propiedad Path.DirectorySeparatorChar en lugar de codificar de forma rígida un carácter separador de directorio.

• Use una barra diagonal ("/") como carácter separador de directorio. Este carácter lo devuelve la propiedad Path.DirectorySeparatorChar en sistemas basados en Unix y por la propiedad Path.AltDirectorySeparatorChar en sistemas Windows.

A diferencia del método Combine, el método Join no intenta raíz la ruta de acceso devuelta. (Es decir, si alguna de las rutas de acceso de paths, excepto la primera, es una ruta de acceso absoluta, el método Join no descarta las rutas de acceso anteriores como lo hace el método Combine).

No todos los caracteres no válidos para los nombres de directorio y archivo se interpretan como inaceptables por el método Join, ya que puede usar estos caracteres para los caracteres comodín de búsqueda. Por ejemplo, aunque Path.Join("c:\\", "temp", "*.txt") podría no ser válido al crear un archivo, es válido como una cadena de búsqueda. Por lo tanto, el método Join lo interpreta correctamente.

Join(String, String)

Source:

Path.cs

Concatena dos rutas de acceso en una sola ruta de acceso.

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

Parámetros

path1

String

Primera ruta de acceso que se va a unir.

path2

String

Segunda ruta de acceso que se va a unir.

Devoluciones

String

Ruta de acceso concatenada.

Comentarios

Este método simplemente concatena path y path2 y agrega un carácter separador de directorio entre cualquiera de los componentes de ruta de acceso si aún no está presente. Si la longitud de path1 o path2 es cero, el método concatena el argumento restante. Si la longitud de la cadena concatenada resultante es cero, el método devuelve String.Empty.

Si path1 termina en un carácter separador de ruta de acceso que no es adecuado para la plataforma de destino, el método Join conserva el carácter separador de ruta de acceso original y anexa el admitido. Este problema se produce en rutas de acceso codificadas de forma rígida que usan el carácter de barra diagonal inversa de Windows ("\"), que no se reconoce como separador de ruta de acceso en sistemas basados en Unix. Para solucionar este problema, puede hacer lo siguiente:

• Recupere el valor de la propiedad Path.DirectorySeparatorChar en lugar de codificar de forma rígida un carácter separador de directorio.

• Use una barra diagonal ("/") como carácter separador de directorio. Este carácter lo devuelve la propiedad Path.DirectorySeparatorChar en sistemas basados en Unix y por la propiedad Path.AltDirectorySeparatorChar en sistemas Windows.

A diferencia del método Combine, el método Join no intenta raíz la ruta de acceso devuelta. (Es decir, si path2 es una ruta de acceso absoluta, el método Join no descarta las rutas de acceso anteriores como lo hace el método Combine).

No todos los caracteres no válidos para los nombres de directorio y archivo se interpretan como inaceptables por el método Join, ya que puede usar estos caracteres para los caracteres comodín de búsqueda. Por ejemplo, aunque Path.Join("c:\\", "temp", "*.txt") podría no ser válido al crear un archivo, es válido como una cadena de búsqueda. Por lo tanto, el método Join lo interpreta correctamente.