Dlaczego Path.Combine nieprawidłowo łączy nazwy plików rozpoczynające się od Path.DirectorySeparatorChar?

Z okna natychmiastowego w Visual Studio:

> Path.Combine(@"C:\x", "y")
"C:\\x\\y"
> Path.Combine(@"C:\x", @"\y")
"\\y"

Wydaje się, że oba powinny być takie same.

Stara FileSystemObject.BuildPath () nie działała w ten sposób ...

Jest to rodzaj filozoficznego pytania (na które być może tylko Microsoft może naprawdę odpowiedzieć), ponieważ robi dokładnie to, co mówi dokumentacja.

System.IO.Path.Combine

„Jeśli ścieżka2 zawiera ścieżkę bezwzględną, ta metoda zwraca ścieżkę 2.”

Oto faktyczna metoda Combine ze źródła .NET. Możesz zobaczyć, że wywołuje on CombineNoChecks , który następnie wywołuje IsPathRooted na path2 i zwraca tę ścieżkę, jeśli tak:

public static String Combine(String path1, String path2) {
    if (path1==null || path2==null)
        throw new ArgumentNullException((path1==null) ? "path1" : "path2");
    Contract.EndContractBlock();
    CheckInvalidPathChars(path1);
    CheckInvalidPathChars(path2);

    return CombineNoChecks(path1, path2);
}

internal static string CombineNoChecks(string path1, string path2)
{
    if (path2.Length == 0)
        return path1;

    if (path1.Length == 0)
        return path2;

    if (IsPathRooted(path2))
        return path2;

    char ch = path1[path1.Length - 1];
    if (ch != DirectorySeparatorChar && ch != AltDirectorySeparatorChar &&
            ch != VolumeSeparatorChar) 
        return path1 + DirectorySeparatorCharAsString + path2;
    return path1 + path2;
}

Nie wiem, jakie jest uzasadnienie. Myślę, że rozwiązaniem jest usunięcie (lub przycięcie) DirectorySeparatorChar od początku drugiej ścieżki; może napisz własną metodę Combine, która to robi, a następnie wywołuje Path.Combine ().

To jest zdemontowany kod z .NET Reflector dla metody Path.Combine. Sprawdź funkcję IsPathRooted. Jeśli druga ścieżka jest zrootowana (zaczyna się od DirectorySeparatorChar), zwróć drugą ścieżkę taką, jaka jest.

public static string Combine(string path1, string path2)
{
    if ((path1 == null) || (path2 == null))
    {
        throw new ArgumentNullException((path1 == null) ? "path1" : "path2");
    }
    CheckInvalidPathChars(path1);
    CheckInvalidPathChars(path2);
    if (path2.Length == 0)
    {
        return path1;
    }
    if (path1.Length == 0)
    {
        return path2;
    }
    if (IsPathRooted(path2))
    {
        return path2;
    }
    char ch = path1[path1.Length - 1];
    if (((ch != DirectorySeparatorChar) &&
         (ch != AltDirectorySeparatorChar)) &&
         (ch != VolumeSeparatorChar))
    {
        return (path1 + DirectorySeparatorChar + path2);
    }
    return (path1 + path2);
}


public static bool IsPathRooted(string path)
{
    if (path != null)
    {
        CheckInvalidPathChars(path);
        int length = path.Length;
        if (
              (
                  (length >= 1) &&
                  (
                      (path[0] == DirectorySeparatorChar) ||
                      (path[0] == AltDirectorySeparatorChar)
                  )
              )

              ||

              ((length >= 2) &&
              (path[1] == VolumeSeparatorChar))
           )
        {
            return true;
        }
    }
    return false;
}

Chciałem rozwiązać ten problem:

string sample1 = "configuration/config.xml";
string sample2 = "/configuration/config.xml";
string sample3 = "\\configuration/config.xml";

string dir1 = "c:\\temp";
string dir2 = "c:\\temp\\";
string dir3 = "c:\\temp/";

string path1 = PathCombine(dir1, sample1);
string path2 = PathCombine(dir1, sample2);
string path3 = PathCombine(dir1, sample3);

