Можете ли вы вызвать Directory.GetFiles () с несколькими фильтрами?

Неа. Попробуйте следующее:

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

Взято из: http://blogs.msdn.com/markda/archive/2006/04/20/580075.aspx

Нет ... Я считаю, что вам нужно делать столько звонков, сколько типов файлов вы хотите.

Я бы сам создал функцию, взяв массив строк с нужными мне расширениями, а затем перебрал бы этот массив, сделав все необходимые вызовы. Эта функция вернет общий список файлов, соответствующих отправленным мной расширениям.

Надеюсь, это поможет.

Для .NET 4.0 и более поздних версий

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

Для более ранних версий .NET

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

редактировать:Пожалуйста, прочтите комментарии. Улучшение, которое предлагает Пол Фарри, и проблема памяти / производительности, на которую указывает Christian.K, очень важны.

Просто нашел другой способ сделать это. По-прежнему не одна операция, а выбросить ее, чтобы узнать, что думают об этом другие.

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

Следующая функция выполняет поиск по нескольким шаблонам, разделенным запятыми. Вы также можете указать исключение, например: «! Web.config» будет искать все файлы и исключать «web.config». Узоры можно смешивать.

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

}

Использование:

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

Позволять

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

Затем

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

или же

from file in Directory.GetFiles(path, "*.*", SearchOption.AllDirectories)
from ext in set
where String.Equals(ext, new FileInfo(file).Extension, StringComparison.OrdinalIgnoreCase)
select 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);
}

Если у вас есть большой список расширений, которые нужно проверить, вы можете использовать следующее. Я не хотел создавать много операторов ИЛИ, поэтому я изменил то, что написал lette.

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
}

Я не могу использовать метод .Where, потому что я программирую в .NET Framework 2.0 (Linq поддерживается только в .NET Framework 3.5+).

Приведенный ниже код не чувствителен к регистру (поэтому .CaB или .cab также будут указаны).

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

Другой способ использовать Linq, но без необходимости возвращать все и фильтровать это в памяти.

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

На самом деле это 2 вызова GetFiles(), но я думаю, что это соответствует духу вопроса и возвращает их одним перечислимым.

Как насчет этого:

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

Нашел здесь (в комментариях): http://msdn.microsoft.com/en-us/library/wz42302f.aspx

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

Сделайте нужные расширения одной строкой, например ".mp3.jpg.wma.wmf", а затем проверьте, содержит ли каждый файл нужное вам расширение. Это работает с .net 2.0, поскольку он не использует 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

   }
}

Преимущество этого подхода в том, что вы можете добавлять или удалять расширения без редактирования кода, то есть для добавления изображений в формате png просто напишите myExtensions = ". Jpg.mp3.png".

Я знаю, что это старый вопрос, но LINQ: (.NET40 +)

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

У меня была такая же проблема, и я не мог найти правильного решения, поэтому я написал функцию 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();
}

Эта функция вызовет Directory.Getfiles() только один раз.

Например, вызовите функцию следующим образом:

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

Обновлено: Чтобы получить один файл с несколькими расширениями, используйте это:

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

Например, вызовите функцию следующим образом:

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

Существует также решение для спуска, которое, похоже, не имеет накладных расходов на память или производительность и довольно элегантно:

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

Интересно, почему опубликовано так много "решений"?

Если мои новички в понимании того, как работает GetFiles, верны, есть только два варианта, и любое из вышеперечисленных решений можно свести к следующему:

1. GetFiles, затем фильтр: быстро, но убивает память из-за накладных расходов на хранение до применения фильтров

2. Фильтр во время GetFiles: чем больше фильтров установлено, тем медленнее используется память, так как накладные расходы не сохраняются.
   Это объясняется в одном из вышеупомянутых сообщений с впечатляющим тестом: каждая опция фильтра вызывает отдельную операцию GetFile, поэтому одна и та же часть жесткого диска читается несколько раз.

На мой взгляд, вариант 1) лучше, но использование SearchOption.AllDirectories в таких папках, как C: \, потребует огромных объемов памяти. Поэтому я бы просто сделал рекурсивный под-метод, который проходит через все подпапки, используя вариант 1)

Это должно вызывать только одну операцию GetFiles для каждой папки и, следовательно, быть быстрым (вариант 1), но использовать только небольшой объем памяти, поскольку фильтры применяются после чтения каждой подпапки -> служебные данные удаляются после каждой подпапки.

Пожалуйста, поправьте меня, если я ошибаюсь. Как я уже сказал, я новичок в программировании, но хочу получить более глубокое понимание вещей, чтобы в конечном итоге стать хорошим в этом :)

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

//Using Union

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

для

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

Ты мог бы:

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

• Не забудьте новый .NET4 Directory.EnumerateFiles для повышения производительности (В чем разница между Directory.EnumerateFiles и Directory.GetFiles?)
• «IgnoreCase» должен быть быстрее, чем «ToLower» (.EndsWith("aspx", StringComparison.OrdinalIgnoreCase), а не .ToLower().EndsWith("aspx"))

Но реальное преимущество EnumerateFiles проявляется, когда вы разделяете фильтры и объединяете результаты:

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

Это станет немного быстрее, если вам не нужно превращать их в шары (например, exts = new[] {"*.mp3", "*.jpg"}).

Оценка производительности на основе следующего теста LinqPad (примечание: Perf просто повторяет делегат 10000 раз) https://gist.github.com/zaus/7454021

(репост и расширен из 'duplicate', поскольку этот вопрос специально не запрашивал LINQ: Несколько расширений файлов searchPattern для System.IO.Directory.GetFiles)

Или вы можете просто преобразовать строку расширений в 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;
}

в .NET 2.0 (без 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()
}

Тогда используйте это:

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

Что о

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

Я не знаю, какое решение лучше, но я использую это:

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

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

Если вы используете VB.NET (или импортировали зависимость в свой проект C#), на самом деле существует удобный метод, который позволяет фильтровать несколько расширений:

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

В VB.NET к этому можно получить доступ через пространство имен My:

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

К сожалению, эти удобные методы не поддерживают вариант с ленивой оценкой, как Directory.EnumerateFiles().

Использование шаблона поиска GetFiles для фильтрации расширения небезопасно !! Например, у вас есть два файла Test1.xls и Test2.xlsx, и вы хотите отфильтровать файл xls с помощью шаблона поиска * .xls, но GetFiles возвращает как Test1.xls, так и Test2.xlsx Я не знал об этом и получил ошибку в производственной среде, когда некоторые временные файлы внезапно стали обрабатываться как правильные. Шаблон поиска был * .txt, а временные файлы назывались * .txt20181028_100753898 Таким образом, шаблону поиска нельзя доверять, вам также нужно добавить дополнительную проверку имен файлов.

Вот простой и элегантный способ получить отфильтрованные файлы

var allowedFileExtensions = ".csv,.txt";


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