¿Se puede llamar a Directory.GetFiles () con múltiples filtros?

Estoy tratando de usar el Directory.GetFiles()método para recuperar una lista de archivos de varios tipos, como mp3'sy jpg' s. He intentado lo siguiente sin suerte:

Directory.GetFiles("C:\\path", "*.mp3|*.jpg", SearchOption.AllDirectories);
Directory.GetFiles("C:\\path", "*.mp3;*.jpg", SearchOption.AllDirectories);

¿Hay alguna manera de hacer esto en una llamada?

Para .NET 4.0 y posterior,

var files = Directory.EnumerateFiles("C:\\path", "*.*", SearchOption.AllDirectories)
            .Where(s => s.EndsWith(".mp3") || s.EndsWith(".jpg"));

Para versiones anteriores de .NET,

var files = Directory.GetFiles("C:\\path", "*.*", SearchOption.AllDirectories)
            .Where(s => s.EndsWith(".mp3") || s.EndsWith(".jpg"));

editar: por favor lea los comentarios. La mejora que sugiere Paul Farry , y el problema de memoria / rendimiento que Christian.K señala son muy importantes.

Qué tal esto:

private static string[] GetFiles(string sourceFolder, string filters, System.IO.SearchOption searchOption)
{
   return filters.Split('|').SelectMany(filter => System.IO.Directory.GetFiles(sourceFolder, filter, searchOption)).ToArray();
}

Lo encontré aquí (en los comentarios): http://msdn.microsoft.com/en-us/library/wz42302f.aspx

Si tiene una gran lista de extensiones para verificar, puede usar lo siguiente. No quería crear muchas declaraciones OR, así que modifiqué lo que lette escribió.

string supportedExtensions = "*.jpg,*.gif,*.png,*.bmp,*.jpe,*.jpeg,*.wmf,*.emf,*.xbm,*.ico,*.eps,*.tif,*.tiff,*.g01,*.g02,*.g03,*.g04,*.g05,*.g06,*.g07,*.g08";
foreach (string imageFile in Directory.GetFiles(_tempDirectory, "*.*", SearchOption.AllDirectories).Where(s => supportedExtensions.Contains(Path.GetExtension(s).ToLower())))
{
    //do work here
}

para

var exts = new[] { "mp3", "jpg" };

Tú podrías:

public IEnumerable<string> FilterFiles(string path, params string[] exts) {
    return
        Directory
        .EnumerateFiles(path, "*.*")
        .Where(file => exts.Any(x => file.EndsWith(x, StringComparison.OrdinalIgnoreCase)));
}

• No olvide el nuevo .NET4 Directory.EnumerateFilespara aumentar el rendimiento ( ¿Cuál es la diferencia entre Directory.EnumerateFiles y Directory.GetFiles? )
• "IgnoreCase" debería ser más rápido que "ToLower" (en .EndsWith("aspx", StringComparison.OrdinalIgnoreCase)lugar de .ToLower().EndsWith("aspx"))

Pero el beneficio real de EnumerateFilesaparece cuando divide los filtros y combina los resultados:

public IEnumerable<string> FilterFiles(string path, params string[] exts) {
    return 
        exts.Select(x => "*." + x) // turn into globs
        .SelectMany(x => 
            Directory.EnumerateFiles(path, x)
            );
}

Se vuelve un poco más rápido si no tiene que convertirlos en globos (es decir, exts = new[] {"*.mp3", "*.jpg"}ya).

Evaluación de rendimiento basada en la siguiente prueba de LinqPad (nota: Perf solo repite el delegado 10000 veces) https://gist.github.com/zaus/7454021

(reenviado y extendido desde 'duplicado' ya que esa pregunta no solicitó específicamente LINQ: múltiples extensiones de archivo searchPattern para System.IO.Directory.GetFiles )

Sé que es una pregunta antigua pero LINQ: (.NET40 +)

var files = Directory.GetFiles("path_to_files").Where(file => Regex.IsMatch(file, @"^.+\.(wav|mp3|txt)$"));

También hay una solución de descenso que parece no tener sobrecarga de memoria o rendimiento y es bastante elegante:

string[] filters = new[]{"*.jpg", "*.png", "*.gif"};
string[] filePaths = filters.SelectMany(f => Directory.GetFiles(basePath, f)).ToArray();

Otra forma de usar Linq, pero sin tener que devolver todo y filtrar eso en la memoria.

var files = Directory.GetFiles("C:\\path", "*.mp3", SearchOption.AllDirectories).Union(Directory.GetFiles("C:\\path", "*.jpg", SearchOption.AllDirectories));