string path4 = PathCombine(dir2, sample1);
string path5 = PathCombine(dir2, sample2);
string path6 = PathCombine(dir2, sample3);

string path7 = PathCombine(dir3, sample1);
string path8 = PathCombine(dir3, sample2);
string path9 = PathCombine(dir3, sample3);

Oczywiście wszystkie ścieżki 1-9 powinny zawierać równoważny ciąg na końcu. Oto metoda PathCombine, którą wymyśliłem:

private string PathCombine(string path1, string path2)
{
    if (Path.IsPathRooted(path2))
    {
        path2 = path2.TrimStart(Path.DirectorySeparatorChar);
        path2 = path2.TrimStart(Path.AltDirectorySeparatorChar);
    }

    return Path.Combine(path1, path2);
}

Myślę też, że to dość denerwujące, że ta obsługa łańcuchów musi być wykonywana ręcznie, i byłbym zainteresowany przyczyną tego.

Moim zdaniem jest to błąd. Problem polega na tym, że istnieją dwa różne rodzaje ścieżek „absolutnych”. Ścieżka „d: \ mydir \ myfile.txt” jest bezwzględna, ścieżka „\ mydir \ myfile.txt” również jest uważana za „bezwzględną”, mimo że brakuje jej litery dysku. Moim zdaniem poprawnym działaniem byłoby wstawienie litery dysku z pierwszej ścieżki, gdy druga ścieżka zaczyna się od separatora katalogów (i nie jest ścieżką UNC). Poleciłbym napisać własną funkcję opakowania pomocnika, która zachowa się tak, jak chcesz, jeśli jej potrzebujesz.

Z MSDN :

Jeśli jedna z określonych ścieżek jest łańcuchem o zerowej długości, ta metoda zwraca drugą ścieżkę. Jeśli ścieżka2 zawiera ścieżkę bezwzględną, ta metoda zwraca ścieżkę2.

W twoim przykładzie ścieżka 2 jest absolutna.

Zgodnie z radą Christiana Grausa w blogu „Things I Hate about Microsoft” zatytułowanym „ Path.Combine jest zasadniczo bezużyteczny ” . Oto moje rozwiązanie:

public static class Pathy
{
    public static string Combine(string path1, string path2)
    {
        if (path1 == null) return path2
        else if (path2 == null) return path1
        else return path1.Trim().TrimEnd(System.IO.Path.DirectorySeparatorChar)
           + System.IO.Path.DirectorySeparatorChar
           + path2.Trim().TrimStart(System.IO.Path.DirectorySeparatorChar);
    }

    public static string Combine(string path1, string path2, string path3)
    {
        return Combine(Combine(path1, path2), path3);
    }
}

Niektórzy radzą, aby przestrzenie nazw kolidowały, ... Poszedłem Pathytrochę, aby uniknąć kolizji przestrzeni nazw System.IO.Path.

Edycja : Dodano sprawdzanie parametrów zerowych

Ten kod powinien załatwić sprawę:

        string strFinalPath = string.Empty;
        string normalizedFirstPath = Path1.TrimEnd(new char[] { '\\' });
        string normalizedSecondPath = Path2.TrimStart(new char[] { '\\' });
        strFinalPath =  Path.Combine(normalizedFirstPath, normalizedSecondPath);
        return strFinalPath;

Nie znając faktycznych szczegółów, domyślam się, że próbuje się połączyć, jakbyś mógł dołączyć względne identyfikatory URI. Na przykład:

urljoin('/some/abs/path', '../other') = '/some/abs/other'

Oznacza to, że łącząc ścieżkę z poprzednim ukośnikiem, faktycznie łączysz jedną bazę z drugą, w którym to przypadku druga ma pierwszeństwo.

Powód:

Twój drugi adres URL jest uważany za ścieżkę bezwzględną. CombineMetoda zwróci ostatnią ścieżkę tylko wtedy, gdy ostatnia ścieżka jest ścieżką bezwzględną.

Rozwiązanie: Wystarczy usunąć początkowy ukośnik /z drugiej ścieżki ( /SecondPathdo SecondPath). Następnie działa tak, jak wyjątek.

