在.NET中计算目录大小的最佳方法是什么？

我编写了以下例程来手动遍历目录并在C＃/。NET中计算其大小：

protected static float CalculateFolderSize(string folder)
{
    float folderSize = 0.0f;
    try
    {
        //Checks if the path is valid or not
        if (!Directory.Exists(folder))
            return folderSize;
        else
        {
            try
            {
                foreach (string file in Directory.GetFiles(folder))
                {
                    if (File.Exists(file))
                    {
                        FileInfo finfo = new FileInfo(file);
                        folderSize += finfo.Length;
                    }
                }

                foreach (string dir in Directory.GetDirectories(folder))
                    folderSize += CalculateFolderSize(dir);
            }
            catch (NotSupportedException e)
            {
                Console.WriteLine("Unable to calculate folder size: {0}", e.Message);
            }
        }
    }
    catch (UnauthorizedAccessException e)
    {
        Console.WriteLine("Unable to calculate folder size: {0}", e.Message);
    }
    return folderSize;
}

我有一个针对大量文件夹重复运行此例程的应用程序。我想知道是否有更有效的方法来使用.NET计算文件夹的大小？我没有看到框架中的任何特定内容。我应该使用P / Invoke和Win32 API吗？在.NET中计算文件夹大小的最有效方法是什么？

我不相信有Win32 API可以计算目录消耗的空间，尽管我对此有待纠正。如果有的话，我会假设资源管理器会使用它。如果您在资源管理器中获得了一个大目录的属性，则为您提供文件夹大小所花费的时间与其所包含的文件/子目录的数量成正比。

您的例程看起来相当整洁和简单。请记住，您是在计算文件长度的总和，而不是磁盘上实际消耗的空间。群集末尾的浪费空间，文件流等消耗的空间将被忽略。

不，这看起来是推荐的计算目录大小的方法，下面是relevent方法：

public static long DirSize(DirectoryInfo d) 
{    
    long size = 0;    
    // Add file sizes.
    FileInfo[] fis = d.GetFiles();
    foreach (FileInfo fi in fis) 
    {      
        size += fi.Length;    
    }
    // Add subdirectory sizes.
    DirectoryInfo[] dis = d.GetDirectories();
    foreach (DirectoryInfo di in dis) 
    {
        size += DirSize(di);   
    }
    return size;  
}

您将以root身份调用：

