Czy istnieje szybszy sposób na znalezienie wszystkich plików w katalogu i wszystkich podkatalogach?

Fajne pytanie.

Pobawiłem się trochę i wykorzystując bloki iteratora i LINQ wydaje mi się, że poprawiłem Twoją poprawioną implementację o około 40%

Chciałbym, aby przetestować go za pomocą metod pomiaru czasu i w sieci, aby zobaczyć, jak wygląda różnica.

Oto mięso tego

private static IEnumerable<FileInfo> GetFileList(string searchPattern, string rootFolderPath)
{
    var rootDir = new DirectoryInfo(rootFolderPath);
    var dirList = rootDir.GetDirectories("*", SearchOption.AllDirectories);

    return from directoriesWithFiles in ReturnFiles(dirList, searchPattern).SelectMany(files => files)
           select directoriesWithFiles;
}

private static IEnumerable<FileInfo[]> ReturnFiles(DirectoryInfo[] dirList, string fileSearchPattern)
{
    foreach (DirectoryInfo dir in dirList)
    {
        yield return dir.GetFiles(fileSearchPattern, SearchOption.TopDirectoryOnly);
    }
}

Krótka odpowiedź jak poprawić wydajność tego kodu brzmi: nie możesz.

Prawdziwym uderzeniem wydajności jest rzeczywiste opóźnienie dysku lub sieci, więc bez względu na to, w jaki sposób go przewrócisz, musisz sprawdzić i iterację każdego elementu pliku i pobrać listę katalogów i plików. (To oczywiście wyklucza modyfikacje sprzętu lub sterowników w celu zmniejszenia lub poprawy opóźnienia dysku, ale wiele osób już płaci dużo pieniędzy, aby rozwiązać te problemy, więc będziemy ignoruj tę stronę na razie)

Biorąc pod uwagę oryginalne ograniczenia, istnieje już kilka rozwiązań, które mniej lub bardziej elegancko owijają proces iteracji (jednak, ponieważ zakładam, że czytam z jednego dysku twardego, równoległość nie pomoże szybciej poprzeć drzewa katalogów, a może nawet wydłużyć ten czas, ponieważ teraz masz dwa lub więcej wątków walczących o dane na różnych częściach dysku, gdy próbuje szukać Wstecz i czwarty) zmniejsz liczbę wątków o więcej niż jeden. wytworzonych obiektów, itp. Jednak jeśli ocenimy, w jaki sposób funkcja będzie zużywana przez dewelopera końcowego, możemy wymyślić pewne optymalizacje i uogólnienia.

Po pierwsze, możemy opóźnić wykonanie performance zwracając IEnumerable, yield return osiąga to poprzez kompilację w maszynie stanowej enumerator wewnątrz anonimowej klasy, która implementuje IEnumerable i jest zwracana, gdy metoda jest wykonywana. Większość metod w LINQ jest pisana w celu opóźnienia wykonania dopóki iteracja nie zostanie wykonana, więc kod w select lub SelectMany nie zostanie wykonany, dopóki nie zostanie iteracją IEnumerable. Efekt końcowy opóźnionej realizacji jest odczuwalny tylko wtedy, gdy musisz pobrać podzbiór danych w późniejszym czasie, na przykład, jeśli potrzebujesz tylko pierwszych 10 wyników, opóźnienie wykonania zapytania, które zwraca kilka tysięcy wyników, nie będzie powtarzane przez całe 1000 wyników, dopóki nie potrzebujesz więcej niż dziesięciu.

Teraz, biorąc pod uwagę, że chcesz zrobić podfolder Szukaj, mogę również wywnioskować, że może to być przydatne, jeśli możesz określić tę głębokość, a jeśli to zrobię, to również uogólnia mój problem, ale także wymaga rekurencyjnego rozwiązania. Później, gdy ktoś zdecyduje, że teraz musi przeszukać dwa katalogi głęboko, ponieważ zwiększyliśmy liczbę plików i zdecydowaliśmy się dodać kolejną warstwę kategoryzacji , możesz po prostu dokonać niewielkiej modyfikacji zamiast przepisywać funkcję.

W świetle tego wszystkiego, oto rozwiązanie, które przyszedłem up with that provides a bardziej general solution than some of the others above:

public static IEnumerable<FileInfo> BetterFileList(string fileSearchPattern, string rootFolderPath)
{
    return BetterFileList(fileSearchPattern, new DirectoryInfo(rootFolderPath), 1);
}