Ma to w pewnym sensie sens, biorąc pod uwagę, w jaki sposób (względne) ścieżki są zwykle traktowane:

string GetFullPath(string path)
{
     string baseDir = @"C:\Users\Foo.Bar";
     return Path.Combine(baseDir, path);
}

// Get full path for RELATIVE file path
GetFullPath("file.txt"); // = C:\Users\Foo.Bar\file.txt

// Get full path for ROOTED file path
GetFullPath(@"C:\Temp\file.txt"); // = C:\Temp\file.txt

Prawdziwe pytanie brzmi: dlaczego ścieżki, które zaczynają się "\", są uważane za „zakorzenione”? To również było dla mnie nowe, ale działa tak w systemie Windows :

new FileInfo("\windows"); // FullName = C:\Windows, Exists = True
new FileInfo("windows"); // FullName = C:\Users\Foo.Bar\Windows, Exists = False

Jeśli chcesz połączyć obie ścieżki bez utraty żadnej ścieżki, możesz użyć tego:

?Path.Combine(@"C:\test", @"\test".Substring(0, 1) == @"\" ? @"\test".Substring(1, @"\test".Length - 1) : @"\test");

Lub ze zmiennymi:

string Path1 = @"C:\Test";
string Path2 = @"\test";
string FullPath = Path.Combine(Path1, Path2.IsRooted() ? Path2.Substring(1, Path2.Length - 1) : Path2);

Oba przypadki zwracają „C: \ test \ test”.

Najpierw oceniam, czy ścieżka 2 zaczyna się od / i czy to prawda, zwracam ścieżkę 2 bez pierwszego znaku. W przeciwnym razie zwróć pełną ścieżkę2.

Te dwie metody powinny uchronić cię przed przypadkowym połączeniem dwóch ciągów, które zawierają ogranicznik.

    public static string Combine(string x, string y, char delimiter) {
        return $"{ x.TrimEnd(delimiter) }{ delimiter }{ y.TrimStart(delimiter) }";
    }

    public static string Combine(string[] xs, char delimiter) {
        if (xs.Length < 1) return string.Empty;
        if (xs.Length == 1) return xs[0];
        var x = Combine(xs[0], xs[1], delimiter);
        if (xs.Length == 2) return x;
        var ys = new List<string>();
        ys.Add(x);
        ys.AddRange(xs.Skip(2).ToList());
        return Combine(ys.ToArray(), delimiter);
    }

To \ oznacza „katalog główny bieżącego dysku”. W twoim przykładzie oznacza to folder „testowy” w katalogu głównym bieżącego dysku. Może to być więc równe „c: \ test”.

Usuń początkowy ukośnik („\”) z drugiego parametru (ścieżka2) Path.Combine.

Użyłem funkcji agregującej, aby wymusić połączenie ścieżek, jak poniżej:

public class MyPath    
{
    public static string ForceCombine(params string[] paths)
    {
        return paths.Aggregate((x, y) => Path.Combine(x, y.TrimStart('\\')));
    }
}

Jak wspomniał Ryan, robi dokładnie to, co mówi dokumentacja.

Od czasów DOS rozróżnia się bieżący dysk i bieżącą ścieżkę. \jest ścieżką katalogu głównego, ale dla AKTUALNEGO DYSKU.

Dla każdego „ dysku ” istnieje osobna „ bieżąca ścieżka ”. Jeśli zmienisz dysk za pomocącd D: , nie zmienisz bieżącej ścieżki na D:\, ale na: „D: \ cokolwiek \ było \ ostatnią \ ścieżką \ dostępną \ na \ tym \ dysku” ...

Tak więc w systemie Windows literał @"\x"oznacza: „CURRENTDISK: \ x”. Dlatego Path.Combine(@"C:\x", @"\y")jako drugi parametr ma ścieżkę katalogu głównego, a nie krewnego, choć nie na znanym dysku ... A ponieważ nie wiadomo, który może być «bieżącym dyskiem», zwraca python "\\y".

>cd C:
>cd \mydironC\apath
>cd D:
>cd \mydironD\bpath
>cd C:
>cd
>C:\mydironC\apath