Console.WriteLine("The size is {0} bytes.", DirSize(new DirectoryInfo(targetFolder));

...targetFolder要计算的文件夹大小在哪里。

DirectoryInfo dirInfo = new DirectoryInfo(@strDirPath);
long dirSize = await Task.Run(() => dirInfo.EnumerateFiles( "*", SearchOption.AllDirectories).Sum(file => file.Length));

public static long DirSize(DirectoryInfo dir)
{
    return dir.GetFiles().Sum(fi => fi.Length) +
           dir.GetDirectories().Sum(di => DirSize(di));
}

真正的问题是 您打算将尺寸用于什么？

您的第一个问题是至少有四个“文件大小”定义：

• “文件末尾”偏移量，即从文件开头到结尾必须跳过的字节数。
  换句话说，它是字节数文件中逻辑上（从使用角度来看）。

• “有效数据长度”等于未实际存储的第一个字节的偏移量。
  它始终小于或等于“文件结尾”，并且是群集大小的倍数。
  例如，一个1 GB的文件可以具有1 MB的有效数据长度。如果您要求Windows读取前8 MB，它将读取前1 MB并假装其余数据在那里，将其返回为零。

• 文件的“分配大小”。它始终大于或等于“文件末尾”。
  这是操作系统为文件分配的群集数乘以群集大小。
  与“文件结尾”大于“有效数据长度”的情况不同，多余的字节不被视为文件数据的一部分，因此，如果您尝试读入，操作系统将不会用零填充缓冲区。文件末尾以外的分配区域。

• 文件的“压缩大小”，仅对压缩（和稀疏？）文件有效。
  它等于集群的大小乘以卷上实际分配给该文件的集群的数量。
  对于非压缩和非稀疏文件，没有“压缩大小”的概念。您将改为使用“分配的大小”。

您的第二个问题是，类似的“文件”C:\Foo实际上可以具有多个数据流。
此名称仅指默认流。文件可能具有备用流，例如C:\Foo:Bar，其大小甚至不会在资源管理器中显示！

您的第三个问题是“文件”可以有多个名称（“硬链接”）。
例如，C:\Windows\notepad.exe并且C:\Windows\System32\notepad.exe是两个名称的相同文件。 可以使用任何名称打开文件的任何流。

您的第四个问题是“文件”（或目录）实际上甚至可能不是文件（或目录）：
它可能是软链接到其他文件（“符号链接”或“重新解析点”）（或目录）。
该其他文件甚至可能不在同一驱动器上。它甚至可能指向网络上的某些内容，或者甚至可能是递归的！如果是递归的，尺寸应该是无穷大吗？

您的第五个问题是有一些使某些文件或目录看起来像实际文件或目录的“过滤器”驱动程序，即使它们并非如此。例如，可以使用称为ImageX的工具将Microsoft的WIM图像文件（已压缩）“挂载”在文件夹上，而不会像重分析点或链接。它们看起来就像目录-只是它们实际上不是目录，而且“大小”的概念对他们而言实际上没有任何意义。

您的第六个问题是每个文件都需要元数据。
例如，同一文件具有10个名称需要更多的元数据，这需要空间。如果文件名短，那么拥有10个名称可能和拥有1个名称一样便宜；如果文件名很长，那么拥有多个名称可能会占用更多的磁盘空间用于元数据。（具有多个流的同一个故事，等等。）
您也算这些吗？

var size = new DirectoryInfo("E:\\").GetDirectorySize();

这是此扩展方法背后的代码

public static long GetDirectorySize(this System.IO.DirectoryInfo directoryInfo, bool recursive = true)
{
    var startDirectorySize = default(long);
    if (directoryInfo == null || !directoryInfo.Exists)
        return startDirectorySize; //Return 0 while Directory does not exist.

    //Add size of files in the Current Directory to main size.
    foreach (var fileInfo in directoryInfo.GetFiles())
        System.Threading.Interlocked.Add(ref startDirectorySize, fileInfo.Length);

    if (recursive) //Loop on Sub Direcotries in the Current Directory and Calculate it's files size.
        System.Threading.Tasks.Parallel.ForEach(directoryInfo.GetDirectories(), (subDirectory) =>
    System.Threading.Interlocked.Add(ref startDirectorySize, GetDirectorySize(subDirectory, recursive)));

    return startDirectorySize;  //Return full Size of this Directory.
}

看来，以下方法比递归函数执行任务的速度更快：

long size = 0;
DirectoryInfo dir = new DirectoryInfo(folder);
foreach (FileInfo fi in dir.GetFiles("*.*", SearchOption.AllDirectories))
{
   size += fi.Length;
}

一个简单的控制台应用程序测试表明，此循环比递归函数对文件进行汇总的速度更快，并提供相同的结果。您可能想使用LINQ方法（如Sum（））来缩短此代码。

更多更快！添加COM参考“ Windows脚本宿主对象...”

public double GetWSHFolderSize(string Fldr)
    {
        //Reference "Windows Script Host Object Model" on the COM tab.
        IWshRuntimeLibrary.FileSystemObject FSO = new     IWshRuntimeLibrary.FileSystemObject();
        double FldrSize = (double)FSO.GetFolder(Fldr).Size;
        Marshal.FinalReleaseComObject(FSO);
        return FldrSize;
    }
private void button1_Click(object sender, EventArgs e)
        {
            string folderPath = @"C:\Windows";
        Stopwatch sWatch = new Stopwatch();

        sWatch.Start();
        double sizeOfDir = GetWSHFolderSize(folderPath);
        sWatch.Stop();
        MessageBox.Show("Directory size in Bytes : " + sizeOfDir + ", Time: " + sWatch.ElapsedMilliseconds.ToString());
          }

该解决方案效果很好。它正在收集所有子文件夹：

Directory.GetFiles(@"MainFolderPath", "*", SearchOption.AllDirectories).Sum(t => (new FileInfo(t).Length));

直到最近我一直在摆弄VS2008和LINQ，这种紧凑而简短的方法对我来说非常有用（示例在VB.NET中；当然需要LINQ / .NET FW 3.5+）：

Dim size As Int64 = (From strFile In My.Computer.FileSystem.GetFiles(strFolder, _
              FileIO.SearchOption.SearchAllSubDirectories) _
              Select New System.IO.FileInfo(strFile).Length).Sum()

它简短，它搜索子目录，如果您知道LINQ语法，则很容易理解。您甚至可以使用.GetFiles函数的第三个参数指定通配符来搜索特定文件。

我不是C＃专家，但是您可以通过这种方式在C＃上添加My名称空间。

我认为这种获取文件夹大小的方法不仅比Hao的链接中描述的方法更短，更现代，而且基本上使用了最后描述的相同的FileInfo循环。

这是计算目录大小的最佳方法。仅有其他方法仍将使用递归，但使用起来会更容易并且不那么灵活。

float folderSize = 0.0f;
FileInfo[] files = Directory.GetFiles(folder, "*", SearchOption.AllDirectories);
foreach(FileInfo file in files) folderSize += file.Length;

我使用相同的计数原理扩展了@Hao的答案，但支持更丰富的数据返回，因此您获得了N个级别的返回大小，递归大小，目录计数和递归目录计数。

public class DiskSizeUtil
{
    /// <summary>
    /// Calculate disk space usage under <paramref name="root"/>.  If <paramref name="levels"/> is provided, 
    /// then return subdirectory disk usages as well, up to <paramref name="levels"/> levels deep.
    /// If levels is not provided or is 0, return a list with a single element representing the
    /// directory specified by <paramref name="root"/>.
    /// </summary>
    /// <returns></returns>
    public static FolderSizeInfo GetDirectorySize(DirectoryInfo root, int levels = 0)
    {
        var currentDirectory = new FolderSizeInfo();

        // Add file sizes.
        FileInfo[] fis = root.GetFiles();
        currentDirectory.Size = 0;
        foreach (FileInfo fi in fis)
        {
            currentDirectory.Size += fi.Length;
        }

        // Add subdirectory sizes.
        DirectoryInfo[] dis = root.GetDirectories();

        currentDirectory.Path = root;
        currentDirectory.SizeWithChildren = currentDirectory.Size;
        currentDirectory.DirectoryCount = dis.Length;
        currentDirectory.DirectoryCountWithChildren = dis.Length;
        currentDirectory.FileCount = fis.Length;
        currentDirectory.FileCountWithChildren = fis.Length;

        if (levels >= 0)
            currentDirectory.Children = new List<FolderSizeInfo>();

        foreach (DirectoryInfo di in dis)
        {
            var dd = GetDirectorySize(di, levels - 1);
            if (levels >= 0)
                currentDirectory.Children.Add(dd);

            currentDirectory.SizeWithChildren += dd.SizeWithChildren;
            currentDirectory.DirectoryCountWithChildren += dd.DirectoryCountWithChildren;
            currentDirectory.FileCountWithChildren += dd.FileCountWithChildren;
        }

        return currentDirectory;
    }

    public class FolderSizeInfo
    {
        public DirectoryInfo Path { get; set; }
        public long SizeWithChildren { get; set; }
        public long Size { get; set; }
        public int DirectoryCount { get; set; }
        public int DirectoryCountWithChildren { get; set; }
        public int FileCount { get; set; }
        public int FileCountWithChildren { get; set; }
        public List<FolderSizeInfo> Children { get; set; }
    }
}

public static long GetDirSize(string path)
{
    try
    {
        return Directory.EnumerateFiles(path).Sum(x => new FileInfo(x).Length)  
            +
               Directory.EnumerateDirectories(path).Sum(x => GetDirSize(x));
    }
    catch
    {
        return 0L;
    }
}

就最好的算法而言，您可能是正确的。我建议您拆开递归函数并使用自己的堆栈（请记住，.Net 2.0+应用程序中的堆栈溢出是世界末日，无法捕获IIRC异常）。

最重要的是，如果您以任何形式的UI使用它，请将其放在工作线程上，该线程向UI线程发出更新信号。

为了提高性能，您可以使用任务并行库（TPL）。这是一个很好的示例：目录文件大小计算-如何使其更快？

我没有测试它，但是作者说它比非多线程方法快3倍...

Trikaldarshi单线解决方案的替代方案。（它避免构造FileInfo对象）

long sizeInBytes = Directory.EnumerateFiles("{path}","*", SearchOption.AllDirectories).Sum(fileInfo => new FileInfo(fileInfo).Length);

Directory.GetFiles(@"C:\Users\AliBayat","*",SearchOption.AllDirectories)
.Select (d => new FileInfo(d))
.Select (d => new { Directory = d.DirectoryName,FileSize = d.Length} )
.ToLookup (d => d.Directory )
.Select (d => new { Directory = d.Key,TotalSizeInMB =Math.Round(d.Select (x =>x.FileSize)
.Sum () /Math.Pow(1024.0,2),2)})
.OrderByDescending (d => d.TotalSizeInMB).ToList();

调用GetFileswithSearchOption.AllDirectories返回subdirectories指定目录的所有目录中所有文件的全名。OS表示文件大小（以字节为单位）。您可以从文件的长度属性中检索文件的大小。用1024除以2的幂可以得到文件的大小（以兆字节为单位）。因为目录/文件夹可以包含许多文件，所以d.Select(x => x.FileSize)返回以兆字节为单位的文件大小的集合。最后致电Sum()查找指定目录中文件的总大小。

更新：filterMask =“ 。 ”不适用于没有扩展名的文件

我想出的最快方法是将EnumerateFiles与SearchOption.AllDirectories一起使用。此方法还允许在浏览文件并计算大小时更新UI。长路径名不会引起任何问题，因为不会尝试为长路径名创建FileInfo或DirectoryInfo。在枚举文件时，即使文件名很长，只要起始目录名称不太长，EnumerateFiles返回的FileInfo都不会引起问题。UnauthorizedAccess仍然存在问题。

    private void DirectoryCountEnumTest(string sourceDirName)
    {
        // Get the subdirectories for the specified directory.
        long dataSize = 0;
        long fileCount = 0;
        string prevText = richTextBox1.Text;

        if (Directory.Exists(sourceDirName))
        {
            DirectoryInfo dir = new DirectoryInfo(sourceDirName);
            foreach (FileInfo file in dir.EnumerateFiles("*", SearchOption.AllDirectories))
            {
                fileCount++;
                try
                {
                    dataSize += file.Length;
                    richTextBox1.Text = prevText + ("\nCounting size: " + dataSize.ToString());
                }
                catch (Exception e)
                {
                    richTextBox1.AppendText("\n" + e.Message);
                }
            }
            richTextBox1.AppendText("\n files:" + fileCount.ToString());
        }
    }

此.NET Core命令行应用程序在这里计算给定路径的目录大小：

https://github.com/garethrbrown/folder-size

关键方法是这种递归检查子目录以得出总大小的方法。

private static long DirectorySize(SortDirection sortDirection, DirectoryInfo directoryInfo, DirectoryData directoryData)
{
        long directorySizeBytes = 0;

        // Add file sizes for current directory

        FileInfo[] fileInfos = directoryInfo.GetFiles();

        foreach (FileInfo fileInfo in fileInfos)
        {
            directorySizeBytes += fileInfo.Length;
        }

        directoryData.Name = directoryInfo.Name;

        directoryData.SizeBytes += directorySizeBytes;

        // Recursively add subdirectory sizes

        DirectoryInfo[] subDirectories = directoryInfo.GetDirectories();

        foreach (DirectoryInfo di in subDirectories)
        {
            var subDirectoryData = new DirectoryData(sortDirection);

            directoryData.DirectoryDatas.Add(subDirectoryData);

            directorySizeBytes += DirectorySize(sortDirection, di, subDirectoryData);
        }

        directoryData.SizeBytes = directorySizeBytes;

        return directorySizeBytes;
    }
}

