Können Sie Directory.GetFiles () mit mehreren Filtern aufrufen?

Ich versuche, die Directory.GetFiles()Methode zu verwenden, um eine Liste von Dateien verschiedener Typen abzurufen, z. B. mp3's und jpg' s. Ich habe beide der folgenden ohne Glück versucht:

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

Gibt es eine Möglichkeit, dies in einem Anruf zu tun?

Für .NET 4.0 und höher

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

Für frühere Versionen von .NET

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

bearbeiten: Bitte lesen Sie die Kommentare. Die von Paul Farry vorgeschlagene Verbesserung und das von Christian.K hervorgehobene Gedächtnis- / Leistungsproblem sind beide sehr wichtig.

Wie wäre es damit:

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

Ich habe es hier gefunden (in den Kommentaren): http://msdn.microsoft.com/en-us/library/wz42302f.aspx

Wenn Sie eine große Liste von zu überprüfenden Erweiterungen haben, können Sie Folgendes verwenden. Ich wollte nicht viele OR-Anweisungen erstellen, also habe ich geändert, was lette geschrieben hat.

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
}

zum

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

Du könntest:

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

• Vergessen Sie nicht das neue .NET4 Directory.EnumerateFilesfür eine Leistungssteigerung ( Was ist der Unterschied zwischen Directory.EnumerateFiles und Directory.GetFiles? )
• "IgnoreCase" sollte schneller sein als "ToLower" ( .EndsWith("aspx", StringComparison.OrdinalIgnoreCase)anstatt .ToLower().EndsWith("aspx"))

Der eigentliche Vorteil von EnumerateFileszeigt sich jedoch, wenn Sie die Filter aufteilen und die Ergebnisse zusammenführen:

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

Es wird ein bisschen schneller, wenn Sie sie nicht in Globs verwandeln müssen (dh exts = new[] {"*.mp3", "*.jpg"}bereits).

Leistungsbewertung basierend auf dem folgenden LinqPad-Test (Hinweis: PerfWiederholen Sie den Delegaten nur 10000 Mal) https://gist.github.com/zaus/7454021

(neu gepostet und von 'duplicate' erweitert, da für diese Frage ausdrücklich kein LINQ angefordert wurde: Mehrere Dateierweiterungen searchPattern for System.IO.Directory.GetFiles )

Ich weiß, es ist eine alte Frage, aber LINQ: (.NET40 +)

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

Es gibt auch eine Abstiegslösung, die keinen Speicher- oder Leistungsaufwand zu haben scheint und recht elegant ist:

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

Eine andere Möglichkeit, Linq zu verwenden, ohne jedoch alles zurückgeben und im Speicher filtern zu müssen.

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

Es sind eigentlich 2 Anrufe GetFiles(), aber ich denke, es stimmt mit dem Geist der Frage überein und gibt sie in einer Aufzählung zurück.

Nee. Versuche Folgendes:

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

Entnommen aus: http://blogs.msdn.com/markda/archive/2006/04/20/580075.aspx

Lassen

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

Dann

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

oder

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

Ich kann nicht verwenden .Where Methode , da ich in .NET Framework 2.0 programmiere (Linq wird nur in .NET Framework 3.5+ unterstützt).

Code ist unten nicht Groß- und Kleinschreibung (so .CaBoder .cabwird auch aufgeführt werden).

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

Die folgende Funktion sucht nach mehreren Mustern, die durch Kommas getrennt sind. Sie können auch einen Ausschluss angeben, z. B.: "! Web.config" sucht nach allen Dateien und schließt "web.config" aus. Muster können gemischt werden.

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

}

Verwendungszweck:

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

in .NET 2.0 (kein 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()
}

Dann benutze es:

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

Habe gerade einen anderen Weg gefunden, es zu tun. Immer noch nicht eine Operation, aber wirf sie raus, um zu sehen, was andere Leute darüber denken.

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

Wie wäre es mit

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

Machen Sie die gewünschten Erweiterungen zu einer Zeichenfolge, dh ".mp3.jpg.wma.wmf", und prüfen Sie dann, ob jede Datei die gewünschte Erweiterung enthält. Dies funktioniert mit .net 2.0, da LINQ nicht verwendet wird.

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

   }
}

Der Vorteil dieses Ansatzes ist, dass Sie Erweiterungen hinzufügen oder entfernen können, ohne den Code zu bearbeiten, dh um PNG-Bilder hinzuzufügen, schreiben Sie einfach 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();
}

