如何比较 C# 中的（目录）路径？

Question

如果我有两个 DirectoryInfo 对象，我如何比较它们的语义相等性？例如，以下路径都应视为等于C:\temp：

• C:\temp
• C:\temp\
• C:\temp\.
• C:\temp\x\..\..\temp\.

以下可能等于也可能不等于C:\temp：

• \temp 如果当前工作目录在驱动器上 C:\
• temp 如果当前工作目录是C:\
• C:\temp.
• C:\temp...\

如果考虑当前工作目录很重要，我可以自己弄清楚，所以这并不重要。尾随点在窗口中被剥离，所以这些路径真的应该是相等的 - 但它们在 unix 中没有被剥离，所以在单声道下我期待其他结果。

区分大小写是可选的。路径可能存在也可能不存在，用户可能拥有或不拥有路径的权限 - 我更喜欢不需要任何 I 的快速稳健的方法/O（所以没有权限检查），但如果有内置的东西，我也会对任何“足够好”的东西感到满意......

我意识到，如果没有 I/O，就无法确定某个中间存储层是否碰巧将相同的存储映射到了相同的文件（即使使用 I/O，当事情变得足够混乱时也可能是不可能的）。但是，无论底层文件系统如何，至少应该可以肯定地识别等效的路径，即在给定类型的所有可能文件系统上必然会解析为相同文件（如果存在）的路径。这有时有用的原因是 (A) 因为我当然想在执行 I/O 之前先检查一下，(B) I/O 有时会触发有问题的副作用，以及 (C) 各种其他软件组件有时会破坏提供的路径，并且能够以一种对等效路径的最常见转换不敏感的方式进行比较是有帮助的，最后 (D) 准备部署，事先进行一些健全性检查很有用，但这些检查发生在待部署之前- on system 甚至可以访问。

Answer 1

GetFullPath 似乎可以完成这项工作，除了大小写差异 (Path.GetFullPath("test") != Path.GetFullPath("TEST")) 和斜杠。 因此，以下代码应该可以正常工作：

String.Compare(
    Path.GetFullPath(path1).TrimEnd('\\'),
    Path.GetFullPath(path2).TrimEnd('\\'), 
    StringComparison.InvariantCultureIgnoreCase)

或者，如果你想以DirectoryInfo开头：

String.Compare(
    dirinfo1.FullName.TrimEnd('\\'),
    dirinfo2.FullName.TrimEnd('\\'), 
    StringComparison.InvariantCultureIgnoreCase)

Answer 2

来自this answer，这个方法可以处理一些边缘情况：

public static string NormalizePath(string path)
{
    return Path.GetFullPath(new Uri(path).LocalPath)
               .TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)
               .ToUpperInvariant();
}

原始答案中的更多详细信息。像这样称呼它：

bool pathsEqual = NormalizePath(path1) == NormalizePath(path2);

应该适用于文件和目录路径。

Answer 3

自最初提出问题以来以及最初发布此答案以来，已对该问题进行了编辑和澄清。就目前的问题而言，下面的这个答案不是正确的答案。本质上，当前的问题是要求进行纯文本路径比较，这与想要确定两条路径是否解析为同一个文件系统对象完全不同。所有其他答案，除了 Igor Korkhov 的答案，最终都是基于两个名字的文本比较。

如果你真的想知道两个路径何时解析到同一个文件系统对象，你必须做一些 IO。试图获得两个“标准化”名称，考虑到引用同一文件对象的无数可能方式，几乎是不可能的。存在诸如：连接点、符号链接、网络文件共享（以不同方式引用同一文件对象）等问题。事实上，除了 Igor Korkhov 的之外，上面的每个答案都绝对会给出在某些情况下不正确导致问题“这两个路径是否引用相同的文件系统对象。（例如连接、符号链接、目录链接等）

该问题特别要求该解决方案不需要任何 I/O，但如果您要处理网络路径，则绝对需要进行 IO：在某些情况下根本无法从任何本地确定路径字符串操作，两个文件引用是否将引用同一个物理文件。 （这很容易理解如下。假设文件服务器在共享子树的某处有一个 windows 目录联结。在这种情况下，可以直接引用文件，也可以通过联结引用文件。但联结位于 并且由文件服务器解析，因此客户端根本不可能仅通过本地信息来确定两个引用文件名引用同一个物理文件：该信息在本地根本不可用到客户端。因此必须绝对做一些最小的 IO - 例如打开两个文件对象句柄 - 以确定引用是否引用相同的物理文件。）