从Microsoft Docs计算目录大小的多线程示例，这样会更快

using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      long totalSize = 0;

      String[] args = Environment.GetCommandLineArgs();
      if (args.Length == 1) {
         Console.WriteLine("There are no command line arguments.");
         return;
      }
      if (! Directory.Exists(args[1])) {
         Console.WriteLine("The directory does not exist.");
         return;
      }

      String[] files = Directory.GetFiles(args[1]);
      Parallel.For(0, files.Length,
                   index => { FileInfo fi = new FileInfo(files[index]);
                              long size = fi.Length;
                              Interlocked.Add(ref totalSize, size);
                   } );
      Console.WriteLine("Directory '{0}':", args[1]);
      Console.WriteLine("{0:N0} files, {1:N0} bytes", files.Length, totalSize);
   }
}
// The example displaysoutput like the following:
//       Directory 'c:\windows\':
//       32 files, 6,587,222 bytes

本示例仅计算当前文件夹中的文件，因此，如果要递归计算所有文件，则可以更改

String[] files = Directory.GetFiles(args[1]);

至

String[] files = Directory.GetFiles(args[1], "*", SearchOption.AllDirectories);

我尝试更改示例（Alexandre Pepin和hao的答案）

照原样

    private long GetDirectorySize(string dirPath)
    {
        if (Directory.Exists(dirPath) == false)
        {
            return 0;
        }

        DirectoryInfo dirInfo = new DirectoryInfo(dirPath);

        long size = 0;

        // Add file sizes.
        FileInfo[] fis = dirInfo.GetFiles();
        foreach (FileInfo fi in fis)
        {
            size += fi.Length;
        }

        // Add subdirectory sizes.
        DirectoryInfo[] dis = dirInfo.GetDirectories();
        foreach (DirectoryInfo di in dis)
        {
            size += GetDirectorySize(di.FullName);
        }

        return size;
    }

