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 única ruta de acceso.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatena cuatro rutas de acceso en una única ruta de acceso.
Join(String, String, String)	Concatena tres rutas de acceso en una única ruta de acceso.
Join(String[])	Concatena una matriz de rutas de acceso en una única ruta de acceso.
Join(String, String)	Concatena dos rutas de acceso en una única ruta de acceso.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatena dos componentes de ruta de acceso en una única ruta de acceso.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatena tres componentes de ruta de acceso en una única ruta de acceso.

Join(String, String, String, String)

Source:

Path.cs

Concatena cuatro rutas de acceso en una única 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 combinar.

path2

String

Segunda ruta de acceso que se va a combinar.

path3

String

Tercera ruta de acceso que se va a combinar.

path4

String

Cuarta ruta de acceso que se va a combinar.

Devoluciones

String

Ruta de acceso concatenada.

Comentarios

Este método simplemente concatena path, path2path3 y path4 agrega un carácter separador de directorio entre cualquiera de los componentes de ruta de acceso si aún no hay uno presente. Si la longitud de cualquiera de path1los argumentos , path2path3 o path4 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 path2path3 termina en un carácter separador de ruta de acceso que no es adecuado para la plataforma de destino, el Join método conserva el carácter separador de ruta de acceso original y anexa el admitido. Este problema surge 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 Path.DirectorySeparatorChar propiedad en lugar de codificar de forma rígida un carácter separador de directorios.

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

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

No todos los caracteres no válidos para los nombres de directorio y archivo se interpretan como inaceptables por el Join método , ya que puede usar estos caracteres para 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 Join método lo interpreta correctamente.

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

Source:

Path.cs

Concatena cuatro rutas de acceso en una única 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 para combinar.

path2

ReadOnlySpan<Char>

Intervalo de caracteres que contiene la segunda ruta de acceso para combinar.

path3

ReadOnlySpan<Char>

Intervalo de caracteres que contiene la tercera ruta de acceso para combinar.

path4

ReadOnlySpan<Char>

Intervalo de caracteres que contiene la cuarta ruta de acceso que combinar.

Devoluciones

String

Ruta de acceso concatenada.

Comentarios

Este método simplemente concatena path, path2path3 y path4 agrega un carácter separador de directorio entre cualquiera de los componentes de ruta de acceso si aún no hay uno presente. Si el Length de cualquiera de path1los argumentos , path2path3 o path4 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 path2path3 termina en un carácter separador de ruta de acceso que no es adecuado para la plataforma de destino, el Join método conserva el carácter separador de ruta de acceso original y anexa el admitido. Este problema surge 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 Path.DirectorySeparatorChar propiedad en lugar de codificar de forma rígida un carácter separador de directorios.

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

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

No todos los caracteres no válidos para los nombres de directorio y archivo se interpretan como inaceptables por el Join método , ya que puede usar estos caracteres para 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 Join método lo interpreta correctamente.

Join(String, String, String)

Source:

Path.cs

Concatena tres rutas de acceso en una única 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 combinar.

path2

String

Segunda ruta de acceso que se va a combinar.

path3

String

Tercera ruta de acceso que se va a combinar.

Devoluciones

String

Ruta de acceso concatenada.

Comentarios

Este método simplemente concatena path, path2y path3 agrega un carácter separador de directorio entre cualquiera de los componentes de ruta de acceso si aún no hay uno presente. Si la longitud de cualquiera de path1los argumentos , path2 o path3 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 Join método conserva el carácter separador de ruta de acceso original y anexa el admitido. Este problema surge 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 Path.DirectorySeparatorChar propiedad en lugar de codificar de forma rígida un carácter separador de directorios.

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

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

No todos los caracteres no válidos para los nombres de directorio y archivo se interpretan como inaceptables por el Join método , ya que puede usar estos caracteres para 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 Join método lo interpreta correctamente.

Join(String[])

Source:

Path.cs

Concatena una matriz de rutas de acceso en una única 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 ruta de acceso si aún no está presente. 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 de acceso que no es adecuado para la plataforma de destino, el Join método conserva el carácter separador de ruta de acceso original y anexa el admitido. Este problema surge 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 Path.DirectorySeparatorChar propiedad en lugar de codificar de forma rígida un carácter separador de directorios.

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

A diferencia del Combine método , el Join método 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 Join método no descarta las rutas de acceso anteriores como hace el Combine método).

No todos los caracteres no válidos para los nombres de directorio y archivo se interpretan como inaceptables por el Join método , ya que puede usar estos caracteres para 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 Join método lo interpreta correctamente.

Join(String, String)

Source:

Path.cs