以下解决方案会进行一些 IO，虽然非常少，但可以正确确定两个文件系统引用在语义上是否相同，即引用同一个文件对象。 （如果两个文件规范都没有引用有效的文件对象，则所有赌注都关闭）：

public static bool AreDirsEqual(string dirName1, string dirName2, bool resolveJunctionaAndNetworkPaths = true)
{
    if (string.IsNullOrEmpty(dirName1) || string.IsNullOrEmpty(dirName2))
        return dirName1==dirName2;
    dirName1 = NormalizePath(dirName1); //assume NormalizePath normalizes/fixes case and path separators to Path.DirectorySeparatorChar
    dirName2 = NormalizePath(dirName2);
    int i1 = dirName1.Length;
    int i2 = dirName2.Length;
    do
    {
        --i1; --i2;
        if (i1 < 0 || i2 < 0)
            return i1 < 0 && i2 < 0;
    } while (dirName1[i1] == dirName2[i2]);//If you want to deal with international character sets, i.e. if NormalixePath does not fix case, this comparison must be tweaked
    if( !resolveJunctionaAndNetworkPaths )
        return false;
    for(++i1, ++i2; i1 < dirName1.Length; ++i1, ++i2)
    {
        if (dirName1[i1] == Path.DirectorySeparatorChar)
        {
            dirName1 = dirName1.Substring(0, i1);
            dirName2 = dirName1.Substring(0, i2);
            break;
        }
    }
    return AreFileSystemObjectsEqual(dirName1, dirName2);
}

public static bool AreFileSystemObjectsEqual(string dirName1, string dirName2)
{
    //NOTE: we cannot lift the call to GetFileHandle out of this routine, because we _must_
    // have both file handles open simultaneously in order for the objectFileInfo comparison
    // to be guaranteed as valid.
    using (SafeFileHandle directoryHandle1 = GetFileHandle(dirName1), directoryHandle2 = GetFileHandle(dirName2))
    {
        BY_HANDLE_FILE_INFORMATION? objectFileInfo1 = GetFileInfo(directoryHandle1);
        BY_HANDLE_FILE_INFORMATION? objectFileInfo2 = GetFileInfo(directoryHandle2);
        return objectFileInfo1 != null
                && objectFileInfo2 != null
                && (objectFileInfo1.Value.FileIndexHigh == objectFileInfo2.Value.FileIndexHigh)
                && (objectFileInfo1.Value.FileIndexLow == objectFileInfo2.Value.FileIndexLow)
                && (objectFileInfo1.Value.VolumeSerialNumber == objectFileInfo2.Value.VolumeSerialNumber);
    }
}

static SafeFileHandle GetFileHandle(string dirName)
{
    const int FILE_ACCESS_NEITHER = 0;
    //const int FILE_SHARE_READ = 1;
    //const int FILE_SHARE_WRITE = 2;
    //const int FILE_SHARE_DELETE = 4;
    const int FILE_SHARE_ANY = 7;//FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE
    const int CREATION_DISPOSITION_OPEN_EXISTING = 3;
    const int FILE_FLAG_BACKUP_SEMANTICS = 0x02000000;
    return CreateFile(dirName, FILE_ACCESS_NEITHER, FILE_SHARE_ANY, System.IntPtr.Zero, CREATION_DISPOSITION_OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, System.IntPtr.Zero);
}


static BY_HANDLE_FILE_INFORMATION? GetFileInfo(SafeFileHandle directoryHandle)
{
    BY_HANDLE_FILE_INFORMATION objectFileInfo;
    if ((directoryHandle == null) || (!GetFileInformationByHandle(directoryHandle.DangerousGetHandle(), out objectFileInfo)))
    {
        return null;
    }
    return objectFileInfo;
}

[DllImport("kernel32.dll", EntryPoint = "CreateFileW", CharSet = CharSet.Unicode, SetLastError = true)]
static extern SafeFileHandle CreateFile(string lpFileName, int dwDesiredAccess, int dwShareMode,
 IntPtr SecurityAttributes, int dwCreationDisposition, int dwFlagsAndAttributes, IntPtr hTemplateFile);
