Effizientere Methode, Verzeichnis, Größe

Hab ich auch schon bauen Sie eine rekursive Funktion, um das Verzeichnis, die Größe eines Ordners Weg. Es funktioniert, doch mit der wachsenden Anzahl der Verzeichnisse, die ich habe durchsuchen und die Anzahl der Dateien im jeweiligen Ordner), dies ist eine sehr langsame, ineffiziente Methode.

static string GetDirectorySize(string parentDir)
{
    long totalFileSize = 0;

    string[] dirFiles = Directory.GetFiles(parentDir, "*.*", 
                            System.IO.SearchOption.AllDirectories);

    foreach (string fileName in dirFiles)
    {
        //Use FileInfo to get length of each file.
        FileInfo info = new FileInfo(fileName);
        totalFileSize = totalFileSize + info.Length;
    }
    return String.Format(new FileSizeFormatProvider(), "{0:fs}", totalFileSize);
}

Dies ist die Suche in allen Unterverzeichnissen für das argument Weg, so dass die dirFiles array wird ziemlich gross. Gibt es eine bessere Methode, dies zu erreichen? Ich habe gesucht, aber nicht gefunden habe, noch nichts.

Andere Idee, die mein Sinn gekommen war, setzen die Ergebnisse in einem cache, und, wenn die Funktion erneut aufgerufen wird, versuchen Sie und finden Sie die Unterschiede und nur Forschungs-Ordner, die geändert wurden. Nicht sicher, ob das eine gute Sache...

  • Dies ist eine weitaus kompliziertere Frage, dann würden Sie sich vorstellen. Ich würde vorschlagen, den Aufruf in eine win32-api-Methode für so etwas.
  • stackoverflow.com/q/128618/284240
  • Schauen Sie durch diese parallele Lösung stackoverflow.com/questions/2979432/...
  • Array-Größe ist ziemlich irrelevant, die Kosten sind zu 99,9% schlagen die Festplatte. Werden Sie zu zahlen haben, mindestens einmal, können Sie inkrementelle updates nach, die von FileSystemWatcher.
