nombre - obtener ruta de carpeta c#

Encontrar el número de archivos con una extensión específica, en todos los subdirectorios

Question

¿Hay alguna forma de encontrar el número de archivos de un tipo específico sin tener que recorrer todos los resultados en un directorio. Obtener archivos () o un método similar? Estoy buscando algo como esto:

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

Sé que puedo hacer una función recursiva para llamar a Directory.GetFiles, pero sería mucho más limpio si pudiera hacer esto sin todas las iteraciones.

EDITAR: Si no es posible hacer esto sin recurrir e iterar, ¿cuál sería la mejor manera de hacerlo?

Answer 1

Alguien tiene que hacer la parte iterativa.

AFAIK, ya no existe este método en .NET, así que supongo que alguien tiene que ser tú.

Answer 2

Puede usar esta sobrecarga de GetFiles:

Método Directory.GetFiles (String, String, SearchOption )

y este miembro de SearchOption:

AllDirectories : incluye el directorio actual y todos los subdirectorios en una operación de búsqueda. Esta opción incluye puntos de análisis como unidades montadas y enlaces simbólicos en la búsqueda.

GetFiles devuelve una matriz de cadena para que pueda obtener la longitud que es el número de archivos encontrados.

Answer 3

El método más hábil sería usar linq:

var fileCount = (from file in Directory.EnumerateFiles(@"H:/iPod_Control/Music", "*.mp3", SearchOption.AllDirectories)
                    select file).Count();

Answer 4

Tengo una aplicación que genera recuentos de los directorios y archivos en un directorio principal. Algunos de los directorios contienen miles de subdirectorios con miles de archivos en cada uno. Para hacer esto mientras mantengo un ui receptivo, hago lo siguiente (enviando la ruta al método ADirectoryPathWasSelected ):

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 5

Estaba buscando una versión más optimizada. Como no lo he encontrado, decidí codificarlo y compartirlo aquí:

    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;
    }

Todas las soluciones que usan GetFiles / GetDirectories son lentas ya que todos esos objetos necesitan ser creados. Usando la enumeración, no crea ningún objeto temporal (FileInfo / DirectoryInfo).

vea Comentarios http://msdn.microsoft.com/en-us/library/dd383571.aspx para más información

Answer 6

Debería usar la sobrecarga Directory.GetFiles (path, searchPattern, SearchOption) de Directory.GetFiles ().

Path especifica la ruta, searchPattern especifica sus comodines (p. Ej., *, * .format) y SearchOption proporciona la opción de incluir subdirectorios.

La propiedad Length de la matriz de devolución de esta búsqueda proporcionará el recuento de archivos adecuado para su patrón de búsqueda y opción particulares:

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

return files.Length;

EDITAR: Alternativamente puede usar el método Directory.EnumerateFiles

return Directory.EnumerateFiles(@"c:/windows/system32", "*.dll", SearchOption.AllDirectories).Count();

Answer 7

Usando la recursión, MagicFindFileCount se vería así:

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;
  }

Aunque la solución de Jon podría ser la mejor.