[DllImport("kernel32.dll", SetLastError = true)]
static extern bool GetFileInformationByHandle(IntPtr hFile, out BY_HANDLE_FILE_INFORMATION lpFileInformation);

[StructLayout(LayoutKind.Sequential)]
public struct BY_HANDLE_FILE_INFORMATION
{
    public uint FileAttributes;
    public System.Runtime.InteropServices.ComTypes.FILETIME CreationTime;
    public System.Runtime.InteropServices.ComTypes.FILETIME LastAccessTime;
    public System.Runtime.InteropServices.ComTypes.FILETIME LastWriteTime;
    public uint VolumeSerialNumber;
    public uint FileSizeHigh;
    public uint FileSizeLow;
    public uint NumberOfLinks;
    public uint FileIndexHigh;
    public uint FileIndexLow;
};

请注意，在上面的代码中，我包含了两行类似dirName1 = NormalizePath(dirName1); 的代码，并且没有指定函数NormalizePath 是什么。 NormalizePath 可以是任何路径规范化函数 - 许多已在此问题其他地方的答案中提供。提供合理的NormalizePath 函数意味着AreDirsEqual 将给出合理的答案，即使两个输入路径引用不存在的文件系统对象，即您只想在字符串级别上比较的路径。 （上面 Ishmaeel 的评论也应该注意，这段代码没有这样做......）

（此代码可能存在细微的权限问题，如果用户对某些初始目录具有仅遍历权限，我不确定是否允许AreFileSystemObjectsEqual 要求的文件系统访问。在这种情况下，参数resolveJunctionaAndNetworkPaths 至少允许用户恢复到纯文本比较...）

这个想法来自 Warren Stevens 在我在 SuperUser 上发布的一个类似问题的回复：https://superuser.com/a/881966/241981

Answer 4

.NET 中路径的实现有一些不足之处。对此有很多抱怨。 NDepend 的创建者Patrick Smacchia 发布了open source library that enables handling of common and complex path operations。如果您在应用程序中对路径进行大量比较操作，此库可能对您有用。

Answer 5

似乎 P/Invoking GetFinalPathNameByHandle() 将是最可靠的解决方案。

UPD：糟糕，我没有考虑到您不使用任何 I/O 的愿望

Answer 6

微软已经实现了类似的方法，尽管它们不如上面的答案有用：

• PathUtil.ArePathsEqual Method（就是return string.Equals(path1, path2, StringComparison.OrdinalIgnoreCase);）
• PathUtil.Normalize Method
• PathUtil.NormalizePath Method（就是return PathUtil.Normalize(path);）

Answer 7

 System.IO.Path.GetFullPath(pathA).Equals(System.IO.Path.GetFullPath(PathB));

Answer 8

“名称”属性是相等的。采取：

DirectoryInfo dir1 = new DirectoryInfo("C:\\Scratch");
DirectoryInfo dir2 = new DirectoryInfo("C:\\Scratch\\");
DirectoryInfo dir3 = new DirectoryInfo("C:\\Scratch\\4760");
DirectoryInfo dir4 = new DirectoryInfo("C:\\Scratch\\4760\\..\\");

dir1.Name == dir2.Name and dir2.Name == dir4.Name（在本例中为“Scratch”。dir3 ==“4760”。）只有 FullName 属性不同。

在给定两个 DirectoryInfo 类的情况下，您可以使用递归方法检查每个父级的 Name 属性，以确保完整路径相同。

编辑：这对您的情况有用吗？创建一个控制台应用程序并将其粘贴到整个 Program.cs 文件中。向 AreEquals() 函数提供两个 DirectoryInfo 对象，如果它们是同一个目录，它将返回 True。如果您愿意，您也许可以将此 AreEquals() 方法调整为 DirectoryInfo 上的扩展方法，因此您可以这样做 myDirectoryInfo.IsEquals(myOtherDirectoryInfo);

using System;
using System.Diagnostics;
using System.IO;
using System.Collections.Generic;

