Suche nach der Anzahl der Dateien mit einer bestimmten Erweiterung in allen Unterverzeichnissen

Question

Gibt es eine Möglichkeit, die Anzahl der Dateien eines bestimmten Typs zu finden, ohne eine Schleife durch alle Ergebnisse in einem Directory.GetFiles() oder einer ähnlichen Methode? Ich suche so etwas wie dies:

int ComponentCount = MagicFindFileCount(@"c:\windows\system32", "*.dll");

Ich weiß, dass ich eine rekursive Funktion machen kann, um Directory.GetFiles aufzurufen, aber es wäre viel sauberer, wenn ich dies ohne die ganze Iteration tun könnte.

EDIT : Wenn es nicht möglich ist, dies zu tun, ohne selbst zu rekursieren und zu iterieren, was wäre dann der beste Weg, dies zu tun?

Answer 1

Ich habe eine Anwendung, die Zählungen der Verzeichnisse und Dateien in einem übergeordneten Verzeichnis erzeugt. Einige der Verzeichnisse enthalten Tausende von Unterverzeichnissen mit Tausenden von Dateien in jedem. Um dies zu tun, während die Aufrechterhaltung einer reaktionsschnellen ui ich das folgende (Senden des Pfads zu ADirectoryPathWasSelected Methode):

public class DirectoryFileCounter
{
    int mDirectoriesToRead = 0;

    // Pass this method the parent directory path
    public void ADirectoryPathWasSelected(string path)
    {
        // create a task to do this in the background for responsive ui
        // state is the path
        Task.Factory.StartNew((state) =>
        {
            try
            {
                // Get the first layer of sub directories
                this.AddCountFilesAndFolders(state.ToString())

             }
             catch // Add Handlers for exceptions
             {}
        }, path));
    }

    // This method is called recursively
    private void AddCountFilesAndFolders(string path)
    {
        try
        {
            // Only doing the top directory to prevent an exception from stopping the entire recursion
            var directories = Directory.EnumerateDirectories(path, "*.*", SearchOption.TopDirectoryOnly);

            // calling class is tracking the count of directories
            this.mDirectoriesToRead += directories.Count();

            // get the child directories
            // this uses an extension method to the IEnumerable<V> interface,
           // which will run a function on an object. In this case 'd' is the 
           // collection of directories
            directories.ActionOnEnumerable(d => AddCountFilesAndFolders(d));
        }
        catch // Add Handlers for exceptions
        {
        }
        try
        {
            // count the files in the directory
            this.mFilesToRead += Directory.EnumerateFiles(path).Count();
        }
        catch// Add Handlers for exceptions
        { }
    }
}
// Extension class
public static class Extensions
{ 
    // this runs the supplied method on each object in the supplied enumerable
    public static void ActionOnEnumerable<V>(this IEnumerable<V> nodes,Action<V> doit)
    {

        foreach (var node in nodes)
        {   
            doit(node);
        }
    }
}

Answer 2

Jemand muss die Iteration übernehmen.

AFAIK, gibt es keine solche Methode in .NET bereits vorhanden, so dass ich denke, dass jemand hat, um Sie zu sein.