public static IEnumerable<FileInfo> BetterFileList(string fileSearchPattern, DirectoryInfo directory, int depth)
{
    return depth == 0
        ? directory.GetFiles(fileSearchPattern, SearchOption.TopDirectoryOnly)
        : directory.GetFiles(fileSearchPattern, SearchOption.TopDirectoryOnly).Concat(
            directory.GetDirectories().SelectMany(x => BetterFileList(fileSearchPattern, x, depth - 1)));
}

Na marginesie, coś jeszcze, o czym nikt dotąd nie wspomniał, to uprawnienia i bezpieczeństwo plików. Obecnie nie ma żądań sprawdzania, obsługi ani uprawnień, a kod wyrzuci wyjątki uprawnień do plików, jeśli napotka katalog, do którego nie ma dostępu.

Uzyskanie 2 milionów nazw plików zgodnych z filtrem zajmuje 30 sekund. Powodem, dla którego jest to tak szybkie, jest to, że wykonuję tylko 1 wyliczenie. Każde dodatkowe wyliczenie wpływa na wydajność. Zmienna długość jest otwarta dla Twojej interpretacji i niekoniecznie związana z przykładem wyliczenia.

if (Directory.Exists(path))
{
    files = Directory.EnumerateFiles(path, "*.*", SearchOption.AllDirectories)
    .Where(s => s.EndsWith(".xml") || s.EndsWith(".csv"))
    .Select(s => s.Remove(0, length)).ToList(); // Remove the Dir info.
}

Rozważ podzielenie zaktualizowanej metody na dwa Iteratory:

private static IEnumerable<DirectoryInfo> GetDirs(string rootFolderPath)
{
     DirectoryInfo rootDir = new DirectoryInfo(rootFolderPath);
     yield return rootDir;

     foreach(DirectoryInfo di in rootDir.GetDirectories("*", SearchOption.AllDirectories));
     {
          yield return di;
     }
     yield break;
}

public static IEnumerable<FileInfo> GetFileList(string fileSearchPattern, string rootFolderPath)
{
     var allDirs = GetDirs(rootFolderPath);
     foreach(DirectoryInfo di in allDirs())
     {
          var files = di.GetFiles(fileSearchPattern, SearchOption.TopDirectoryOnly);
          foreach(FileInfo fi in files)
          {
               yield return fi;
          }
     }
     yield break;
}

Ponadto, w zależności od sytuacji sieciowej, gdybyś był w stanie zainstalować małą usługę na tym serwerze, do której można było zadzwonić z KOMPUTERA Klienta, zbliżyłbyś się znacznie do wyników "folderu lokalnego", ponieważ wyszukiwanie mogłoby wykonać na serwerze i po prostu zwrócić Wyniki do ciebie. Będzie to największe zwiększenie prędkości w scenariuszu folderu sieciowego, ale może nie być dostępne w Twoim sytuacja. Używałem programu do synchronizacji plików, który zawiera tę opcję - Po zainstalowaniu usługi na moim serwerze program stał się sposób {5]} szybciej w identyfikacji plików, które były nowe, usunięte i out-of-sync.

Spróbuj programowania równoległego:

private string _fileSearchPattern;
private List<string> _files;
private object lockThis = new object();

public List<string> GetFileList(string fileSearchPattern, string rootFolderPath)
{
    _fileSearchPattern = fileSearchPattern;
    AddFileList(rootFolderPath);
    return _files;
}

private void AddFileList(string rootFolderPath)
{
    var files = Directory.GetFiles(rootFolderPath, _fileSearchPattern);
    lock (lockThis)
    {
        _files.AddRange(files);
    }

    var directories = Directory.GetDirectories(rootFolderPath);

    Parallel.ForEach(directories, AddFileList); // same as Parallel.ForEach(directories, directory => AddFileList(directory));
}

Wydaje się, że DirectoryInfo daje znacznie więcej informacji niż potrzebujesz, spróbuj przesłać polecenie dir i przetworzyć informacje z tego.