En realidad son 2 llamadas GetFiles(), pero creo que es consistente con el espíritu de la pregunta y las devuelve en una enumerable.

No Intenta lo siguiente:

List<string> _searchPatternList = new List<string>();
    ...
    List<string> fileList = new List<string>();
    foreach ( string ext in _searchPatternList )
    {
        foreach ( string subFile in Directory.GetFiles( folderName, ext  )
        {
            fileList.Add( subFile );
        }
    }

    // Sort alpabetically
    fileList.Sort();

    // Add files to the file browser control    
    foreach ( string fileName in fileList )
    {
        ...;
    }

Tomado de: http://blogs.msdn.com/markda/archive/2006/04/20/580075.aspx

Dejar

var set = new HashSet<string> { ".mp3", ".jpg" };

Entonces

Directory.GetFiles(path, "*.*", SearchOption.AllDirectories)
         .Where(f => set.Contains(
             new FileInfo(f).Extension,
             StringComparer.OrdinalIgnoreCase));

o

from file in Directory.GetFiles(path, "*.*", SearchOption.AllDirectories)
from ext in set
where String.Equals(ext, new FileInfo(file).Extension, StringComparison.OrdinalIgnoreCase)
select file;

No puedo usar el .Wheremétodo porque estoy programando en .NET Framework 2.0 (Linq solo es compatible con .NET Framework 3.5+).

Código de abajo no es sensible a mayúsculas (por lo que .CaBo .cabse enumeran también).

string[] ext = new string[2] { "*.CAB", "*.MSU" };

foreach (string found in ext)
{
    string[] extracted = Directory.GetFiles("C:\\test", found, System.IO.SearchOption.AllDirectories);

    foreach (string file in extracted)
    {
        Console.WriteLine(file);
    }
}

La siguiente función busca en múltiples patrones, separados por comas. También puede especificar una exclusión, por ejemplo: "! Web.config" buscará todos los archivos y excluirá "web.config". Los patrones se pueden mezclar.

private string[] FindFiles(string directory, string filters, SearchOption searchOption)
{
    if (!Directory.Exists(directory)) return new string[] { };

    var include = (from filter in filters.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries) where !string.IsNullOrEmpty(filter.Trim()) select filter.Trim());
    var exclude = (from filter in include where filter.Contains(@"!") select filter);

    include = include.Except(exclude);

    if (include.Count() == 0) include = new string[] { "*" };

    var rxfilters = from filter in exclude select string.Format("^{0}$", filter.Replace("!", "").Replace(".", @"\.").Replace("*", ".*").Replace("?", "."));
    Regex regex = new Regex(string.Join("|", rxfilters.ToArray()));

    List<Thread> workers = new List<Thread>();
    List<string> files = new List<string>();

    foreach (string filter in include)
    {
        Thread worker = new Thread(
            new ThreadStart(
                delegate
                {
                    string[] allfiles = Directory.GetFiles(directory, filter, searchOption);
                    if (exclude.Count() > 0)
                    {
                        lock (files)
                            files.AddRange(allfiles.Where(p => !regex.Match(p).Success));
                    }
                    else
                    {
                        lock (files)
                            files.AddRange(allfiles);
                    }
                }
            ));

        workers.Add(worker);

        worker.Start();
    }

    foreach (Thread worker in workers)
    {
        worker.Join();
    }

    return files.ToArray();

}

Uso:

foreach (string file in FindFiles(@"D:\628.2.11", @"!*.config, !*.js", SearchOption.AllDirectories))
            {
                Console.WriteLine(file);
            }

List<string> FileList = new List<string>();
DirectoryInfo di = new DirectoryInfo("C:\\DirName");

IEnumerable<FileInfo> fileList = di.GetFiles("*.*");

//Create the query
IEnumerable<FileInfo> fileQuery = from file in fileList
                                  where (file.Extension.ToLower() == ".jpg" || file.Extension.ToLower() == ".png")
                                  orderby file.LastWriteTime
                                  select file;

foreach (System.IO.FileInfo fi in fileQuery)
{
    fi.Attributes = FileAttributes.Normal;
    FileList.Add(fi.FullName);
}

en .NET 2.0 (sin Linq):

public static List<string> GetFilez(string path, System.IO.SearchOption opt,  params string[] patterns)
{
    List<string> filez = new List<string>();
    foreach (string pattern in patterns)
    {
        filez.AddRange(
            System.IO.Directory.GetFiles(path, pattern, opt)
        );
    }


    // filez.Sort(); // Optional
    return filez; // Optional: .ToArray()
}

Entonces úsalo:

