How to filter Directory.EnumerateFiles with multiple criteria?

The most elegant approach is probably:

var directory = new DirectoryInfo(path);
var masks = new[] { "*.mp3", "*.wav" };
var files = masks.SelectMany(directory.EnumerateFiles);

But it might not be the most efficient.

string path = "C:\\";
var result = new List<string>();
string[] extensions = { ".mp3", ".wma", ".mp4", ".wav" };

foreach (string file in Directory.EnumerateFiles(path, "*.*", SearchOption.AllDirectories)
    .Where(s => extensions.Any(ext => ext == Path.GetExtension(s))))
{
    result.Add(file);
    Console.WriteLine(file);
}

As I noted in a comment, while Mikael Svenson's helper methods are great little solutions, if you're ever trying to do something for a one-off project in a hurry again, consider the Linq extension .Union( ). This allows you to join together two enumerable sequences. In your case, the code would look like this:

List<string> result = Directory.EnumerateFiles(path,"*.mp3", SearchOption.AllDirectories)
.Union(Directory.EnumerateFiles(path, ".wma", SearchOption.AllDirectories)).ToList();

This creates and fills your result list all in one line.

I solved this problem this way:

string[] formats = {".mp3", ".wma", ".mp4"};

foreach (var file in Directory.EnumerateFiles(folder, "*.*", SearchOption.AllDirectories).Where(x => formats.Any(x.EndsWith)))
{
    // TODO...
}

I know this is an old post but I came up with a solution people might like to use.

private IEnumerable<FileInfo> FindFiles()
{
    DirectoryInfo sourceDirectory = new DirectoryInfo(@"C:\temp\mydirectory");
    string foldersFilter = "*bin*,*obj*";
    string fileTypesFilter = "*.mp3,*.wma,*.mp4,*.wav";

    // filter by folder name and extension
    IEnumerable<DirectoryInfo> directories = foldersFilter.Split(',').SelectMany(pattern => sourceDirectory.EnumerateDirectories(pattern, SearchOption.AllDirectories));
    List<FileInfo> files = new List<FileInfo>();
    files.AddRange(directories.SelectMany(dir => fileTypesFilter.Split(',').SelectMany(pattern => dir.EnumerateFiles(pattern, SearchOption.AllDirectories))));

    // Pick up root files
    files.AddRange(fileTypesFilter.Split(',').SelectMany(pattern => sourceDirectory.EnumerateFiles(fileTypesFilter, SearchOption.TopDirectoryOnly)));

    // filter just by extension
    IEnumerable<FileInfo> files2 = fileTypesFilter.Split(',').SelectMany(pattern => sourceDirectory.EnumerateFiles(pattern, SearchOption.AllDirectories));
}

For Filtering using the same File Extensions list strings as GUI Open Dialogs e.g.:

".exe,.pdb".Split(',', ';', '|').SelectMany(_ => Directory.EnumerateFiles(".", "*" + _, searchOptions)

Packaged up:

    public static IEnumerable<string> EnumerateFilesFilter(string path, string filesFilter, SearchOption searchOption = SearchOption.TopDirectoryOnly)
    {
        return filesFilter.Split(',', ';', '|').SelectMany(_ => Directory.EnumerateFiles(path, "*" + _, searchOption));
    }

Beginning from the NET Core 2.1 and .NET Standard 2.1 there is built-in class FileSystemName: documentation, source code which provides methods for matching file system names:

Example:

public static IEnumerable<string> EnumerateFiles(string path, string[] searchPatterns, SearchOption searchOption = SearchOption.TopDirectoryOnly)
{
    return Directory.EnumerateFiles(path, "*", searchOption)
                    .Where(fileName => searchPatterns.Any(pattern => FileSystemName.MatchesSimpleExpression(pattern, fileName)));
}

I've adapted the existing source code of FileSystemName to be used in .NetFramework 4: Gist FileSystemName for .NetFramework 4.

To filter using a Regex pattern and file Modified date.

In the example it return files that:

• name starts with Bck for extensions tgz and xml
• are older than 200 days.

Returns Full path name

string startPath = @"c:\temp";
int olderThanDays = 200;

Regex re = new Regex($@"^Bck.*\.tgz|^Bck.*\.xml");
var files = new DirectoryInfo(startPath)
    .EnumerateFiles($"*.*", SearchOption.AllDirectories)
    .Where(f => f.CreationTime < DateTime.Now.AddDays(-olderThanDays) && re.IsMatch(f.Name))             
    .Select(f => f.FullName).ToList();

Yevhan's answer is by far the cleanest and most modern, but I would take it one step further and create a FileSystemEnumerable<FileInfo> directly. This will give you the added benefit of being able to provide your own transform (to in this case get a FileInfo object rather than a file path), and specify a ShouldIncludePredicate predicate to execute all your desired filters at once, with out needing multiple enumerations.

    var path = @"C:\SEARCH\DIRECTORY";

    IReadOnlyList<string> filters = [
        "*.xlsx",
        "*.xls"
    ];

    bool FilterPrediate(ref FileSystemEntry f)
    {
        if (f.IsDirectory)
            return false;

        foreach (var filter in filters)
            if (FileSystemName.MatchesSimpleExpression(filter, f.FileName))
                return true;

        return false;
    }

    var enumerable = new FileSystemEnumerable<FileInfo>(path, (ref FileSystemEntry f) => (FileInfo)f.ToFileSystemInfo())
    {
        ShouldIncludePredicate = FilterPrediate
    };

    foreach (FileInfo file in enumerable)
    {
        // TODO do work
    }

This is the simplest solution I could think of:

var tracks = di.EnumerateFiles("*.mp3").ToList();
tracks.AddRange(di.EnumerateFiles("*.wma"));