Metody BCL są przenośne, że tak powiem. Jeśli pozostaniemy w 100% zarządzani, uważam, że najlepsze, co możesz zrobić, to wywołać GetDirectories / foldery podczas sprawdzania praw dostępu (lub ewentualnie nie sprawdzać praw i mieć inny wątek gotowy do pracy, gdy pierwszy trwa trochę zbyt długo - znak, że ma zamiar wyrzucić wyjątek nieautoryzowany dostęp - może to być unikalne z filtrami WYJĄTKÓW za pomocą VB lub od dziś niepublikowane c#).

Jeśli chcesz szybciej niż GetDirectories musisz wywołanie win32 (findsomethingEx itp.), które dostarcza określone flagi, które pozwalają ignorować ewentualnie niepotrzebne IO podczas przechodzenia struktur MFT. Również jeśli dysk jest udział sieciowy, nie może być duże przyspieszenie przez podobne podejście, ale tym razem unikając również nadmierne sieci roundtrips.

Teraz, jeśli masz admina i używasz ntfs i naprawdę się spieszysz z milionami plików do przejrzenia, absolutnym najszybszym sposobem, aby przejść przez nie( zakładając, że wirujący rust zabija opóźnienie dysku) jest wykorzystanie zarówno MFT, jak i journalingu w połączeniu, zasadniczo zastępując usługę indeksowania usługą dostosowaną do konkretnych potrzeb. Jeśli musisz znaleźć tylko nazwy plików, a nie rozmiary (lub rozmiary też, ale musisz je buforować i używać dziennika, aby zauważyć zmiany), takie podejście może pozwolić na praktycznie natychmiastowe wyszukiwanie dziesiątek milionów plików i folderów, jeśli zostanie wdrożone idealnie. Może być jeden lub dwa payware, które zawracały sobie tym głowę. Są próbki zarówno MFT (DiscUtils) jak i czytanie dziennika (google) w C#. Mam tylko około 5 milionów plików i samo użycie NTFSSearch jest wystarczająco dobre dla tej kwoty, ponieważ wyszukiwanie zajmuje około 10-20 sekund. Po dodaniu odczytu z dziennika zmniejszy to się do

Możesz użyć parallel foreach (. Net 4.0) lub spróbować Poor Man ' s Parallel.Foreach Iterator dla .Net3.5 . To przyspieszy twoje poszukiwania.

To jest straszne, a powodem, dla którego wyszukiwanie plików jest straszne na platformach Windows, jest to, że MS popełnił błąd, który wydaje się niechętny do naprawienia. Powinieneś być w stanie użyć SearchOption.AllDirectories I wszyscy odzyskamy prędkość, jakiej chcemy. Ale nie możesz tego zrobić, ponieważ GetDirectories wymaga oddzwonienia, abyś mógł zdecydować, co zrobić z katalogami, do których nie masz dostępu. MS zapomniał lub nie pomyślał, aby przetestować klasę na własnych komputerach.

Więc my wszystkie zostały z nonsensownymi pętlami rekurencyjnymi.

W C# / Managed C++ masz bardzo mało oprionów, są to również opcje, które biorą MS, ponieważ ich kodery też nie wypracowały, jak to obejść.

Najważniejsze jest to, że elementy wyświetlania, takie jak TreeViews i FileViews, wyszukują tylko i pokazują to, co użytkownicy mogą zobaczyć. Na kontrolkach znajduje się wiele pomocników, w tym wyzwalacze, które informują, kiedy trzeba wypełnić niektóre dane.

W drzewach, począwszy od tryb zwinięty, przeszukuje ten jeden katalog jak i kiedy użytkownik otworzy go w drzewie, to znacznie szybciej niż oczekiwanie na wypełnienie całego drzewa. To samo w przeglądach plików, mam tendencję do reguły 10%, jak wiele elementów mieści się w obszarze wyświetlania, ma inne 10% gotowe, jeśli użytkownik przewija, jest ładnie responsywny.

MS do pre-search and directory watch. Mała baza katalogów, plików, oznacza to, że masz na swoim drzewie itp mają dobry szybki punkt startowy, spada w dół trochę na odświeżaniu.

Ale wymieszaj te dwa pomysły, weź katalogi i pliki z bazy danych, ale odśwież wyszukiwanie, ponieważ węzeł drzewa jest rozszerzony (tylko ten węzeł drzewa) i jako inny katalog jest zaznaczony w drzewie.

Ale lepiej jest dodać system wyszukiwania plików jako usługę. MS już to ma, ale z tego co wiem nie mamy do niego dostępu, podejrzewam, że to dlatego, że jest odporny na błędy "failed access to directory". Podobnie jak w przypadku MS one, jeśli jeśli usługa działa na poziomie administratora, musisz uważać, aby nie rozdawać zabezpieczeń tylko ze względu na trochę dodatkowej prędkości.

Byłbym skłonny zwrócić liczbę w tym przypadku-w zależności od tego, jak zużywasz wyniki, może to być poprawa, Plus zmniejszasz swój parametr footprint o 1/3 i unikasz ciągłego przechodzenia wokół tej listy.

private IEnumerable<FileInfo> GetFileList(string fileSearchPattern, string rootFolderPath)
{
    DirectoryInfo di = new DirectoryInfo(rootFolderPath);

    var fiArr = di.GetFiles(fileSearchPattern, SearchOption.TopDirectoryOnly);
    foreach (FileInfo fi in fiArr)
    {
        yield return fi;
    }

    var diArr = di.GetDirectories();

    foreach (DirectoryInfo di in diArr)
    {
        var nextRound = GetFileList(fileSearchPattern, di.FullnName);
        foreach (FileInfo fi in nextRound)
        {
            yield return fi;
        }
    }
    yield break;
}

Innym pomysłem byłoby spin off BackgroundWorker obiektów do trollowania przez katalogi. Nie chciałbyś nowego wątku dla każdego katalogu, ale możesz utworzyć go na najwyższym poziomie (najpierw przejść przez GetFileList()), więc jeśli wykonasz na dysku C:\, w przypadku 12 katalogów każdy z tych katalogów będzie przeszukiwany przez inny wątek, który następnie będzie przeszukiwał podkatalogi. Będziesz miał JEDEN wątek przechodzący przez C:\Windows, podczas gdy inny przechodzi przez C:\Program Files. Istnieje wiele zmiennych, jak to ma wpłynąć na wydajność -- trzeba by to przetestować, aby zobaczyć.

W celu wyszukiwania plików i katalogów chciałbym zaoferować wykorzystanie wielowątkowej biblioteki. NET, która ma szerokie możliwości wyszukiwania. Wszystkie informacje o bibliotece można znaleźć na Githubie: https://github.com/VladPVS/FastSearchLibrary

Jeśli chcesz go pobrać, możesz to zrobić tutaj: https://github.com/VladPVS/FastSearchLibrary/releases

Jest to jeden przykładowy sposób użycia:

class Searcher
{
    private static object locker = new object(); 

    private FileSearcher searcher;

    List<FileInfo> files;

    public Searcher()
    {
        files = new List<FileInfo>(); // create list that will contain search result
    }

    public void Startsearch()
    {
        CancellationTokenSource tokenSource = new CancellationTokenSource();
        // create tokenSource to get stop search process possibility

        searcher = new FileSearcher(@"C:\", (f) =>
        {
            return Regex.IsMatch(f.Name, @".*[Dd]ragon.*.jpg$");
        }, tokenSource);  // give tokenSource in constructor


        searcher.FilesFound += (sender, arg) => // subscribe on FilesFound event
        {
            lock (locker) // using a lock is obligatorily
            {
                arg.Files.ForEach((f) =>
                {
                    files.Add(f); // add the next part of the received files to the results list
                    Console.WriteLine($"File location: {f.FullName}, \nCreation.Time: {f.CreationTime}");
                });

                if (files.Count >= 10) // one can choose any stopping condition
                    searcher.StopSearch();
            }
        };

        searcher.SearchCompleted += (sender, arg) => // subscribe on SearchCompleted event
        {
            if (arg.IsCanceled) // check whether StopSearch() called
                Console.WriteLine("Search stopped.");
            else
                Console.WriteLine("Search completed.");

            Console.WriteLine($"Quantity of files: {files.Count}"); // show amount of finding files
        };

        searcher.StartSearchAsync();
        // start search process as an asynchronous operation that doesn't block the called thread
    }
}

To kolejny przykład:

***
List<string> folders = new List<string>
{
  @"C:\Users\Public",
  @"C:\Windows\System32",
  @"D:\Program Files",
  @"D:\Program Files (x86)"
}; // list of search directories

List<string> keywords = new List<string> { "word1", "word2", "word3" }; // list of search keywords

FileSearcherMultiple multipleSearcher = new FileSearcherMultiple(folders, (f) =>
{
  if (f.CreationTime >= new DateTime(2015, 3, 15) &&
     (f.Extension == ".cs" || f.Extension == ".sln"))
    foreach (var keyword in keywords)
      if (f.Name.Contains(keyword))
        return true;
  return false;
}, tokenSource, ExecuteHandlers.InCurrentTask, true); 

***