foreach (string fn in GetFilez(path
                             , System.IO.SearchOption.AllDirectories
                             , "*.xml", "*.xml.rels", "*.rels"))
{}

DirectoryInfo directory = new DirectoryInfo(Server.MapPath("~/Contents/"));

//Using Union

FileInfo[] files = directory.GetFiles("*.xlsx")
                            .Union(directory
                            .GetFiles("*.csv"))
                            .ToArray();

Acabo de encontrar otra forma de hacerlo. Todavía no es una operación, sino tirarla para ver qué piensan otras personas al respecto.

private void getFiles(string path)
{
    foreach (string s in Array.FindAll(Directory.GetFiles(path, "*", SearchOption.AllDirectories), predicate_FileMatch))
    {
        Debug.Print(s);
    }
}

private bool predicate_FileMatch(string fileName)
{
    if (fileName.EndsWith(".mp3"))
        return true;
    if (fileName.EndsWith(".jpg"))
        return true;
    return false;
}

Qué pasa

string[] filesPNG = Directory.GetFiles(path, "*.png");
string[] filesJPG = Directory.GetFiles(path, "*.jpg");
string[] filesJPEG = Directory.GetFiles(path, "*.jpeg");

int totalArraySizeAll = filesPNG.Length + filesJPG.Length + filesJPEG.Length;
List<string> filesAll = new List<string>(totalArraySizeAll);
filesAll.AddRange(filesPNG);
filesAll.AddRange(filesJPG);
filesAll.AddRange(filesJPEG);

Haga las extensiones que desea una cadena, es decir, ".mp3.jpg.wma.wmf" y luego verifique si cada archivo contiene la extensión que desea. Esto funciona con .net 2.0 ya que no usa LINQ.

string myExtensions=".jpg.mp3";

string[] files=System.IO.Directory.GetFiles("C:\myfolder");

foreach(string file in files)
{
   if(myExtensions.ToLower().contains(System.IO.Path.GetExtension(s).ToLower()))
   {
      //this file has passed, do something with this file

   }
}

La ventaja de este enfoque es que puede agregar o quitar extensiones sin editar el código, es decir, para agregar imágenes png, simplemente escriba myExtensions = ". Jpg.mp3.png".

/// <summary>
/// Returns the names of files in a specified directories that match the specified patterns using LINQ
/// </summary>
/// <param name="srcDirs">The directories to seach</param>
/// <param name="searchPatterns">the list of search patterns</param>
/// <param name="searchOption"></param>
/// <returns>The list of files that match the specified pattern</returns>
public static string[] GetFilesUsingLINQ(string[] srcDirs,
     string[] searchPatterns,
     SearchOption searchOption = SearchOption.AllDirectories)
{
    var r = from dir in srcDirs
            from searchPattern in searchPatterns
            from f in Directory.GetFiles(dir, searchPattern, searchOption)
            select f;

    return r.ToArray();
}

Nop ... creo que tienes que hacer tantas llamadas como los tipos de archivos que quieras.

Yo mismo crearía una función tomando una matriz en cadenas con las extensiones que necesito y luego iteraría en esa matriz haciendo todas las llamadas necesarias. Esa función devolvería una lista genérica de los archivos que coinciden con las extensiones que envié.

Espero eso ayude.

Tuve el mismo problema y no pude encontrar la solución correcta, así que escribí una función llamada GetFiles:

/// <summary>
/// Get all files with a specific extension
/// </summary>
/// <param name="extensionsToCompare">string list of all the extensions</param>
/// <param name="Location">string of the location</param>
/// <returns>array of all the files with the specific extensions</returns>
public string[] GetFiles(List<string> extensionsToCompare, string Location)
{
    List<string> files = new List<string>();
    foreach (string file in Directory.GetFiles(Location))
    {
        if (extensionsToCompare.Contains(file.Substring(file.IndexOf('.')+1).ToLower())) files.Add(file);
    }
    files.Sort();
    return files.ToArray();
}

Esta función llamará Directory.Getfiles()solo una vez.

Por ejemplo, llame a la función de esta manera:

string[] images = GetFiles(new List<string>{"jpg", "png", "gif"}, "imageFolder");

EDITAR: Para obtener un archivo con múltiples extensiones, use este:

/// <summary>
    /// Get the file with a specific name and extension
    /// </summary>
    /// <param name="filename">the name of the file to find</param>
    /// <param name="extensionsToCompare">string list of all the extensions</param>
    /// <param name="Location">string of the location</param>
    /// <returns>file with the requested filename</returns>
    public string GetFile( string filename, List<string> extensionsToCompare, string Location)
    {
        foreach (string file in Directory.GetFiles(Location))
        {
            if (extensionsToCompare.Contains(file.Substring(file.IndexOf('.') + 1).ToLower()) &&& file.Substring(Location.Length + 1, (file.IndexOf('.') - (Location.Length + 1))).ToLower() == filename) 
                return file;
        }
        return "";
    }

Por ejemplo, llame a la función de esta manera:

string image = GetFile("imagename", new List<string>{"jpg", "png", "gif"}, "imageFolder");

Me pregunto por qué hay tantas "soluciones" publicadas?

Si mi comprensión de novato sobre cómo funciona GetFiles es correcta, solo hay dos opciones y cualquiera de las soluciones anteriores se puede resumir en estas:

1. GetFiles, luego filtro: Rápido, pero un asesino de memoria debido al almacenamiento de sobrecarga hasta que se aplican los filtros

2. Filtre mientras GetFiles: más lento cuanto más filtros estén configurados, pero menor uso de memoria ya que no se almacena ninguna sobrecarga.
   Esto se explica en una de las publicaciones anteriores con un punto de referencia impresionante: cada opción de filtro provoca una operación separada GetFile, por lo que la misma parte del disco duro se lee varias veces.

En mi opinión, la opción 1) es mejor, pero usar SearchOption.AllDirectories en carpetas como C: \ usaría grandes cantidades de memoria.
Por lo tanto, simplemente haría un submétodo recursivo que recorra todas las subcarpetas con la opción 1)

Esto debería causar solo 1 operación GetFiles en cada carpeta y, por lo tanto, ser rápido (Opción 1), pero use solo una pequeña cantidad de memoria ya que los filtros se aplican después de la lectura de cada subcarpeta -> la sobrecarga se elimina después de cada subcarpeta.

Por favor, corríjame si estoy equivocado. Soy, como dije, bastante nuevo en la programación, pero quiero obtener una comprensión más profunda de las cosas para eventualmente ser bueno en esto :)

Si está utilizando VB.NET (o importó la dependencia en su proyecto C #), en realidad existe un método conveniente que permite filtrar por múltiples extensiones:

Microsoft.VisualBasic.FileIO.FileSystem.GetFiles("C:\\path", Microsoft.VisualBasic.FileIO.SearchOption.SearchAllSubDirectories, new string[] {"*.mp3", "*.jpg"});

En VB.NET se puede acceder a esto a través del espacio Mi nombre:

My.Computer.FileSystem.GetFiles("C:\path", FileIO.SearchOption.SearchAllSubDirectories, {"*.mp3", "*.jpg"})

Desafortunadamente, estos métodos de conveniencia no admiten una variante vagamente evaluada como lo Directory.EnumerateFiles()hace.

No sé qué solución es mejor, pero uso esto:

String[] ext = "*.ext1|*.ext2".Split('|');

            List<String> files = new List<String>();
            foreach (String tmp in ext)
            {
                files.AddRange(Directory.GetFiles(dir, tmp, SearchOption.AllDirectories));
            }

Aquí hay una manera simple y elegante de obtener archivos filtrados

var allowedFileExtensions = ".csv,.txt";


var files = Directory.EnumerateFiles(@"C:\MyFolder", "*.*", SearchOption.TopDirectoryOnly)
                .Where(s => allowedFileExtensions.IndexOf(Path.GetExtension(s)) > -1).ToArray(); 

O simplemente puede convertir la cadena de extensiones a Cadena ^

vector <string>  extensions = { "*.mp4", "*.avi", "*.flv" };
for (int i = 0; i < extensions.size(); ++i)
{
     String^ ext = gcnew String(extensions[i].c_str());;
     String^ path = "C:\\Users\\Eric\\Videos";
     array<String^>^files = Directory::GetFiles(path,ext);
     Console::WriteLine(ext);
     cout << " " << (files->Length) << endl;
}

¡Usar el patrón de búsqueda GetFiles para filtrar la extensión no es seguro! Por ejemplo, tiene dos archivos Test1.xls y Test2.xlsx y desea filtrar el archivo xls utilizando el patrón de búsqueda * .xls, pero GetFiles devuelve Test1.xls y Test2.xlsx No estaba al tanto de esto y recibí un error en la producción entorno cuando algunos archivos temporales de repente se manejaron como archivos correctos. El patrón de búsqueda fue * .txt y los archivos temporales se llamaron * .txt20181028_100753898 Por lo tanto, no se puede confiar en el patrón de búsqueda, también debe agregar una verificación adicional en los nombres de archivo.