namespace ConsoleApplication3
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(AreEqual(
                new DirectoryInfo("C:\\Scratch"),
                new DirectoryInfo("C:\\Scratch\\")));

            Console.WriteLine(AreEqual(
                new DirectoryInfo("C:\\Windows\\Microsoft.NET\\Framework"),
                new DirectoryInfo("C:\\Windows\\Microsoft.NET\\Framework\\v3.5\\1033\\..\\..")));

            Console.WriteLine(AreEqual(
                new DirectoryInfo("C:\\Scratch\\"),
                new DirectoryInfo("C:\\Scratch\\4760\\..\\..")));

            Console.WriteLine("Press ENTER to continue");
            Console.ReadLine();
        }

        private static bool AreEqual(DirectoryInfo dir1, DirectoryInfo dir2)
        {
            DirectoryInfo parent1 = dir1;
            DirectoryInfo parent2 = dir2;

            /* Build a list of parents */
            List<string> folder1Parents = new List<string>();
            List<string> folder2Parents = new List<string>();

            while (parent1 != null)
            {
                folder1Parents.Add(parent1.Name);
                parent1 = parent1.Parent;
            }

            while (parent2 != null)
            {
                folder2Parents.Add(parent2.Name);
                parent2 = parent2.Parent;
            }

            /* Now compare the lists */

            if (folder1Parents.Count != folder2Parents.Count)
            {
                // Cannot be the same - different number of parents
                return false;
            }

            bool equal = true;

            for (int i = 0; i < folder1Parents.Count && i < folder2Parents.Count; i++)
            {
                equal &= folder1Parents[i] == folder2Parents[i];
            }

            return equal;
        }
    }
}

Answer 9

您可以使用 Minimatch，它是 Node.js 的 minimatch 的一个端口。

var mm = new Minimatcher(searchPattern, new Options { AllowWindowsPaths = true });

if (mm.IsMatch(somePath))
{
    // The path matches!  Do some cool stuff!
}

var matchingPaths = mm.Filter(allPaths);

See why AllowWindowsPaths = true 选项是必需的：

在 Windows 风格的路径上 Minimatch 的语法是为 Linux 风格的路径设计的（只有正斜杠）。特别是，它使用反斜杠作为转义字符，因此它不能简单地接受 Windows 样式的路径。我的 C# 版本保留了这种行为。

要抑制这种情况，并允许反斜杠和正斜杠作为路径分隔符（在模式或输入中），请设置 AllowWindowsPaths 选项：

var mm = new Minimatcher(searchPattern, new Options { AllowWindowsPaths = true });

传递此选项将完全禁用转义字符。

Nuget： http://www.nuget.org/packages/Minimatch/

GitHub： https://github.com/SLaks/Minimatch

Answer 10

using System;
using System.Collections.Generic;
using System.Text;

namespace EventAnalysis.IComparerImplementation
{

    public sealed class FSChangeElemComparerByPath : IComparer<FSChangeElem>
    {
        public int Compare(FSChangeElem firstPath, FSChangeElem secondPath)
        {
            return firstPath.strObjectPath == null ?
                (secondPath.strObjectPath == null ? 0 : -1) :
                (secondPath.strObjectPath == null ? 1 : ComparerWrap(firstPath.strObjectPath, secondPath.strObjectPath));
        }

        private int ComparerWrap(string stringA, string stringB)
        {
            int length = 0;
            int start = 0;
            List<string> valueA = new List<string>();
            List<string> valueB = new List<string>();

            ListInit(ref valueA, stringA);
            ListInit(ref valueB, stringB);

            if (valueA.Count != valueB.Count)
            {
                length = (valueA.Count > valueB.Count)
                           ? valueA.Count : valueB.Count;

                if (valueA.Count != length)
                {
                    for (int i = 0; i < length - valueA.Count; i++)
                    {
                        valueA.Add(string.Empty);
                    }
                }
                else
                {
                    for (int i = 0; i < length - valueB.Count; i++)
                    {
                        valueB.Add(string.Empty);
                    }
                }
            }

            else
                length = valueA.Count;

            return RecursiveComparing(valueA, valueB, length, start);
        }

        private void ListInit(ref List<string> stringCollection, string stringToList)
        {
            foreach (string s in stringToList.Remove(0, 2).Split('\\'))
            {
                stringCollection.Add(s);
            }
        }

        private int RecursiveComparing(List<string> valueA, List<string> valueB, int length, int start)
        {
            int result = 0;

            if (start != length)
            {
                if (valueA[start] == valueB[start])
                {
                    result = RecursiveComparing(valueA, valueB, length, ++start);
                }
                else
                {
                    result = String.Compare(valueA[start], valueB[start]);
                }
            }
            else
                return 0;

            return result;
        }
    }
}