InformationsquelleAutor ikathegreat | 2012-03-22
  1. 25

    Sind, werden Sie zuerst Scannen Sie den Baum, um eine Liste aller Dateien. Dann sind Sie Wiedereröffnung jeder Datei, um seine Größe. Dieser beläuft sich auf zweimal Scannen.

    Schlage ich vor, Sie DirectoryInfo.GetFiles die hand, die Sie FileInfo - Objekte direkt. Diese Objekte sind vor-gefüllt mit Ihrer Länge.

    In .NET 4 Sie können auch die EnumerateFiles Methode zurückgeben wird, Sie faul IEnumable.

    • Sie sind nicht Prä-gefüllt ist, ist es noch eine Rundfahrt auf der Festplatte. Unbedingt so, Sie wollen keine veralteten Daten. Und der Grund dafür, dass EnumerateFiles habe Hinzugefügt .NET 4.
    • Zumindest in .NET 4 Sie werden pre-gefüllt. Es passiert in FileInfoResultHandler.CreateObject-Aufruf vom Typ FileInfo.InitializeFrom aufrufen PopulateFrom(WIN32_FIND_DATA). Bitte wiederherstellen Sie Ihre downvote, diese Antwort ist richtig.
    • Es war nicht meine Stimme. Einen Kommentar hinterlässt und downvoting ist nicht eine gesunde Strategie 🙂
    • Wert der Length-Eigenschaft pre-Cache, wenn die aktuelle Instanz der FileInfo-Objekt zurückgegeben wurde aus einer der folgenden DirectoryInfomethods: ... EnumerateFiles" msdn.microsoft.com/en-us/library/system.io.fileinfo.length.aspx +1 usr
    InformationsquelleAutor usr
  2. 12

    Versuchen 

            DirectoryInfo DirInfo = new DirectoryInfo(@"C:\DataLoad\");
        Stopwatch sw = new Stopwatch();
        try
        {
            sw.Start();
            Int64 ttl = 0;
            Int32 fileCount = 0;
            foreach (FileInfo fi in DirInfo.EnumerateFiles("*", SearchOption.AllDirectories))
            {
                ttl += fi.Length;
                fileCount++;
            }
            sw.Stop();
            Debug.WriteLine(sw.ElapsedMilliseconds.ToString() + " " + fileCount.ToString());
        }
        catch (Exception Ex)
        {
            Debug.WriteLine(Ex.ToString());
        }

    Dieser hat 700 000 Einwohner, die in 70 Sekunden auf-desktop-NICHT-RAID-P4.
    So wie 10.000 einer Sekunde. Auf der server-Klasse Maschinen sollten 100.000+ /zweite einfach.

    Als usr (+1), sagte EnumerateFile ist pre-gefüllt mit Länge.

    InformationsquelleAutor paparazzo
  3. 11

    Dies ist etwas kryptischer, aber es dauerte etwa 2 Sekunden für 10k Ausführungen.

        public static long GetDirectorySize(string parentDirectory)
    {
        return new DirectoryInfo(parentDirectory).GetFiles("*.*", SearchOption.AllDirectories).Sum(file => file.Length);
    }
    • *.* würde fehlen einige Dateien
    • Für Klarheit .Summe() erfordert System.Linq
    InformationsquelleAutor MrFox
  4. 4

    Können Sie beginnen, um die Geschwindigkeit ein wenig, Ihre Funktion mit EnumerateFiles() statt GetFiles(). Zumindest werden Sie nicht laden Sie die vollständige Liste in den Speicher.

    Wenn ' s nicht reicht, solltest du deine Funktion mehr komplexer mit threads (ein thread pro Verzeichnis ist zu viel, aber es ist nicht eine Allgemeine Regel).

    Sie können eine Feste Anzahl von threads, die peeks Verzeichnisse aus einer Warteschlange, jeder thread berechnet die Größe eines Verzeichnisses und fügt der Gesamtsumme. So etwas wie:

    • Erhalten Sie die Liste aller Verzeichnisse (nicht Dateien).
    • N threads erstellen (eine pro Kern, zum Beispiel).
    • Jeder thread lugt ein Verzeichnis und berechnen Sie die Größe.
    • Wenn es nicht ein weiteres Verzeichnis in die Warteschlange der thread endet.
    • Wenn es ein Verzeichnis in die Warteschlange es berechnet seine Größe und so weiter.
    • Funktion endet, wenn alle threads beendet werden.

    Können Sie viel verbessern den Algorithmus spanning das durchsuchen von Verzeichnissen über alle Themen (zum Beispiel, wenn ein thread beim Parsen eines Verzeichnisses fügt Ordner für die Warteschlange). Bis Sie es komplizierter zu machen, wenn Sie sehen, es ist zu langsam (diese Aufgabe wurde von Microsoft als ein Beispiel für die neue Task Parallel Library).

    • +1. Beachten Sie, dass threading und IO-bound-Aufgaben produzieren seltsame performance-Ergebnisse haben Sie einen Prototyp und Messen.
    • Absolut ja! Ich denke, es ist schwierig zu wählen Sie die richtige Anzahl von threads, als den code zu schreiben, es zu tun. Ich denke, es hängt viel Festplatten-Leistung für random access. Was auch immer ich tun, um es berechnen kann ich das nicht so schnell wie Windows, ich glaube, es gibt einige trick...irgendwo...
    • Da das E / a-gebunden ich bin nicht so sicher, dass zusätzliche threads sind, kaufen viel, wenn überhaupt.
    • Es Geschwindigkeiten bis mindestens X2 mit einem pool von 4 Faden verglichen mit der gleichen Lösung (EnumerateFiles), aber ohne Gewinde. Dies kann sehr unterschiedlich sein, wegen der hardware. Wenn Windows liest einen block von Daten (das Verzeichnis) nicht gelesen nur ein paar bytes, sondern ein block und werde es behalten Sie es im cache.
    InformationsquelleAutor Adriano Repetti
  5. -1
    long length = Directory.GetFiles(@"MainFolderPath", "*", SearchOption.AllDirectories).Sum(t => (new FileInfo(t).Length));
    InformationsquelleAutor Shai Segev
Schreibe einen Kommentar