Jak uzyskać rozmiar katalogu (pliki w katalogu) w języku C#?

Question

Chcę móc uzyskać rozmiar jednego z lokalnych katalogów przy użyciu C#. Staram się unikać następujący (pseudo takiego kodu), chociaż w najgorszym wypadku będę musiał zadowolić się następująco:

int GetSize(Directory) 
    { 
     int Size = 0; 

     foreach (File in Directory) 
     { 
      FileInfo fInfo of File; 
      Size += fInfo.Size; 
     } 

     foreach (SubDirectory in Directory) 
     { 
      Size += GetSize(SubDirectory); 
     } 
     return Size; 
    } 

Zasadniczo, jest tam na spacer() dostępne gdzieś tak, że mogę chodzić przez drzewo katalogów? Który zapisałby rekursję przechodzenia przez każdy podkatalog.

Answer 1

Jeśli używasz Directory.GetFiles można zrobić rekurencyjną wyszukiwanego (używając SearchOption.AllDirectories), ale jest to trochę łuszcząca się i tak (zwłaszcza jeśli nie masz dostępu do jednego z podkatalogów) - i może pociągać za sobą ogromne single tablica wraca (ostrzeżenie klaxon ...).

Byłbym zadowolony z podejścia rekursji, chyba że mógłbym pokazać (poprzez profilowanie) wąskie gardło; a następnie prawdopodobnie przestawiłbym się na (jednopoziomowy) Directory.GetFiles, używając Queue<string> do emulowania rekursji.

Należy zauważyć, że .NET 4.0 wprowadza niektóre metody listowania plików/katalogów oparte na modułach wyliczających, które można zapisać na dużych tablicach.

Answer 2

Już od jakiegoś czasu szukałem funkcji podobnej do tej, o którą prosiłem i z tego, co znalazłem w Internecie i na forach MSDN, nie ma takiej funkcji.

Rekurencyjna metoda to jedyna opcja, w której znalazłem rozmiar folderu z uwzględnieniem wszystkich zawartych w nim plików i podfolderów.

Answer 3

Można ukryć swój rekursji za metodę rozszerzenia (aby uniknąć problemów Marc uwidocznił z GetFiles() metoda):

public static IEnumerable<FileInfo> Walk(this DirectoryInfo directory) 
{ 
    foreach(FileInfo file in directory.GetFiles()) 
    { 
     yield return file; 
    } 

    foreach(DirectoryInfo subDirectory in directory.GetDirectories() 
    { 
     foreach(FileInfo file in subDirectory.Walk()) 
     { 
      yield return file; 
     } 
    } 
} 

(Prawdopodobnie chcesz dodać wyjątek obsługi to dla folderów zabezpieczonych itd.)

Następnie:

int totalSize = 0; 

foreach(FileInfo file in directory.Walk()) 
{ 
    totalSize += file.Length; 
} 

zasadzie ten sam kod, ale może trochę neater ...

Answer 4

Wystarczy popatrzeć na tego posta:

http://social.msdn.microsoft.com/forums/en-US/vbgeneral/thread/eed54ebe-facd-4305-b64b-9dbdc65df04e

Zasadniczo nie ma czysty NET sposób, ale jest dość proste podejście COM więc jeśli jesteś zadowolony z użyciem modelu COM i jest związany Windows, to może ci pomóc.

Answer 5

Oto mój .NET 4.0 podejście

public static long GetFileSizeSumFromDirectory(string searchDirectory) 
{ 
var files = Directory.EnumerateFiles(searchDirectory); 

// get the sizeof all files in the current directory 
var currentSize = (from file in files let fileInfo = new FileInfo(file) select fileInfo.Length).Sum(); 

var directories = Directory.EnumerateDirectories(searchDirectory); 

// get the size of all files in all subdirectories 
var subDirSize = (from directory in directories select GetFileSizeSumFromDirectory(directory)).Sum(); 

return currentSize + subDirSize; 
} 

Albo nawet ładniejszy:

// get IEnumerable from all files in the current dir and all sub dirs 
var files = Directory.EnumerateFiles(searchDirectory,"*",SearchOption.AllDirectories); 

// get the size of all files 
long sum = (from file in files let fileInfo = new FileInfo(file) select fileInfo .Length).Sum(); 

Gabriel wskazał będzie to powiedzie się, jeśli masz ograniczony katalog pod searchDirectory!

Answer 6

Po pierwsze, wybacz mój biedny angielski; o) Miałem problem, który zabrał mnie na tę stronę: wyliczyć pliki katalogu i jego podkatalogów bez blokowania na wyjątku UnauthorizedAccessException i, podobnie jak nowa metoda .Net 4 DirectoryInfo .Zanumeruj ..., uzyskaj pierwszy wynik przed zakończeniem całego zapytania.