Concatena dos rutas de acceso en una única 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 combinar.

path2

String

Segunda ruta de acceso que se va a combinar.

Devoluciones

String

Ruta de acceso concatenada.

Comentarios

Este método simplemente concatena path y path2 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 o path1path2 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 Join método conserva el carácter separador de ruta de acceso original y anexa el admitido. Este problema surge 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 Path.DirectorySeparatorChar propiedad en lugar de codificar de forma rígida un carácter separador de directorios.

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

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

No todos los caracteres no válidos para los nombres de directorio y archivo se interpretan como inaceptables por el Join método , ya que puede usar estos caracteres para 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 Join método lo interpreta correctamente.

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

Source:

Path.cs

Concatena dos componentes de ruta de acceso en una única 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 para combinar.

path2

ReadOnlySpan<Char>

Intervalo de caracteres que contiene la segunda ruta de acceso para combinar.

Devoluciones

String

Rutas de acceso combinadas.

Ejemplos

En el ejemplo siguiente se muestra la diferencia en las rutas de acceso devueltas por los Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) métodos 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 ShowPathInformation método , las cadenas devueltas por los dos métodos divergen. En la segunda llamada al método, el primer argumento de cadena es una unidad, mientras que el segundo es un directorio raíz. El Join método concatena las dos cadenas y conserva los separadores de ruta de acceso duplicados. El Combine método 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 en el directorio, tendría acceso a C: en lugar de D:. Por último, dado que ambos argumentos de la tercera llamada a ShowPathInformation están modificados, el Join método simplemente los anexa para crear una ruta de acceso de archivo sin sentido, mientras que el Combine método descarta la primera cadena y devuelve la segunda. El uso de esta cadena para el acceso a archivos podría dar 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 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 al principio de path2. Si el Length de o path1path2 es cero, el método devuelve la otra ruta de acceso. Si el Length valor 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 Join método conserva el carácter separador de ruta de acceso original y anexa el admitido. Este problema surge 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 Path.DirectorySeparatorChar propiedad en lugar de codificar de forma rígida un carácter separador de directorios.

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

A diferencia del Combine método , el Join método no intenta raíz la ruta de acceso devuelta. (Es decir, si path2 es una ruta de acceso absoluta, el Join método no descarta path1 y devuelve path2 como lo hace el Combine método). 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 Combine método permite a un usuario tener acceso a un recurso del sistema de archivos (como C:/Users/User1/Documents/Financial/ en el caso del ejemplo) que la aplicación no tenía intención de hacer accesible.

No todos los caracteres no válidos para los nombres de directorio y archivo se interpretan como inaceptables por el Join método , ya que puede usar estos caracteres para 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 Join método lo interpreta correctamente.

Consulte también

• Formatos de ruta de acceso de archivo en los sistemas Windows

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

Source:

Path.cs

Concatena tres componentes de ruta de acceso en una única 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 para combinar.

path2

ReadOnlySpan<Char>

Intervalo de caracteres que contiene la segunda ruta de acceso para combinar.

path3

ReadOnlySpan<Char>

Intervalo de caracteres que contiene la tercera ruta de acceso para combinar.

Devoluciones

String

Ruta de acceso concatenada.

Ejemplos

En el ejemplo siguiente se muestra la diferencia en las rutas de acceso devueltas por los Path.Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) métodos 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 ShowPathInformation método , las cadenas devueltas por los dos métodos divergen. En la segunda llamada al método, el primer argumento de cadena es una unidad, mientras que el segundo es un directorio raíz. El Join método concatena las dos cadenas y conserva los separadores de ruta de acceso duplicados. Una llamada al GetFullPath método eliminaría la duplicación. El Combine método 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 en el 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 Join método simplemente lo anexa a los dos primeros argumentos para crear una ruta de acceso de archivo sin sentido, mientras que el Combine método descarta las dos primeras cadenas y devuelve la tercera. El uso de esta cadena para el acceso a archivos podría dar 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 agrega un carácter separador de directorio entre cualquiera de los componentes de ruta de acceso si aún no hay uno presente. Si el Length valor de cualquiera de path1los argumentos , path2o path3 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 Join método conserva el carácter separador de ruta de acceso original y anexa el admitido. Este problema surge 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 Path.DirectorySeparatorChar propiedad en lugar de codificar de forma rígida un carácter separador de directorios.

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

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

No todos los caracteres no válidos para los nombres de directorio y archivo se interpretan como inaceptables por el Join método , ya que puede usar estos caracteres para 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 Join método lo interpreta correctamente.

Consulte también

• Formatos de ruta de acceso de archivo en los sistemas Windows