Nein ... Ich glaube, Sie müssen so viele Anrufe tätigen, wie Sie möchten.

Ich würde selbst eine Funktion erstellen, die ein Array für Zeichenfolgen mit den von mir benötigten Erweiterungen verwendet und dann auf diesem Array iteriert und alle erforderlichen Aufrufe ausführt. Diese Funktion würde eine allgemeine Liste der Dateien zurückgeben, die den von mir gesendeten Erweiterungen entsprechen.

Ich hoffe es hilft.

Ich hatte das gleiche Problem und konnte nicht die richtige Lösung finden. Deshalb schrieb ich eine Funktion namens 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();
}

Diese Funktion ruft Directory.Getfiles()nur einmal auf.

Rufen Sie zum Beispiel die Funktion folgendermaßen auf:

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

BEARBEITEN: Um eine Datei mit mehreren Erweiterungen zu erhalten, verwenden Sie diese:

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

Rufen Sie zum Beispiel die Funktion folgendermaßen auf:

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

Ich frage mich, warum es so viele "Lösungen" gibt?

Wenn mein Anfängerverständnis darüber, wie GetFiles funktioniert, richtig ist, gibt es nur zwei Optionen, und jede der oben genannten Lösungen kann auf diese zurückgeführt werden:

1. GetFiles, dann Filter: Schnell, aber ein Speicherkiller aufgrund des Speicheraufwands, bis die Filter angewendet werden

2. Filtern während GetFiles: Langsamer, je mehr Filter eingestellt sind, aber geringer Speicherbedarf, da kein Overhead gespeichert wird.
   Dies wird in einem der oben genannten Beiträge mit einem beeindruckenden Benchmark erläutert: Jede Filteroption bewirkt eine separate GetFile-Operation, sodass derselbe Teil der Festplatte mehrmals gelesen wird.

Meiner Meinung nach ist Option 1) besser, aber die Verwendung von SearchOption.AllDirectories in Ordnern wie C: \ würde sehr viel Speicher verbrauchen.
Daher würde ich nur eine rekursive Untermethode erstellen, die mit Option 1) alle Unterordner durchläuft.

Dies sollte nur 1 GetFiles-Operation für jeden Ordner verursachen und daher schnell sein (Option 1), aber nur wenig Speicher verwenden, da die Filter nach dem Lesen jedes Unterordners angewendet werden -> Overhead wird nach jedem Unterordner gelöscht.

Bitte korrigieren Sie mich, wenn ich falsch liege. Ich bin, wie gesagt, ziemlich neu in der Programmierung, möchte aber ein tieferes Verständnis der Dinge erlangen, um irgendwann gut darin zu werden :)

Wenn Sie VB.NET verwenden (oder die Abhängigkeit in Ihr C # -Projekt importieren), gibt es tatsächlich eine praktische Methode, mit der Sie nach mehreren Erweiterungen filtern können:

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

In VB.NET kann über den My-Namespace darauf zugegriffen werden:

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

Leider unterstützen diese Convenience-Methoden keine träge bewertete Variante wie Directory.EnumerateFiles()diese.

Ich weiß nicht, welche Lösung besser ist, aber ich benutze diese:

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

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

Hier finden Sie eine einfache und elegante Möglichkeit, gefilterte Dateien abzurufen

var allowedFileExtensions = ".csv,.txt";


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

Oder Sie können einfach die Zeichenfolge der Erweiterungen in Zeichenfolge ^ konvertieren

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

Die Verwendung des GetFiles-Suchmusters zum Filtern der Erweiterung ist nicht sicher !! Zum Beispiel haben Sie zwei Dateien Test1.xls und Test2.xlsx und möchten die xls-Datei mithilfe des Suchmusters * .xls herausfiltern, aber GetFiles gibt sowohl Test1.xls als auch Test2.xlsx zurück. Ich war mir dessen nicht bewusst und habe einen Fehler in der Produktion erhalten Umgebung, in der einige temporäre Dateien plötzlich als richtige Dateien behandelt wurden. Das Suchmuster war * .txt und die temporären Dateien wurden * .txt20181028_100753898 benannt. Damit das Suchmuster nicht vertrauenswürdig ist, müssen Sie auch die Dateinamen zusätzlich überprüfen.