Получить все файлы и каталоги по определенному пути быстро

Ответ 1

Этот метод выполняется намного быстрее. Вы можете работать только при размещении большого количества файлов в каталоге. Мой внешний жесткий диск A:\содержит почти 1 терабит, поэтому он имеет большое значение при работе с большим количеством файлов.

static void Main(string[] args)
{
    DirectoryInfo di = new DirectoryInfo("A:\\");
    FullDirList(di, "*");
    Console.WriteLine("Done");
    Console.Read();
}

static List<FileInfo> files = new List<FileInfo>();  // List that will hold the files and subfiles in path
static List<DirectoryInfo> folders = new List<DirectoryInfo>(); // List that hold direcotries that cannot be accessed
static void FullDirList(DirectoryInfo dir, string searchPattern)
{
    // Console.WriteLine("Directory {0}", dir.FullName);
    // list the files
    try
    {
        foreach (FileInfo f in dir.GetFiles(searchPattern))
        {
            //Console.WriteLine("File {0}", f.FullName);
            files.Add(f);                    
        }
    }
    catch
    {
        Console.WriteLine("Directory {0}  \n could not be accessed!!!!", dir.FullName);                
        return;  // We alredy got an error trying to access dir so dont try to access it again
    }

    // process each directory
    // If I have been able to see the files in the directory I should also be able 
    // to look at its directories so I dont think I should place this in a try catch block
    foreach (DirectoryInfo d in dir.GetDirectories())
    {
        folders.Add(d);
        FullDirList(d, searchPattern);                    
    }

}

Кстати, я получил это благодаря вашему комментарию Джим Мишель

Ответ 2

В .NET 4.0 существует Directory.EnumerateFiles метод, который возвращает IEnumerable<string> и не загружает все файлы в памяти. Это только после того, как вы начнете перебирать возвращаемую коллекцию, и файлы будут возвращены, и можно было бы обработать исключения.

Ответ 3

Существует долгая история медленного процесса перечисления файлов .NET. Проблема в том, что нет мгновенного способа перечисления больших структур каталогов. Даже принятый ответ здесь имеет свои проблемы с распределением GC.

Лучшее, что мне удалось сделать, было завершено в моей библиотеке и показано как FindFile (source) в пространстве имен CSharpTest.Net.IO. Этот класс может перечислять файлы и папки без ненужных распределений GC и сортировки строк.

Использование достаточно простое, и свойство RaiseOnAccessDenied будет пропускать каталоги и файлы, к которым у пользователя нет доступа:

    private static long SizeOf(string directory)
    {
        var fcounter = new CSharpTest.Net.IO.FindFile(directory, "*", true, true, true);
        fcounter.RaiseOnAccessDenied = false;

        long size = 0, total = 0;
        fcounter.FileFound +=
            (o, e) =>
            {
                if (!e.IsDirectory)
                {
                    Interlocked.Increment(ref total);
                    size += e.Length;
                }
            };

        Stopwatch sw = Stopwatch.StartNew();
        fcounter.Find();
        Console.WriteLine("Enumerated {0:n0} files totaling {1:n0} bytes in {2:n3} seconds.",
                          total, size, sw.Elapsed.TotalSeconds);
        return size;
    }

Для моего локального диска C:\это выводит следующее:

Перечислил 810 046 файлов на общую сумму 307,707,792,662 байт за 232,876 секунды.

Ваш пробег может варьироваться в зависимости от скорости движения, но это самый быстрый метод, который я нашел для перечисления файлов в управляемом коде. Параметр события является мутирующим классом типа FindFile.FileFoundEventArgs, поэтому не забудьте ссылаться на него, поскольку значения будут меняться для каждого события поднят.

Ответ 4

Вы можете использовать это, чтобы получить все каталоги и подкаталоги. Затем просто выполните цикл для обработки файлов.

string[] folders = System.IO.Directory.GetDirectories(@"C:\My Sample Path\","*", System.IO.SearchOption.AllDirectories);

foreach(string f in folders)
{
   //call some function to get all files in folder
}

Ответ 5

(скопировал этот фрагмент из моего другого ответа в другом вопросе)

Показать прогресс при поиске всех файлов в каталоге

Перечисление быстрых файлов

Конечно, как вы уже знаете, есть много способов сделать перечисление самостоятельно... но никто не будет мгновенным. Вы можете попробовать использовать USN Journal файловой системы для сканирования. Взгляните на этот проект в CodePlex: MFT Scanner в VB.NET... он нашел все файлы в моей IDE SATA (не SSD ) диск менее чем за 15 секунд и нашел 311000 файлов.

Вам придется фильтровать файлы по пути, чтобы возвращались только файлы внутри пути, который вы ищете. Но это легкая часть работы!

Ответ 6

Я знаю, что это старый, но... Другой вариант может заключаться в использовании FileSystemWatcher:

void SomeMethod()
{
    System.IO.FileSystemWatcher m_Watcher = new System.IO.FileSystemWatcher();
    m_Watcher.Path = path;
    m_Watcher.Filter = "*.*";
    m_Watcher.NotifyFilter = m_Watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName;
    m_Watcher.Created += new FileSystemEventHandler(OnChanged);
    m_Watcher.EnableRaisingEvents = true;
}

private void OnChanged(object sender, FileSystemEventArgs e)
    {
        string path = e.FullPath;

        lock (listLock)
        {
            pathsToUpload.Add(path);
        }
    }

Это позволит вам просматривать каталоги для изменений файла с помощью чрезвычайно легкого процесса, который затем можно использовать для хранения имен файлов, которые были изменены, чтобы вы могли создать резервную копию в соответствующее время.

Ответ 7

Возможно, это будет полезно для вас. Вы можете использовать метод DirectoryInfo.EnumerateFiles и обрабатывать UnauthorizedAccessException по мере необходимости.

using System;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        DirectoryInfo diTop = new DirectoryInfo(@"d:\");
        try
        {
            foreach (var fi in diTop.EnumerateFiles())
            {
                try
                {
                    // Display each file over 10 MB; 
                    if (fi.Length > 10000000)
                    {
                        Console.WriteLine("{0}\t\t{1}", fi.FullName, fi.Length.ToString("N0"));
                    }
                }
                catch (UnauthorizedAccessException UnAuthTop)
                {
                    Console.WriteLine("{0}", UnAuthTop.Message);
                }
            }

            foreach (var di in diTop.EnumerateDirectories("*"))
            {
                try
                {
                    foreach (var fi in di.EnumerateFiles("*", SearchOption.AllDirectories))
                    {
                        try
                        {
                            // Display each file over 10 MB; 
                            if (fi.Length > 10000000)
                            {
                                Console.WriteLine("{0}\t\t{1}",  fi.FullName, fi.Length.ToString("N0"));
                            }
                        }
                        catch (UnauthorizedAccessException UnAuthFile)
                        {
                            Console.WriteLine("UnAuthFile: {0}", UnAuthFile.Message);
                        }
                    }
                }
                catch (UnauthorizedAccessException UnAuthSubDir)
                {
                    Console.WriteLine("UnAuthSubDir: {0}", UnAuthSubDir.Message);
                }
            }
        }
        catch (DirectoryNotFoundException DirNotFound)
        {
            Console.WriteLine("{0}", DirNotFound.Message);
        }
        catch (UnauthorizedAccessException UnAuthDir)
        {
            Console.WriteLine("UnAuthDir: {0}", UnAuthDir.Message);
        }
        catch (PathTooLongException LongPath)
        {
            Console.WriteLine("{0}", LongPath.Message);
        }
    }
}