Z pomocą różnych przykładów znalezionych tu i tam w internecie, w końcu napisać tę metodę:

public static IEnumerable<FileInfo> EnumerateFiles_Recursive(this DirectoryInfo directory, string searchPattern, SearchOption searchOption, Func<DirectoryInfo, Exception, bool> handleExceptionAccess) 
{ 
    Queue<DirectoryInfo> subDirectories = new Queue<DirectoryInfo>(); 
    IEnumerable<FileSystemInfo> entries = null; 

    // Try to get an enumerator on fileSystemInfos of directory 
    try 
    { 
     entries = directory.EnumerateFileSystemInfos(searchPattern, SearchOption.TopDirectoryOnly); 
    } 
    catch (Exception e) 
    { 
     // If there's a callback delegate and this delegate return true, we don't throw the exception 
     if (handleExceptionAccess == null || !handleExceptionAccess(directory, e)) 
      throw; 
     // If the exception wasn't throw, we make entries reference an empty collection 
     entries = EmptyFileSystemInfos; 
    } 

    // Yield return file entries of the directory and enqueue the subdirectories 
    foreach (FileSystemInfo entrie in entries) 
    { 
     if (entrie is FileInfo) 
      yield return (FileInfo)entrie; 
     else if (entrie is DirectoryInfo) 
      subDirectories.Enqueue((DirectoryInfo)entrie); 
    } 

    // If recursive search, we make recursive call on the method to yield return entries of the subdirectories. 
    if (searchOption == SearchOption.AllDirectories) 
    { 
     DirectoryInfo subDir = null; 
     while (subDirectories.Count > 0) 
     { 
      subDir = subDirectories.Dequeue(); 
      foreach (FileInfo file in subDir.EnumerateFiles_Recursive(searchPattern, searchOption, handleExceptionAccess)) 
      { 
       yield return file; 
      } 
     } 
    } 
    else 
     subDirectories.Clear(); 
} 

używać kolejki i metody rekurencyjnej zachować tradycyjny porządek (zawartość katalogu, a następnie zawartość pierwszego podkatalogu i jego własnych podkatalogów, a następnie zawartość drugiego ...). Parametr "handleExceptionAccess" jest po prostu wywołaniem funkcji, gdy zostanie zgłoszony wyjątek z katalogiem; funkcja musi zwracać wartość true, aby wskazać, że wyjątek musi zostać zignorowany.

Z tego Methode, można napisać:

DirectoryInfo dir = new DirectoryInfo("c:\\temp"); 
long size = dir.EnumerateFiles_Recursive("*", SearchOption.AllDirectories, (d, ex) => true).Sum(f => f.Length); 

I tu jesteśmy: wszystkie wyjątek, gdy próbuje wyliczyć katalog będzie ignorować!

Nadzieja ta pomoc

Lionel

PS: z jakiegoś powodu nie mogę wyjaśnić, moja metoda jest bardziej szybkie niż jeden Framework 4 ...

PPS: można dostać mój testowe rozwiązania ze źródłem dla tych metod: tutaj TestDirEnumerate. Piszę EnumerateFiles_Recursive, EnumerateFiles_NonRecursive (użyj kolejki, aby uniknąć rekursji) i EnumerateFiles_NonRecursive_TraditionalOrder (użyj stosu kolejki, aby uniknąć rekursji i zachować tradycyjną kolejność). Trzymaj te 3 metody bez zainteresowania, piszę je tylko dla sprawdzenia najlepszego. Myślę, że zatrzymam tylko ostatnią. Napisałem również odpowiednik dla EnumerateFileSystemInfos i EnumerateDirectories.

Answer 7

Bardzo zwięzły sposób na uzyskanie rozmiaru folderu w .net 4.0 jest poniżej. Nadal cierpi z powodu konieczności przechodzenia przez rekursywnie wszystkich plików, ale nie ładuje potencjalnie ogromnej ilości nazw plików i jest tylko dwoma liniami kodu.

private static long GetDirectorySize(string folderPath) 
    { 
     DirectoryInfo di = new DirectoryInfo(folderPath); 
     return di.EnumerateFiles("*.*", SearchOption.AllDirectories).Sum(fi => fi.Length); 
    } 

Answer 8

Powinieneś ułatwić sobie. Utwórz metodę i podaj położenie katalogu.

private static long GetDirectorySize(string location) { 
     return new DirectoryInfo(location).GetFiles("*.*", SearchOption.AllDirectories).Sum(file => file.Length); 
    } 

-G