Pouvez-vous appeler Répertoire.GetFiles() avec plusieurs filtres?

Pour .NET 4.0 et versions ultérieures,

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

Pour les versions antérieures de .NET,

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

edit: lisez les commentaires. L'amélioration que Paul Farry suggère, et la mémoire/problème de performance que Chrétienne.K points sont à la fois très important.

Si vous avez une grande liste des extensions de vérifier que vous pouvez utiliser. Je ne voulais pas créer beaucoup de OU déclarations j'ai donc modifié ce lette a écrit.

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
}

Je sais que c'est une vieille question, mais LINQ: (.NET40+)

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

Il y a aussi une descente solution qui semble ne pas avoir de mémoire ou de surcharge de performance et d'être assez élégant:

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

Laisser

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

Puis

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;

La fonction suivante recherches sur des modèles multiples, séparés par des virgules. Vous pouvez également spécifier une exclusion, par exemple: "!web.config" permet de rechercher les fichiers et de les exclure "du web.config". Les modèles peuvent être mélangés.

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

Utilisation:

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

Viens de trouver une autre façon de le faire. Toujours pas d'une seule opération, mais le fait de lancer pour voir ce que les autres pensent d'elle.

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

Ce sujet

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

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

dans .NET 2.0 (pas de 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()
}

Puis l'utiliser:

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

Je me demande pourquoi il y a autant de "solutions" posté?

Si mon rookie-compréhension sur la façon dont GetFiles travaux est de droite, il y a seulement deux options et l'une des solutions ci-dessus peut être réduit à ces:

1. GetFiles, puis filtre: Rapide, mais un mémoire killer en raison de stocker des frais généraux jusqu'à ce que les filtres sont appliqués

2. Filtre en GetFiles: plus Lent plus les filtres sont fixés, mais la faible utilisation de la mémoire comme aucun frais n'est stockée.
   Ceci est expliqué dans l'un des postes ci-dessus avec un nombre impressionnant de référence: Chaque option de filtre provoque une salle de GetFile d'opération, de sorte que la même partie du disque est lu plusieurs fois.

À mon avis, l'Option 1) est mieux, mais à l'aide de la SearchOption.AllDirectories sur des dossiers comme C:\ serait d'utiliser d'énormes quantités de mémoire.

À cet effet, je voudrais simplement faire un appel récursif à la sous-méthode qui passe par tous les sous-dossiers à l'aide de l'option 1)

Ce qui devrait entraîner seulement 1 GetFiles-opération sur chaque dossier et à cet effet, être rapide (Option 1), mais utiliser seulement une petite quantité de mémoire que les filtres sont appliqués afters de chacun des sous-dossiers de la lecture -> frais généraux sont supprimés après chaque sous-dossier.

S'il vous plaît corrigez-moi si je me trompe. Je suis comme je l'ai dit tout à fait nouveau pour la programmation, mais veulent acquérir une compréhension plus profonde des choses, à terme, être bon à ce jeu 🙂

Si vous utilisez VB.NET (ou importée de la dépendance dans votre projet C#), il existe une méthode pratique qui permet de filtrer les extensions multiples:

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

Dans VB.NET cela peut être accédé par le biais de la Mon-espace de noms:

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

Malheureusement, ces méthodes pratiques ne prennent pas en charge paresseusement évalué variante comme Directory.EnumerateFiles() n'.

Ou vous pouvez simplement convertir la chaîne d'extensions Chaîne^

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