Você pode chamar Directory.GetFiles () com vários filtros?

Estou tentando usar o Directory.GetFiles()método para recuperar uma lista de arquivos de vários tipos, como mp3's e jpg' s. Eu tentei o seguinte sem sorte:

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

Existe uma maneira de fazer isso em uma ligação?

Para .NET 4.0 e posterior,

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

Para versões anteriores do .NET,

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

editar: Por favor, leia os comentários. A melhoria sugerida por Paul Farry e o problema de memória / desempenho apontado por Christian.K são ambos muito importantes.

Que tal agora:

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

Encontrei-o aqui (nos comentários): http://msdn.microsoft.com/en-us/library/wz42302f.aspx

Se você tiver uma grande lista de extensões para verificar, use o seguinte. Eu não queria criar muitas instruções OR, então modifiquei o que lette escreveu.

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

Você poderia:

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

• Não se esqueça do novo .NET4 Directory.EnumerateFilespara aumentar o desempenho ( qual é a diferença entre Directory.EnumerateFiles e Directory.GetFiles? )
• "IgnoreCase" deve ser mais rápido que "ToLower" (em .EndsWith("aspx", StringComparison.OrdinalIgnoreCase)vez de .ToLower().EndsWith("aspx"))

Mas o benefício real EnumerateFilesaparece quando você divide os filtros e mescla os resultados:

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

Fica um pouco mais rápido se você não precisar transformá-los em globs (ou seja, exts = new[] {"*.mp3", "*.jpg"}já).

Avaliação de desempenho com base no seguinte teste do LinqPad (nota: Perfapenas repete o delegado 10000 vezes) https://gist.github.com/zaus/7454021

(republicado e estendido de 'duplicado', pois essa pergunta não solicitou especificamente LINQ: várias extensões de arquivo searchPattern para System.IO.Directory.GetFiles )

Eu sei que é pergunta antiga, mas LINQ: (.NET40 +)

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

Há também uma solução de descida que parece não ter nenhuma sobrecarga de memória ou desempenho e ser bastante elegante:

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

Outra maneira de usar o Linq, mas sem precisar retornar tudo e filtrar isso na memória.

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

Na verdade, são 2 chamadas para GetFiles(), mas acho que é consistente com o espírito da pergunta e as retorna em uma enumerável.

Não. Tente o seguinte:

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 )
    {
        ...;
    }

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

Deixei

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

Então

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

ou

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

Não consigo usar o .Wheremétodo porque estou programando no .NET Framework 2.0 (o Linq é suportado apenas no .NET Framework 3.5+).

O código abaixo não diferencia maiúsculas de minúsculas (portanto, .CaBou .cabtambém será listado).

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

A função a seguir pesquisa em vários padrões, separados por vírgulas. Você também pode especificar uma exclusão, por exemplo: "! Web.config" procurará todos os arquivos e excluirá "web.config". Padrões podem ser misturados.

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

no .NET 2.0 (sem 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()
}

Então use-o:

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();

Acabei de encontrar uma outra maneira de fazê-lo. Ainda não é uma operação, mas joga fora para ver o que as outras pessoas pensam sobre isso.

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

A respeito

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

Faça as extensões desejadas em uma string, por exemplo, ".mp3.jpg.wma.wmf" e verifique se cada arquivo contém a extensão desejada. Isso funciona com o .net 2.0, pois não usa o 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

   }
}

A vantagem dessa abordagem é que você pode adicionar ou remover extensões sem editar o código, ou seja, para adicionar imagens png, basta escrever 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();
}

Não ... acredito que você precise fazer quantas chamadas os tipos de arquivo desejados.

Eu mesmo criaria uma função pegando uma matriz em seqüências de caracteres com os ramais necessários e, em seguida, iteraria nessa matriz, fazendo todas as chamadas necessárias. Essa função retornaria uma lista genérica dos arquivos correspondentes às extensões que eu enviei.

Espero que ajude.

Eu tinha o mesmo problema e não consegui encontrar a solução certa, então escrevi uma função chamada 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 função chama Directory.Getfiles()apenas uma vez.

Por exemplo, chame a função assim:

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

EDIT: Para obter um arquivo com várias extensões, 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 exemplo, chame a função assim:

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

Eu me pergunto por que existem tantas "soluções" postadas?

Se meu entendimento de novato sobre como o GetFiles funciona estiver correto, existem apenas duas opções e qualquer uma das soluções acima pode ser resumida a estas:

1. GetFiles e filtro: Rápido, mas um destruidor de memória devido ao armazenamento de sobrecarga até que os filtros sejam aplicados

2. Filtrar enquanto GetFiles: mais lento, mais filtros são definidos, mas pouco uso de memória, pois nenhuma sobrecarga é armazenada.
   Isso é explicado em uma das postagens acima, com uma referência impressionante: cada opção de filtro causa uma operação GetFile separada, para que a mesma parte do disco rígido seja lida várias vezes.

Na minha opinião, a opção 1) é melhor, mas usar o SearchOption.AllDirectories em pastas como C: \ usaria enormes quantidades de memória.
Portanto, eu faria apenas um sub-método recursivo que percorre todas as subpastas usando a opção 1)

Isso deve causar apenas 1 operação GetFiles em cada pasta e, portanto, ser rápido (Opção 1), mas use apenas uma pequena quantidade de memória, pois os filtros são aplicados após a leitura de cada subpasta -> a sobrecarga é excluída após cada subpasta.

Por favor corrija-me se eu estiver errado. Eu sou como eu disse bastante novo para a programação, mas quero obter uma compreensão mais profunda das coisas para eventualmente se tornar bom nisso :)

Se você estiver usando o VB.NET (ou importou a dependência para o seu projeto C #), existe realmente um método de conveniência que permite filtrar várias extensões:

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

No VB.NET, isso pode ser acessado através do namespace My:

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

Infelizmente, esses métodos de conveniência não suportam uma variante avaliada preguiçosamente, como o Directory.EnumerateFiles()fazem.

não sei qual solução é melhor, mas uso isso:

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

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

Aqui está uma maneira simples e elegante de obter arquivos filtrados

var allowedFileExtensions = ".csv,.txt";


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

Ou você pode simplesmente converter a sequência de extensões em String ^

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 o padrão de pesquisa GetFiles para filtrar a extensão não é seguro! Por exemplo, você tem dois arquivos Test1.xls e Test2.xlsx e deseja filtrar o arquivo xls usando o padrão de pesquisa * .xls, mas GetFiles retorna Test1.xls e Test2.xlsx. Não sabia disso e obtive um erro na produção ambiente quando alguns arquivos temporários foram repentinamente tratados como arquivos corretos. O padrão de pesquisa era * .txt e os arquivos temporários foram nomeados * .txt20181028_100753898 Portanto, o padrão de pesquisa não é confiável, você também deve adicionar uma verificação extra aos nomes de arquivos.