Puoi chiamare Directory.GetFiles () con più filtri?

Sto cercando di utilizzare il Directory.GetFiles()metodo per recuperare un elenco di file di più tipi, come mp3'e jpg'. Ho provato entrambi i seguenti senza fortuna:

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

C'è un modo per farlo in una chiamata?

Per .NET 4.0 e versioni successive,

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

Per le versioni precedenti di .NET,

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

modifica: leggi i commenti. Il miglioramento suggerito da Paul Farry e il problema di memoria / prestazioni che Christian.K sottolinea sono entrambi molto importanti.

Cosa ne pensi di questo:

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

L'ho trovato qui (nei commenti): http://msdn.microsoft.com/en-us/library/wz42302f.aspx

Se si dispone di un ampio elenco di estensioni da controllare, è possibile utilizzare quanto segue. Non volevo creare molte dichiarazioni OR, quindi ho modificato ciò che Lette ha scritto.

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
}

per

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

Potresti:

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

• Non dimenticare il nuovo .NET4 Directory.EnumerateFilesper un aumento delle prestazioni ( Qual è la differenza tra Directory.EnumerateFiles vs Directory.GetFiles? )
• "IgnoreCase" dovrebbe essere più veloce di "ToLower" ( .EndsWith("aspx", StringComparison.OrdinalIgnoreCase)anziché .ToLower().EndsWith("aspx"))

Ma il vero vantaggio di EnumerateFilesapparire quando dividi i filtri e unisci i risultati:

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

Diventa un po 'più veloce se non devi trasformarli in globs (cioè exts = new[] {"*.mp3", "*.jpg"}già).

Valutazione delle prestazioni basata sul seguente test LinqPad (nota: Perfripete il delegato solo 10000 volte) https://gist.github.com/zaus/7454021

(ripubblicato ed esteso da "duplicato" poiché tale domanda non ha richiesto specificamente LINQ: più estensioni di file searchPattern per System.IO.Directory.GetFiles )

So che è una vecchia domanda ma LINQ: (.NET40 +)

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

C'è anche una soluzione di discesa che sembra non avere alcun sovraccarico di memoria o prestazioni ed essere abbastanza elegante:

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

Un altro modo di usare Linq, ma senza dover restituire tutto e filtrare su quello in memoria.

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

In realtà sono 2 chiamate a GetFiles(), ma penso che sia coerente con lo spirito della domanda e le restituisce in un unico elenco.

No. Prova quanto segue:

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

Tratto da: http://blogs.msdn.com/markda/archive/2006/04/20/580075.aspx

Permettere

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

Poi

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

o

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

Non riesco a usare il .Wheremetodo perché sto programmando in .NET Framework 2.0 (Linq è supportato solo in .NET Framework 3.5+).

Il codice seguente non fa distinzione tra maiuscole e minuscole (quindi .CaBo .cabverrà elencato anche).

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

La seguente funzione cerca su più pattern, separati da virgole. È inoltre possibile specificare un'esclusione, ad esempio: "! Web.config" cercherà tutti i file ed escluderà "web.config". I motivi possono essere mescolati.

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

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

Quindi usalo:

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

Ho appena trovato un altro modo per farlo. Ancora nessuna operazione, ma buttarla fuori per vedere cosa ne pensano gli altri.

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

Che dire

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

Crea le estensioni che desideri con una stringa, ad esempio ".mp3.jpg.wma.wmf", quindi controlla se ogni file contiene l'estensione desiderata. Funziona con .net 2.0 in quanto non utilizza 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

   }
}

Il vantaggio di questo approccio è che puoi aggiungere o rimuovere estensioni senza modificare il codice, ad esempio per aggiungere immagini png, basta scrivere 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();
}

No ... credo che tu debba effettuare tutte le chiamate quanti tipi di file desideri.

Vorrei creare una funzione da solo prendendo una matrice su stringhe con le estensioni di cui ho bisogno e quindi ripetendo su quella matrice effettuando tutte le chiamate necessarie. Quella funzione restituirebbe un elenco generico dei file corrispondenti alle estensioni che avevo inviato.

Spero che sia d'aiuto.

Ho avuto lo stesso problema e non sono riuscito a trovare la soluzione giusta, quindi ho scritto una funzione chiamata 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();
}

Questa funzione chiamerà Directory.Getfiles()solo una volta.

Ad esempio, chiamare la funzione in questo modo:

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

EDIT: per ottenere un file con più estensioni usa questo:

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

Ad esempio, chiamare la funzione in questo modo:

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

Mi chiedo perché ci siano così tante "soluzioni" pubblicate?

Se la mia comprensione da principiante su come funziona GetFiles è corretta, ci sono solo due opzioni e una qualsiasi delle soluzioni sopra può essere portata a queste:

1. GetFiles, quindi filtro: veloce, ma un killer di memoria dovuto all'archiviazione fino a quando non vengono applicati i filtri

2. Filtra mentre GetFiles: più lentamente vengono impostati più filtri, ma l'utilizzo della memoria è ridotto poiché non viene archiviato alcun overhead.
   Questo è spiegato in uno dei post sopra con un benchmark impressionante: ogni opzione di filtro provoca un'operazione GetFile separata in modo che la stessa parte del disco rigido venga letta più volte.

A mio avviso, l'opzione 1) è migliore, ma usando SearchOption.AllDirectories su cartelle come C: \ si utilizzerebbero enormi quantità di memoria.
Quindi vorrei solo creare un sotto-metodo ricorsivo che attraversa tutte le sottocartelle usando l'opzione 1)

Ciò dovrebbe causare solo 1 operazione GetFiles su ciascuna cartella e quindi essere veloce (Opzione 1), ma utilizzare solo una piccola quantità di memoria poiché i filtri vengono applicati dopo la lettura di ogni sottocartella -> l'overhead viene eliminato dopo ogni sottocartella.

Perfavore, correggimi se sbaglio. Sono come ho detto abbastanza nuovo nella programmazione, ma voglio ottenere una comprensione più profonda delle cose per diventare finalmente bravo in questo :)

Se stai usando VB.NET (o hai importato la dipendenza nel tuo progetto C #), esiste effettivamente un metodo pratico che consente di filtrare più estensioni:

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

In VB.NET è possibile accedervi tramite My-namespace:

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

Sfortunatamente, questi metodi di convenienza non supportano una variante valutata pigramente come Directory.EnumerateFiles()fa.

non so quale sia la soluzione migliore, ma uso questo:

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

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

Ecco un modo semplice ed elegante per ottenere file filtrati

var allowedFileExtensions = ".csv,.txt";


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

Oppure puoi semplicemente convertire la stringa di estensioni in 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;
}

L'uso del modello di ricerca GetFiles per filtrare l'estensione non è sicuro !! Ad esempio, hai due file Test1.xls e Test2.xlsx e vuoi filtrare il file xls usando il modello di ricerca * .xls, ma GetFiles restituisce sia Test1.xls sia Test2.xlsx Non ne ero a conoscenza e ho riscontrato un errore di produzione ambiente in cui alcuni file temporanei venivano improvvisamente gestiti come file corretti. Il modello di ricerca era * .txt e i file temporanei erano denominati * .txt20181028_100753898 Quindi non è possibile fidarsi del modello di ricerca, è necessario aggiungere un ulteriore controllo anche sui nomi dei file.