Answer 11

我自己用递归解决了这个问题。

 public bool PathEquals(string Path1, string Path2)
 {
     FileInfo f1 = new FileInfo(Path1.Trim('\\','/','.'));
     FileInfo f2 = new FileInfo(Path2.Trim('\\', '/','.'));
     if(f1.Name.ToLower() == f2.Name.ToLower())
     {
         return DirectoryEquals(f1.Directory, f2.Directory);
     }
     else
     {
         return false;
     }
}

public bool DirectoryEquals(DirectoryInfo d1, DirectoryInfo d2)
{
    if(d1.Name.ToLower() == d2.Name.ToLower())
    {
        if((d1.Parent != null) && (d2.Parent != null))
        {
            return DirectoryEquals(d1.Parent, d2.Parent);
        }
        else
        {
            return true;//C:\Temp1\Temp2 equals \Temp1\Temp2
            //return (d1.Parent == null) && (d2.Parent == null);//C:\Temp1\Temp2 does not equal \Temp1\Temp2
        }
    }
    else
    {
        return false;
    }
}

注意：new FileInfo(path) 会返回有效的 FileInfo，即使路径不是文件（名称字段等于目录名称）

Answer 12

谢谢@Andy Shellam 和 @VladV 和 @Eamon Nerbonne

我找到了另一个解决方案：

        private static bool AreEqual(DirectoryInfo dir1, DirectoryInfo dir2)
        {
            return AreEqual(dir1.FullName, dir2.FullName);
        }

        private static bool AreEqual(string folderPath1, string folderPath2)
        {
            folderPath1 = Path.GetFullPath(folderPath1);
            folderPath2 = Path.GetFullPath(folderPath2);

            if (folderPath1.Length == folderPath2.Length)
            {
                return string.Equals(folderPath1, folderPath2/*, StringComparison.OrdinalIgnoreCase*/);
            }
            else if (folderPath1.Length == folderPath2.Length + 1 && IsEndWithAltDirectorySeparatorChar(folderPath1))
            {
                // folderPath1 = @"F:\temp\"
                // folderPath2 = @"F:\temp"
                return folderPath1.Contains(folderPath2 /*, StringComparison.OrdinalIgnoreCase*/);
            }
            else if (folderPath1.Length + 1 == folderPath2.Length && IsEndWithAltDirectorySeparatorChar(folderPath2))
            {
                // folderPath1 = @"F:\temp"
                // folderPath2 = @"F:\temp\"
                return folderPath2.Contains(folderPath1 /*, StringComparison.OrdinalIgnoreCase*/);
            }

            return false;

            static bool IsEndWithAltDirectorySeparatorChar(string path)
            {
                var lastChar = path[path.Length - 1];
                return lastChar == Path.DirectorySeparatorChar;
            }
        }

它可以很好地工作。

        static void Main(string[] args)
        {
            Console.WriteLine(AreEqual(
                new DirectoryInfo("C:\\Scratch"),
                new DirectoryInfo("C:\\Scratch\\")));

            Console.WriteLine(AreEqual(
                new DirectoryInfo("C:\\Windows\\Microsoft.NET\\Framework"),
                new DirectoryInfo("C:\\Windows\\Microsoft.NET\\Framework\\v3.5\\1033\\..\\..")));

            Console.WriteLine(AreEqual(
                new DirectoryInfo("C:\\Scratch\\"),
                new DirectoryInfo("C:\\Scratch\\4760\\..\\..")));

            Debug.WriteLine(AreEqual(@"C:/Temp", @"C:\Temp2")); // False
            Debug.WriteLine(AreEqual(@"C:\Temp\", @"C:\Temp2"));// False
            Debug.WriteLine(AreEqual(@"C:\Temp\", @"C:\Temp")); // True
            Debug.WriteLine(AreEqual(@"C:\Temp/", @"C:\Temp")); // True
            Debug.WriteLine(AreEqual(@"C:/Temp/", @"C:\Temp\"));// True

            Console.WriteLine("Press ENTER to continue");
            Console.ReadLine();
        }

Answer 13

bool equals = myDirectoryInfo1.FullName == myDirectoryInfo2.FullName;

?

Answer 14

bool Equals(string path1, string path2)
{
    return new Uri(path1) == new Uri(path2);
}

Uri 构造函数规范化路径。