Trouver le nombre de fichiers avec une extension spécifique, dans tous les sous-répertoires

Est-il un moyen de trouver le nombre de fichiers d'un type spécifique sans avoir à parcourir l'ensemble des résultats inn un Répertoire.GetFiles() ou une méthode similaire? Je suis à la recherche de quelque chose comme ceci:

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

Je sais que je peux faire une fonction récursive appel Répertoire.GetFiles , mais il serait beaucoup plus propre si je pouvais le faire sans tout le itération.

EDIT: Si il n'est pas possible de le faire sans recursing et d'itération vous-même, quelle serait la meilleure façon de le faire?

InformationsquelleAutor Espo | 2008-08-26
  1. 35

    Vous devez utiliser le Répertoire.GetFiles(chemin d'accès, searchPattern, SearchOption) surcharge de Répertoire.GetFiles().

    Chemin spécifie le chemin d'accès, searchPattern spécifie les caractères génériques (par exemple, *, *.format) et SearchOption fournit l'option inclure les sous-répertoires.

    La propriété Length du tableau de résultats de cette recherche vont fournir le bon nombre de fichiers pour votre modèle de recherche et d'option:

    string[] files = directory.GetFiles(@"c:\windows\system32", "*.dll", SearchOption.AllDirectories);

return files.Length;

    EDIT: Alternativement, vous pouvez utiliser Répertoire.EnumerateFiles méthode

    return Directory.EnumerateFiles(@"c:\windows\system32", "*.dll", SearchOption.AllDirectories).Count();
    • Cela a un énorme problème de performances avec un grand nombre de fichiers.
    • Pouvez-vous (ou quelqu'un d'autre), veuillez quantifier votre déclaration? Comment lent, c'est un "énorme problème de performance'? Combien est 'grand nombre de fichiers'? Jon solution qui fonctionne pour moi mais j'aimerais savoir quand et comment il pourrait devenir problématique.
    • La raison en est que GetFiles méthode va se matérialiser, ensemble liste des fichiers dans un répertoire. La méthode préférée pour, maintenant, c'est Directory.EnumerateFiles il sera de diffuser les fichiers en arrière (par le biais d'un yieldcomme mécanisme) que l'appel sous-jacent à l'OS, les rendements les résultats.
    • L'OP est daté de 2008...bien avant Répertoire.EnumerateFiles a même une lueur dans ses à papa œil. Ne soyez pas si prompts à sauter dans les anciens posts pour tirer des réponses parce que la nouvelle technologie est disponible.
    • Aussi, EnumerateFiles est considérablement plus lent: si vous avez besoin de l'évolutivité, c'est OK, mais il n'y a pas de raison de prendre le coup dans la plupart des cas.
    InformationsquelleAutor Jon Limjap
  2. 8

    La meilleurs méthode woud être utiliser linq:

    var fileCount = (from file in Directory.EnumerateFiles(@"H:\iPod_Control\Music", "*.mp3", SearchOption.AllDirectories)
                    select file).Count();
    • pourquoi ne pas Directory.EnumerateFiles(@"H:\iPod_Control\Music", "*.mp3", SearchOption.AllDirectories).Count()
    InformationsquelleAutor Dean
  3. 7

    Vous pouvez utiliser cette surcharge de GetFiles:

    Répertoire.Méthode GetFiles (String,
    Chaîne, SearchOption    )

    et ce membre de SearchOption:

    AllDirectories - Inclut le
    répertoire et tous les sous-répertoires
    dans une opération de recherche. Cette option
    comprend des points d'analyse comme monté
    les lecteurs et les liens symboliques dans le
    de recherche.

    GetFiles () retourne un tableau de string, de sorte que vous pouvez obtenir juste la Longueur qui est le nombre de fichiers trouvés.

    InformationsquelleAutor jfs
  4. 6

    J'ai été à la recherche pour une version optimisée. Puisque je n'ai pas trouvé, j'ai décidé de code et de le partager ici:

        public static int GetFileCount(string path, string searchPattern, SearchOption searchOption)
    {
        var fileCount = 0;
        var fileIter = Directory.EnumerateFiles(path, searchPattern, searchOption);
        foreach (var file in fileIter)
            fileCount++;
        return fileCount;
    }

    Toutes les solutions à l'aide de la GetFiles/GetDirectories sont un peu lent car tous ces objets doivent être créés. À l'aide de l'énumération, il n'est pas de créer tous les objets temporaires (FileInfo/DirectoryInfo).

    voir les Remarques http://msdn.microsoft.com/en-us/library/dd383571.aspx pour plus d'informations

    • Je serais toujours utiliser le Énumérable.Le comte d'extension dans cette situation...
    InformationsquelleAutor Sauleil
  5. 1

    En utilisant la récursivité votre MagicFindFileCount devrait ressembler à ceci:

    private int MagicFindFileCount( string strDirectory, string strFilter ) {
     int nFiles = Directory.GetFiles( strDirectory, strFilter ).Length;

     foreach( String dir in Directory.GetDirectories( strDirectory ) ) {
        nFiles += GetNumberOfFiles(dir, strFilter);
     }

     return nFiles;
  }

    Si Jon solution pourrait être la meilleure.

    InformationsquelleAutor Huppie
  6. 1

    J'ai une application qui génère des comtes de les répertoires et les fichiers dans un répertoire parent. Certains répertoires contiennent des milliers de sous-répertoires avec des milliers de fichiers dans chaque. Pour ce faire, tout en conservant un réactif de l'interface utilisateur je ne les suivants: (en joignant le chemin d'accès à ADirectoryPathWasSelected méthode):

    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);
}
}
}
    InformationsquelleAutor DraxReaper
  7. 0

    Quelqu'un doit faire le itération de la partie.

    Autant que je sache, il n'existe pas de méthode présents dans .NET déjà, donc je suppose que quelqu'un a à vous.

    InformationsquelleAutor Lasse Vågsæther Karlsen