成为

    private long GetDirectorySize2(string dirPath)
    {
        if (Directory.Exists(dirPath) == false)
        {
            return 0;
        }

        DirectoryInfo dirInfo = new DirectoryInfo(dirPath);

        long size = 0;

        // Add file sizes.
        IEnumerable<FileInfo> fis = dirInfo.EnumerateFiles("*.*", SearchOption.AllDirectories);
        foreach (FileInfo fi in fis)
        {
            size += fi.Length;
        }

        return size;
    }

最后你可以检查结果

        // ---------------------------------------------
        // size of directory
        using System.IO;

        string log1Path = @"D:\SampleDirPath1";
        string log2Path = @"D:\SampleDirPath2";
        string log1DirName = Path.GetDirectoryName(log1Path);
        string log2DirName = Path.GetDirectoryName(log2Path);
        long log1Size = GetDirectorySize(log1Path);
        long log2Size = GetDirectorySize(log2Path);
        long log1Size2 = GetDirectorySize2(log1Path);
        long log2Size2 = GetDirectorySize2(log2Path);

        Console.WriteLine($@"{log1DirName} Size: {SizeSuffix(log1Size)}, {SizeSuffix(log1Size2)}
        {log2DirName} Size: {SizeSuffix(log2Size)}, {SizeSuffix(log2Size2)}");

这是SizeSuffix函数

    private static readonly string[] SizeSuffixes =
               { "bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB" };

    /// <summary>
    /// Size Display
    /// </summary>
    /// <param name="value">bytes 數值</param>
    /// <param name="decimalPlaces">小數位數</param>
    /// <returns></returns>
    public static string SizeSuffix(Int64 value, int decimalPlaces = 2)
    {
        if (decimalPlaces < 0) { throw new ArgumentOutOfRangeException("decimalPlaces"); }
        if (value < 0) { return "-" + SizeSuffix(-value); }
        if (value == 0) { return string.Format("{0:n" + decimalPlaces + "} bytes", 0); }

        // mag is 0 for bytes, 1 for KB, 2, for MB, etc.
        int mag = (int)Math.Log(value, 1024);

        // 1L << (mag * 10) == 2 ^ (10 * mag) 
        // [i.e. the number of bytes in the unit corresponding to mag]
        decimal adjustedSize = (decimal)value / (1L << (mag * 10));

        // make adjustment when the value is large enough that
        // it would round up to 1000 or more
        if (Math.Round(adjustedSize, decimalPlaces) >= 1000)
        {
            mag += 1;
            adjustedSize /= 1024;
        }

        return string.Format("{0:n" + decimalPlaces + "} {1}",
            adjustedSize,
            SizeSuffixes[mag]);
    }

我知道这不是一个.net解决方案，但是无论如何它都来了。也许对于拥有Windows 10并想要更快解决方案的人来说很方便。例如，如果您在命令提示符下运行此命令或按winKey + R：

bash -c "du -sh /mnt/c/Users/; sleep 5"    

该sleep 5是让你有时间看到的结果，窗户没有关闭

在我的电脑上显示：

最后请注意，它显示的是85G（85 GB）。与使用.Net相比，它超级快。如果要更准确地查看尺寸，请删除h代表人类可读的尺寸。

因此，只要执行类似这样的操作，Processes.Start("bash",... arguments)那不是确切的代码，但您会明白的。