Procedimiento para enumerar directorios y archivos

Las colecciones enumerables ofrecen mayor rendimiento que las matrices cuando se trabaja con colecciones grandes de directorios y archivos. Para enumerar directorios y archivos, use métodos que devuelvan una colección enumerable de nombres de directorio o archivo, o bien sus objetos DirectoryInfo, FileInfo o FileSystemInfo.

Si quiere buscar y devolver solo los nombres de directorios o archivos, use los métodos de enumeración de la clase Directory. Si quiere buscar y devolver otras propiedades de directorios o archivos, use las clases DirectoryInfo y FileSystemInfo.

También puede usar colecciones enumerables de métodos como el parámetro IEnumerable<T> para los constructores de clases de colecciones como List<T>.

En la tabla siguiente se resumen los métodos que devuelven colecciones enumerables de archivos y directorios:

Para buscar y devolver	Método que se usa
Nombres de directorio	Directory.EnumerateDirectories
Información de directorio (DirectoryInfo)	DirectoryInfo.EnumerateDirectories
Nombres de archivo	Directory.EnumerateFiles
Información del archivo (FileInfo)	DirectoryInfo.EnumerateFiles
Nombres de entrada de archivos del sistema	Directory.EnumerateFileSystemEntries
Información de entrada del sistema de archivos (FileSystemInfo)	DirectoryInfo.EnumerateFileSystemInfos
Nombres de archivos y directorios	Directory.EnumerateFileSystemEntries

Nota

Aunque puede enumerar inmediatamente todos los archivos de los subdirectorios de un directorio principal mediante la opción AllDirectories de la enumeración SearchOption, los errores UnauthorizedAccessException pueden hacer que la enumeración esté incompleta. Puede detectar estas excepciones si enumera primero los directorios y luego los archivos.

Ejemplos: Uso de la clase Directory

En el ejemplo siguiente se usa el método Directory.EnumerateDirectories(String) para obtener una lista de los nombres de directorio de nivel superior en una ruta de acceso especificada.

C#

using System;
using System.Collections.Generic;
using System.IO;

class Program
{
    private static void Main(string[] args)
    {
        try
        {
            // Set a variable to the My Documents path.
            string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

            List<string> dirs = new List<string>(Directory.EnumerateDirectories(docPath));

            foreach (var dir in dirs)
            {
                Console.WriteLine($"{dir.Substring(dir.LastIndexOf(Path.DirectorySeparatorChar) + 1)}");
            }
            Console.WriteLine($"{dirs.Count} directories found.");
        }
        catch (UnauthorizedAccessException ex)
        {
            Console.WriteLine(ex.Message);
        }
        catch (PathTooLongException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

En el ejemplo siguiente se usa el método Directory.EnumerateFiles(String, String, SearchOption) para enumerar de forma recursiva todos los nombres de archivo de un directorio y los subdirectorios que coinciden con un patrón determinado. Después, se leen todas las líneas de todos los archivos y se muestran las líneas que contienen una cadena especificada, con sus nombres de archivo y rutas de acceso.

C#

using System;
using System.IO;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {
        try
        {
            // Set a variable to the My Documents path.
            string docPath =
            Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

            var files = from file in Directory.EnumerateFiles(docPath, "*.txt", SearchOption.AllDirectories)
                        from line in File.ReadLines(file)
                        where line.Contains("Microsoft")
                        select new
                        {
                            File = file,
                            Line = line
                        };

            foreach (var f in files)
            {
                Console.WriteLine($"{f.File}\t{f.Line}");
            }
            Console.WriteLine($"{files.Count().ToString()} files found.");
        }
        catch (UnauthorizedAccessException uAEx)
        {
            Console.WriteLine(uAEx.Message);
        }
        catch (PathTooLongException pathEx)
        {
            Console.WriteLine(pathEx.Message);
        }
    }
}

Ejemplos: Uso de la clase DirectoryInfo

En el ejemplo siguiente se usa el método DirectoryInfo.EnumerateDirectories para enumerar una colección de los directorios de nivel superior cuyo CreationTimeUtc es anterior a un valor DateTime determinado.

C#

using System;
using System.IO;

namespace EnumDir
{
    class Program
    {
        static void Main(string[] args)
        {
            // Set a variable to the Documents path.
            string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

            DirectoryInfo dirPrograms = new DirectoryInfo(docPath);
            DateTime StartOf2009 = new DateTime(2009, 01, 01);

            var dirs = from dir in dirPrograms.EnumerateDirectories()
            where dir.CreationTimeUtc > StartOf2009
            select new
            {
                ProgDir = dir,
            };

            foreach (var di in dirs)
            {
                Console.WriteLine($"{di.ProgDir.Name}");
            }
        }
    }
}
// </Snippet1>

En el ejemplo siguiente se usa el método DirectoryInfo.EnumerateFiles para enumerar todos los archivos cuyo valor Length supera los 10 MB. En este ejemplo se enumeran primero los directorios de nivel superior, para detectar las posibles excepciones de acceso no autorizado, y luego se enumeran los archivos.

C#

using System;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        // Set a variable to the My Documents path.
        string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

        DirectoryInfo diTop = new DirectoryInfo(docPath);

        try
        {
            foreach (var fi in diTop.EnumerateFiles())
            {
                try
                {
                    // Display each file over 10 MB;
                    if (fi.Length > 10000000)
                    {
                        Console.WriteLine($"{fi.FullName}\t\t{fi.Length.ToString("N0")}");
                    }
                }
                catch (UnauthorizedAccessException unAuthTop)
                {
                    Console.WriteLine($"{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($"{fi.FullName}\t\t{fi.Length.ToString("N0")}");
                            }
                        }
                        catch (UnauthorizedAccessException unAuthFile)
                        {
                            Console.WriteLine($"unAuthFile: {unAuthFile.Message}");
                        }
                    }
                }
                catch (UnauthorizedAccessException unAuthSubDir)
                {
                    Console.WriteLine($"unAuthSubDir: {unAuthSubDir.Message}");
                }
            }
        }
        catch (DirectoryNotFoundException dirNotFound)
        {
            Console.WriteLine($"{dirNotFound.Message}");
        }
        catch (UnauthorizedAccessException unAuthDir)
        {
            Console.WriteLine($"unAuthDir: {unAuthDir.Message}");
        }
        catch (PathTooLongException longPath)
        {
            Console.WriteLine($"{longPath.Message}");
        }
    }
}

Vea también

• E/S de archivos y secuencias