Question

我需要计算数以百计的夹员的大小,有些人将是10德国马克,有些可能是10德国马克,但我需要一种超快的方法,利用C#,使每组人的规模达到。

我希望,我的最终结果将是:

Folder1 10.5GB

Folder2 230MB

Folder3 1.2GB

......

Answer 1

There is no simple way to do this in .Net; you will have to loop through every file and subdir. See the examples here to see how it s done.

Answer 2

添加提及Microsoft 字典的运行时间和使用:

Scripting.FileSystemObject fso = new Scripting.FileSystemObject();
Scripting.Folder folder = fso.GetFolder([folder path]);
Int64 dirSize = (Int64)folder.Size;

如果你需要这个规模的话,那比休养更快。

Answer 3

这是可怕的,但......

使用称为消化器的抗反射剂量器。批号:

@ECHO OFF
IF %1x==x GOTO start
IF %1x==DODIRx GOTO dodir
SET CURDIR=%1
FOR /F "usebackq delims=" %%A IN (`%0 DODIR`) DO SET ANSWER=%%A %CURDIR%
ECHO %ANSWER%
GOTO end
:start
FOR /D %%D IN (*.*) DO CALL %0 "%%D"
GOTO end
:dodir
DIR /S/-C %CURDIR% | FIND "File(s)"
GOTO end
:end

注:应在第5行“%A”之后,而不是在空间之后添加一个表格。

这是你重新研究的数据。它将迅速处理数千份档案。事实上,我整整整整整整整整整整整整整整整整整整整整整整两秒。

摘录如下:dirsize /R /+25,以便首先列出最大的名录。

Good luck.

Answer 4

如果你正确点出一幅大的目录,那么你可以发现,计算规模需要大量时间...... 我不认为我们可以这样做。你们可以做的一件事是,如果你将计算这些目录/子公司的规模,就会大大加快速度。

您可以采取类似做法,计算C#的海床位。

static long DirSize(DirectoryInfo directory)
{
    long size = 0;

    FileInfo[] files = directory.GetFiles();
    foreach (FileInfo file in files)
    {
        size += file.Length;
    }

    DirectoryInfo[] dirs = directory.GetDirectories();

    foreach (DirectoryInfo dir in dirs)
    {
        size += DirSize(dir);
    }

    return size;
}

Answer 5

你可以做这样的事情,但是,在达到倍数时,没有迅速的介入,你必须增加档案规模。

    private static IDictionary<string, long> folderSizes;

    public static long GetDirectorySize(string dirName)
    {
        // use memoization to keep from doing unnecessary work
        if (folderSizes.ContainsKey(dirName))
        {
            return folderSizes[dirName];
        }

        string[] a = Directory.GetFiles(dirName, "*.*");

        long b = 0;
        foreach (string name in a)
        {
            FileInfo info = new FileInfo(name);
            b += info.Length;
        }

        // recurse on all the directories in current directory
        foreach (string d in Directory.GetDirectories(dirName))
        {
            b += GetDirectorySize(d);
        }

        folderSizes[dirName] = b;
        return b;
    }

    static void Main(string[] args)
    {
        folderSizes = new Dictionary<string, long>();
        GetDirectorySize(@"c:StartingFolder");
        foreach (string key in folderSizes.Keys)
        {
            Console.WriteLine("dirName = " + key + " dirSize = " + folderSizes[key]);
        }

        // now folderSizes will contain a key for each directory (starting
        // at c:StartingFolder and including all subdirectories), and
        // the dictionary value will be the folder size
    }

Answer 6

Dot Net珠s 采用的方法与此处描述的方法相似。令人惊讶的是,。阶级并没有这样做的方法,因为它似乎是一种共同的需要,如果不在每个档案系统标的上进行本土/管理的过渡,那么这样做可能更快。我确实认为,如果速度是关键,就写出一个未经管理的物体来进行这一计算,然后从有管理的法典中将其称为每名录一次。

Answer 7

4.0-4.5框架最快的方法是,我可以找到计算文件规模和在磁盘上点的文件:

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

class FileCounter
{
  private readonly int _clusterSize;
  private long _filesCount;
  private long _size;
  private long _diskSize;

  public void Count(string rootPath)
  {
    // Enumerate files (without real execution of course)
    var filesEnumerated = new DirectoryInfo(rootPath)
                              .EnumerateFiles("*", SearchOption.AllDirectories);
    // Do in parallel
    Parallel.ForEach(filesEnumerated, GetFileSize);
  }

  /// <summary>
  /// Get real file size and add to total
  /// </summary>
  /// <param name="fileInfo">File information</param>
  private void GetFileSize(FileInfo fileInfo)
  {
    Interlocked.Increment(ref _filesCount);
    Interlocked.Add(ref _size, fileInfo.Length);
  }
}

var fcount = new FileCounter("F:\temp");
fcount.Count();

这种做法对我来说似乎是我能够在网上平台上找到的最佳办法。如果你需要计算组群大小和磁盘上的实际大小,你可以做以下工作:

using System.Runtime.InteropServices;

private long WrapToClusterSize(long originalSize)
    {
        return ((originalSize + _clusterSize - 1) / _clusterSize) * _clusterSize;
    }

private static int GetClusterSize(string rootPath)
    {
        int sectorsPerCluster = 0, bytesPerSector = 0, numFreeClusters = 0, totalNumClusters = 0;
        if (!GetDiskFreeSpace(rootPath, ref sectorsPerCluster, ref bytesPerSector, ref numFreeClusters,
                              ref totalNumClusters))
        {
            // Satisfies rule CallGetLastErrorImmediatelyAfterPInvoke.
            // see http://msdn.microsoft.com/en-us/library/ms182199(v=vs.80).aspx
            var lastError = Marshal.GetLastWin32Error();
            throw new Exception(string.Format("Error code {0}", lastError));
        }
        return sectorsPerCluster * bytesPerSector;
    }
[DllImport(Kernel32DllImport, SetLastError = true)]
    private static extern bool GetDiskFreeSpace(
        string rootPath,
        ref int sectorsPerCluster,
        ref int bytesPerSector,
        ref int numFreeClusters,
        ref int totalNumClusters);

当然,你需要在第一部法典中重写“GetFileSize”:

private long _diskSize;
private void GetFileSize(FileInfo fileInfo)
    {
        Interlocked.Increment(ref _filesCount);
        Interlocked.Add(ref _size, fileInfo.Length);
        Interlocked.Add(ref _diskSize, WrapToClusterSize(fileInfo.Length));
    }

Answer 8

。 (尽管它是在沙捞取)来自一个经历类似业绩问题的人。您可尝试把标题定在 Win32 ,看看看业绩是否有所改善,但归根结底,你会重新处理同一问题:一项任务只能迅速完成,如果你不得不做很多工作,将需要很多时间。您能更详细地说明您为之做了哪些工作? 它可以帮助民生们带着istic或一些che来帮助你们。如果你做大量计算,你是否将结果付诸东流?

Answer 9

I m quite sure that this will be slow as hell, but I d write it like this:

using System.IO;

long GetDirSize(string dir) {
   return new DirectoryInfo(dir)
      .GetFiles("", SearchOption.AllDirectories)
      .Sum(p => p.Length);
}

友情链接