Si può chiamare Directory.GetFiles() con filtri multipli?

Sto cercando di utilizzare il Directory.GetFiles() metodo per recuperare un elenco di file di diversi tipi, come mp3‘s e jpg‘s. Ho provato entrambe le seguenti senza fortuna:

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

C’è un modo per fare questo in una chiamata?

  • Come nota a margine , utilizzando GetFiles modello di ricerca per filtrare l’estensione non è sicuro.Per esempio, si dispone di due file Test1.xls e Test2.xlsx e si desidera filtrare i file xls utilizzando il modello di ricerca *.xls, ma GetFiles ritorno sia Test1.xls e Test2.xlsx . Nota di Lettura Sezione per maggiori informazioni
  • Così come evitare questo?
  • Come è che non sono sicuri? Che sembra una caratteristica piuttosto che un bug.
InformationsquelleAutor Jason Z | 2008-10-02

 

26 Replies
  1. 488

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

    edit: si Prega di leggere i commenti. Il miglioramento che Paolo Farry suggerisce, e la memoria/problema di prestazioni che Cristiano.K punti sono molto importanti.

    • L’uomo, devo pensare in termini di LINQ più spesso. Bella soluzione!
    • Semplicemente impressionante.
    • Basta assicurarsi di che comprendere le implicazioni di questo restituirà file in un array di stringhe e poi filtro per le estensioni specificate. Che potrebbe non essere un grosso problema se “C:\Path” non hanno un sacco di file al di sotto di esso, ma può essere una memoria/problema di prestazioni in “C:\” o qualcosa di simile.
    • … 2 anni dopo: Bella codice, ma attenzione con questo, se si dispone di un file che termina con .JPG non rendono. Meglio aggiungere s.ToLower().Endswith...
    • si potrebbe utilizzare s.EndsWith(".mp3", StringComparison.OrdinalIgnoreCase)
    • è giusto.
    • Per ridurre i o condizioni che mi piace fare le seguenti (anche se non so se c’è più di un impatto sulle prestazioni)… var file = myDirInfo.GetFiles().Dove(o => nuovo[]{“mp3”, “jpg”}.Contiene(o.Estensione.ToLower()).ToArray();
    • Notare che con .NET 4.0, è possibile sostituire Directory.GetFiles con Directory.EnumerateFiles, msdn.microsoft.com/en-us/library/dd383571.aspx, che consente di evitare i problemi di memoria che @Cristiana.K menzioni.
    • si dovrebbe leggere msdn.microsoft.com/en-us/library/dd465121.aspx
    • Ho fatto alcuni miglioramenti delle prestazioni e fornire il codice di confronto alla risposta qui sotto: stackoverflow.com/questions/163162/…
    • che cosa è s in s => s.EndsWith(".mp3") || s.EndsWith(".jpg") ???
    • È il parametro di espressione lambda, in questo caso s rappresenta il nome di ogni file restituito dalla chiamata al Directory.EnumerateFiles/Directory.GetFiles.
    • Hai una .Net 2 soluzione per favore?
    • Come si fa a verificare se un nome di file (non la cartella) contiene una stringa particolare?
    • Se si desidera migliorare ulteriormente le prestazioni in caso di molti possibili estensioni, è meglio creare un HashSet con tutte le estensioni e fare Where(f => _validExtensions.Contains(Path.GetExtension(f).ToLower())). Fondamentalmente Contains è molto più veloce di quanto il confronto di stringhe più volte.
    • Metodo GetFiles è molto più veloce di EnumerateFiles
    • In contesto di dati, si vuole prima tutti i file, quindi filtrare con loro.
    • Il problema con .Contiene include file senza estensione.

  2. 58

    Come 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

    • Sto indovinando questo modo si evita il potenziale di memoria insidie dei top rated risposta? Nel qual caso, dovrebbe essere classificato più in alto!
    • Il top rated risposta sicuramente mette il carico sulla memoria, ma penso che non dovrebbe essere un problema. Mi è piaciuta questa risposta troppo, ma in realtà è (molto) più lento quindi accettato di rispondere. Controllare questo SpeedTest
    • Grazie. Felice di vedere che è solo circa due volte più lenta – i’ll bastone con esso per intanto penso.
    • È solo lento il doppio se ci sono solo due estensioni. Se si dispone di un elenco di X estensioni, quindi sarà X volte più lento. Perché qui si sta chiamando la funzione di Directory.GetFiles più volte, mentre l’altra soluzione è chiamato solo una volta.
    • Si può usare Parallel.ForEach di ottenere in parallelo
    • ma allora sei limitato da IO larghezza di banda

  3. 31

    Se si dispone di un ampio elenco di estensioni di controllo è possibile utilizzare il seguente. Non volevo creare un sacco di O dichiarazioni così ho modificato quello che lette 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
    }
    • Help me con questo per favore…Quando sono la stampa di immagine che si dà del percorso totale di esso.Come posso ridurre solo il nome del file.
    • Sistema.IO.Percorso.GetFileName(immagine)
    • Path.GetExtension restituisce ‘.ext’, non e ‘*.ext’ (almeno 3.5+).
    • FYI: Hai bisogno di un Sistema.Linq per .dove(
    • Perché utilizzare una virgola come carattere di separazione? Un carattere vietato come un | potrebbe essere più affidabile. È possibile escludere il (raro) caso in cui un’estensione contiene una virgola alla fine.
    • C’è un potenziale difetto. Ci sono ormai lontani i giorni in cui estensioni sono necessarie per essere esattamente tre caratteri. Supponiamo che potreste ritrovarvi con un file con .abc, e supportedExtensions contiene .abcd. Sarà partita, anche se non dovrebbe. Per risolvere: supportedExtensions = ".jpg|.abcd|"; con .Contains(Path.GetExtension(s).ToLower() + "|"). Che è, di includere il carattere separatore in prova. IMPORTANTE: il carattere separatore deve essere anche dopo l’ULTIMA voce in supportedExceptions.
    • Un altro difetto è che tutti .Contiene le soluzioni includono file senza estensione.

  4. 28

    per

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

    Si potrebbe:

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

    Ma il vero vantaggio di EnumerateFiles si presenta quando si dividono i filtri e unire 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 si dispone di li trasformano in gocce (cioè exts = new[] {"*.mp3", "*.jpg"} già).

    Di valutazione delle prestazioni basato sui seguenti LinqPad di prova (nota: Perf si ripete solo il delegato 10000 volte)
    https://gist.github.com/zaus/7454021

    ( ripubblicati e ampliata da “duplicato”, dal momento che la domanda espressamente richiesto nessun LINQ: Più file-extensions searchPattern per il Sistema.IO.Directory.GetFiles )

    • cosa intendi per “mi diventa un po’ più veloce se non si dispone di li trasformano in gocce”? È O(1) o è O(n) (con riferimento al numero di file, non il numero di estensioni)? Io avrei indovinato O(1) (o, O(n) per quanto riguarda il numero di estensioni) e probabilmente da qualche parte nella gamma di un paio di cpu-cicli… Se questo è il caso, probabilmente – in termini di prestazioni trascurabile
    • sì con 10k ripetizioni contro 2 estensioni di glob vs str differenza è 3ms, quindi sì, tecnicamente trascurabile (vedi perf link di risultati), ma non sapendo come molte estensioni è necessario filtro per ho pensato che vale la pena di sottolineare che c’è una differenza; lascio a voi decidere se semplificato “utilizzo” (cioè .FilterFiles(path, "jpg", "gif")) è meglio di “esplicito gocce” (cioè .FilterFiles(path, "*.jpg", "*.gif")).
    • perfetto, grazie. Mi dispiace ma in qualche modo ho saltato quella github link. Forse dovrei adattare la mia schermata di impostazioni del colore 🙂
    • Questo supporto maiuscole estensione di tali culo .JPG o .MKV?
    • Noterai che nel mio primo esempio StringComparison.OrdinalIgnoreCase significa per .jpg o .Jpg o .JPG, ecc
    • Il difetto con il SelectMany soluzione è quella di scorrere tutti i file una volta all’estensione del file passato.
    • ottimo, grazie per segnalarlo. È divertente perché ho appena imbattuto in questo caso ieri come bene, e solo notato perché ho avuto un sacco di file con “estensioni multiple” (ad esempio .json.html) che corrispondono di più di un glob.
    • Ma, sto cercando di indovinare/sperando che perché è più di un filesystem cosa con il glob che non è proprio la ripetizione di ogni file nella directory, almeno non nel senso tradizionale.

  5. 16

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

    var files = Directory.GetFiles("path_to_files").Where(file => Regex.IsMatch(file, @"^.+\.(wav|mp3|txt)$"));
    • Buona idea. Considerare l’utilizzo di file.ToLower() per abbinare facilmente maiuscolo estensioni. E perché non estrarre l’estensione del primo, in modo Regex non deve esaminare intero percorso: Regex.IsMatch(Path.GetExtension(file).ToLower(), @"\.(wav|mp3|txt)");
  6. 11

    Un altro modo per utilizzare Linq, ma senza dover rientrare di tutto e di filtro in memoria.

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

    È in realtà 2 chiamate a GetFiles(), ma penso che sia coerente con lo spirito della domanda e li restituisce in una enumerabile.

    • Perché utilizzare Linq, quindi? Sarebbe più veloce rispetto all’utilizzo di un Elenco e iladdrangemetodo?
    • non so cosa sarebbe più veloce e non credo che sia una questione importante. per quasi qualsiasi luogo ti piacerebbe essere utilizzando il codice per qualsiasi soluzione a questo problema, la differenza di prestazioni sarebbe trascurabile. la domanda dovrebbe essere come ciò che è più leggibile per facilitare la manutenibilità del codice in futuro. penso che questa sia una risposta ragionevole, perché si pone in una linea di fonte, che credo sia parte di ciò che la domanda desideri, le chiamate necessarie ed esprime chiaramente l’intento di linea. elenco e iladdrangemetodo distrae con più passaggi per realizzare la stessa cosa.
  7. 10

    C’è anche una discesa soluzione che sembra non avere memoria o sovraccarico a livello di prestazioni e di essere abbastanza elegante:

    string[] filters = new[]{"*.jpg", "*.png", "*.gif"};
    string[] filePaths = filters.SelectMany(f => Directory.GetFiles(basePath, f)).ToArray();
    • Potrei modificarlo in modo che si possano accettare unknown numero illimitato di interni con una nuova variabile di tipo stringa, e una funzione di Split. Ma anche allora, come è meglio jnoreiga soluzione? È più veloce? Meno memoria di consumo?
    • C’è un trade-off. Questo approccio richiede GetFiles più volte, uno per ogni filtro. Quelle più chiamate potrebbe essere significativo “le prestazioni” in alcune situazioni, È importante vantaggio che ogni GetFiles solo restituisce un array con il di corrispondenza percorsi di file. Mi sarei aspettato che questo genere essere un buon risultato delle prestazioni, forse anche superiore prestazioni, ma che deve essere testato. Se GetFiles è significativamente più veloce rispetto EnumerateFiles, allora questo potrebbe essere l’approccio migliore sicurezza. Si noti inoltre che il finale “.ToArray()” può essere omesso quando IEnumerable è utilizzabile direttamente.
  8. 7

    No. Provare le seguenti:

    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

  9. 6

    Lasciare

    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;
    • getfiles non hanno il sovraccarico u postato.
  10. 5

    Che non posso usare .Where metodo, perché io sono di programmazione .NET Framework 2.0 Linq (è supportato solo in .NET Framework 3.5+).

    Codice riportato di seguito non è “case sensitive” (così .CaB o .cab saranno elencati troppo).

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

    La seguente funzione di ricerca su più modelli, separati da virgole. È inoltre possibile specificare l’esclusione, ad esempio,: “!web.config” cerca tutti i file e di escludere “web.config”. I pattern 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);
                }
  12. 4
    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);
    }
    • file.Extension.ToLower() cattiva pratica.
    • allora che cosa si dovrebbe usare? @abatishchev
    • b, StringComparison.OrdinalIgnoreCase)
    • In realtà, file.Estensione.Equals(“.jpg”,StringComparison.OrdinalIgnoreCase) è quello che preferisco. Sembra che sia più veloce .ToLower o .ToUpper, o almeno così dicono ovunque ho cercato. In realtà, .Uguale è più veloce ==, poiché == chiamate .È uguale a e controlli per nulla(Perché non si può fare null.Equals(null)).
  13. 4

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

    Poi usarlo:

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

    Appena trovato un altro modo per farlo. Ancora una operazione, ma lo getta fuori per vedere cosa pensano gli altri su di esso.

    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;
    }
  15. 3
    DirectoryInfo directory = new DirectoryInfo(Server.MapPath("~/Contents/"));
    
    //Using Union
    
    FileInfo[] files = directory.GetFiles("*.xlsx")
                                .Union(directory
                                .GetFiles("*.csv"))
                                .ToArray();
    • Migliori Linq soluzione che ho visto.
    • dopo ore di tentare ogni soluzione postato sopra, questo si è rivelato essere il migliore.Come Andreas Reiff detto, Meglio Linq soluzione mai
  16. 3

    Che cosa circa

    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);
  17. 2

    Fare le estensioni che si desidera una stringa io.e “.mp3.jpg.wma.wmf” e quindi controllare se ogni file contenente l’estensione che si desidera.
    Questo funziona con .net 2.0 come non utilizzare 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 si può aggiungere o rimuovere le estensioni senza modificare il codice.e per aggiungere le immagini png, basta scrivere myExtensions=”.jpg.mp3.png”.

    • non so che cosa è s
  18. 2
    ///<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();
    }
  19. 2

    Nop… credo che devi fare come molte chiamate come i tipi di file che si desidera.

    Vorrei creare una funzione di me che prende un array di stringhe con le estensioni di cui ho bisogno e poi iterare la matrice di fare tutte le chiamate necessarie. Che funzione dovrebbe restituire un elenco generico di file corrispondenti estensioni che avevo inviato.

    Speranza che aiuta.

  20. 1

    Ho avuto lo stesso problema e non riuscivo a trovare la soluzione giusta, così 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 verrà chiamata Directory.Getfiles() solo una volta.

    Per esempio chiamare la funzione come questa:

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

    EDIT: Per ottenere un file con estensioni multiple, utilizzare 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 "";
        }

    Per esempio chiamare la funzione come questa:

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

    Mi chiedo perché ci sono così tante “soluzioni” postato?

    Se il mio rookie-comprensione su come GetFiles opere è giusto, ci sono solo due opzioni e una delle soluzioni di cui sopra può essere riportato questi:

    1. GetFiles, quindi filtro: Veloce, ma una memoria killer a causa di memorizzazione di sovraccarico fino applicati i filtri

    2. Filtro mentre GetFiles: più Lento, più filtri sono impostati, ma a basso utilizzo di memoria come nessun onere viene memorizzato.
      Questo è spiegato in uno dei post con un imponente punto di riferimento: Ogni opzione di filtro cause separate GetFile-operazione in modo che la stessa parte di hard disk viene letto più volte.

    A mio parere l’Opzione 1) è meglio, ma utilizzando il SearchOption.AllDirectories su cartelle in C:\ sarebbe l’uso di enormi quantità di memoria.

    Perciò vorrei solo fare una ricorsiva sub-metodo che passa attraverso tutte le sottocartelle con l’opzione 1)

    Questo dovrebbe causare solo 1 GetFiles-operazione su ogni cartella e quindi essere veloce (Opzione 1), ma utilizzare solo una piccola quantità di memoria, come i filtri vengono applicate dopo ogni sottocartelle di lettura -> overhead viene eliminato dopo ogni sottocartella.

    Prego di correggermi se ho sbagliato. Io come ho detto molto di programmazione, ma vuole acquisire una più profonda comprensione delle cose, fino a diventare bravo in questo 🙂

  22. 0

    non lo so cosa sia la soluzione migliore, ma io 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));
                }
  23. 0

    Se si utilizza VB.NET (o di importazione di dipendenza nel tuo progetto C#), esiste una convenienza metodo che permette di filtrare più estensioni:

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

    In VB.NET questo è possibile accedere tramite il Mio-namespace:

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

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

  24. 0

    Utilizzando GetFiles modello di ricerca per filtrare l’estensione non è sicuro!!
    Per esempio, si dispone di due file Test1.xls e Test2.xlsx e si desidera filtrare i file xls utilizzando il modello di ricerca *.xls, ma GetFiles ritorno sia Test1.xls e Test2.xlsx
    Non ero a conoscenza di questo e ha ricevuto l’errore in ambiente di produzione quando alcuni file temporanei, improvvisamente, è stata gestita come file a destra. Criterio di ricerca è stato *.txt e file temp è stato nominato *.txt20181028_100753898
    Così pattern di ricerca non può essere attendibile, è necessario aggiungere un ulteriore controllo sui nomi di file come bene.

  25. -1

    O si può semplicemente convertire la stringa di estensioni per la Stringa^

    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;
    }
    • Questo è il c++ e non c#
  26. -2

    spero che questo aiuta qualcuno:

    //getting only playable Audio/Video Files from open dialog
    
    OpenFileDialog dlg = new OpenFileDialog();
    
    dlg.Filter = ""All Media Files|*.wav;*.aac;*.wma;*.wmv;*.avi;*.mpg;*.mpeg;*.m1v;*.mp2;*.mp3;*.mpa;*.mpe;*.m3u;*.mp4;*.mov;*.3g2;*.3gp2;*.3gp;*.3gpp;*.m4a;*.cda;*.aif;*.aifc;*.aiff;*.mid;*.midi;*.rmi;*.mkv;*.WAV;*.AAC;*.WMA;*.WMV;*.AVI;*.MPG;*.MPEG;*.M1V;*.MP2;*.MP3;*.MPA;*.MPE;*.M3U;*.MP4;*.MOV;*.3G2;*.3GP2;*.3GP;*.3GPP;*.M4A;*.CDA;*.AIF;*.AIFC;*.AIFF;*.MID;*.MIDI;*.RMI;*.MKV";
    
    dlg.ShowDialog();
    • Questo non è utile a questa domanda. La domanda è: come filtro una chiamata a Directory.GetFiles() utilizzo di diverse estensioni di file. Il codice è dirigere una finestra di dialogo file di filtrare ciò che si visualizza all’utente in base alle estensioni multiple. Quelli non sono la stessa cosa.

Lascia un commento