Directory.GetFiles () öğesini birden çok filtreyle çağırabilir misiniz?

'S ' ve 's Directory.GetFiles()gibi birden çok türde dosyaların bir listesini almak için yöntemi kullanmaya çalışıyorum . Şanssız her ikisini de denedim:mp3jpg

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

Bunu tek bir çağrıda yapmanın bir yolu var mı?

.NET 4.0 ve sonraki sürümleri için,

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

.NET'in önceki sürümleri için,

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

edit: Lütfen yorumları okuyun. Paul Farry'nin önerdiği gelişme ve Christian.K'nın belirttiği bellek / performans sorunu çok önemlidir.

Buna ne dersin:

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

Burada buldum (yorumlarda): http://msdn.microsoft.com/en-us/library/wz42302f.aspx

Kontrol etmek için geniş bir uzantı listeniz varsa aşağıdakileri kullanabilirsiniz. Ben lette ne yazdım değiştirilmiş yani OR ifadeler çok oluşturmak istemiyordu.

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
}

için

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

Yapabilirdiniz:

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

• Directory.EnumerateFilesPerformans artışı için yeni .NET4'ü unutmayın ( Directory.EnumerateFiles ile Directory.GetFiles arasındaki fark nedir? )
• "IgnoreCase", "ToLower" değerinden daha hızlı olmalıdır ( .EndsWith("aspx", StringComparison.OrdinalIgnoreCase)yerine .ToLower().EndsWith("aspx"))

Ancak EnumerateFilesfiltreleri böldüğünüzde ve sonuçları birleştirdiğinizde gerçek faydası ortaya çıkar:

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

Bunları globlara dönüştürmek zorunda kalmazsanız (yani exts = new[] {"*.mp3", "*.jpg"}zaten) biraz daha hızlı olur .

Aşağıdaki LinqPad testine dayanan performans değerlendirmesi (not: Perftemsilci 10000 kez tekrarlanır) https://gist.github.com/zaus/7454021

(bu soru özellikle LINQ istemediğinden 'yinelenen' için çoğaltıldı ve genişletildi: System.IO.Directory.GetFiles için birden fazla dosya uzantısı searchPattern )

Eski bir soru olduğunu biliyorum ama LINQ: (.NET40 +)

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

Herhangi bir bellek veya performans yükü olmayan ve oldukça zarif görünen bir iniş çözümü de var:

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

Linq'i kullanmanın başka bir yolu, ancak her şeyi geri döndürmek ve bellekte filtrelemek zorunda kalmadan.

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

Aslında 2 çağrı GetFiles(), ama bence sorunun ruhu ile tutarlı ve onları bir numaralandırılabilir döndürür.

Hayır! Takip etmeyi dene:

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

Alındığı yer: http://blogs.msdn.com/markda/archive/2006/04/20/580075.aspx

İzin Vermek

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

Sonra

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

veya

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

.WhereYöntem kullanamıyorum çünkü .NET Framework 2.0'da programlama yapıyorum (Linq yalnızca .NET Framework 3.5 ve sonraki sürümlerinde desteklenmektedir).

Kod aşağıda harf duyarlı (öyle değil .CaBya .cabda listelenir).

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

Aşağıdaki işlev virgülle ayrılmış birden çok desende arama yapar. Bir hariç tutma da belirtebilirsiniz, örneğin: "! Web.config" tüm dosyaları arayacak ve "web.config" dosyasını hariç tutacaktır. Desenler karıştırılabilir.

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

}

Kullanımı:

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

.NET 2.0'da (Linq yok):

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

Sonra kullanın:

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

Sadece başka bir yol buldum. Hala bir operasyon değil, diğer insanların bu konuda ne düşündüğünü görmek için dışarı atıyor.

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

Ne dersin

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

İstediğiniz uzantıları tek bir dize yapın (ör. ".Mp3.jpg.wma.wmf") ve ardından her dosyanın istediğiniz uzantıyı içerip içermediğini kontrol edin. Bu, LINQ kullanmadığı için .net 2.0 ile çalışır.

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

   }
}

Bu yaklaşımın avantajı, kodu düzenlemeden uzantıları ekleyebilmeniz veya kaldırabilmenizdir, yani png resimleri eklemek için sadece myExtensions = ". Jpg.mp3.png" yazın.

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

Hayır ... İstediğiniz dosya türleri kadar arama yapmanız gerektiğine inanıyorum.

Kendimi ihtiyacım uzantıları ile dizeleri bir dizi alarak bir işlev oluşturmak ve daha sonra gerekli tüm çağrıları yaparak bu dizi yineleme. Bu işlev, gönderdiğim uzantılarla eşleşen dosyaların genel bir listesini döndürür.

Umarım yardımcı olur.

Aynı sorunu yaşadım ve doğru çözümü bulamadım, bu yüzden GetFiles adlı bir işlev yazdım:

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

Bu işlev Directory.Getfiles()yalnızca bir kez çağıracaktır .

Örneğin, işlevi şu şekilde çağırın:

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

DÜZENLEME: Birden çok uzantıya sahip bir dosya almak için şu dosyayı kullanın:

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

Örneğin, işlevi şu şekilde çağırın:

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

Acaba neden bu kadar çok "çözüm" var?

GetFiles'in nasıl çalıştığına dair çaylak anlayışım doğru ise, sadece iki seçenek vardır ve yukarıdaki çözümlerden herhangi biri bunlara getirilebilir:

1. GetFiles, sonra filtre: Hızlı, ancak filtreler uygulanana kadar ek yükün depolanması nedeniyle bir bellek katili

2. GetFiles iken Filtrele: Daha fazla filtre ayarlanır, ancak ek bellek depolanmadığı için düşük bellek kullanımı olur.
   Bu, etkileyici bir kıyaslama ile yukarıdaki yazılardan birinde açıklanmaktadır: Her filtre seçeneği ayrı bir GetFile işlemine neden olur, böylece sabit sürücünün aynı kısmı birkaç kez okunur.

Bence Seçenek 1) daha iyidir, ancak C: \ gibi klasörlerde SearchOption.AllDirectories kullanmak büyük miktarda bellek kullanır.
Bu nedenle, sadece seçenek 1'i kullanarak tüm alt klasörlerden geçen özyinelemeli bir alt yöntem yaparım)

Bu, her klasörde yalnızca 1 GetFiles işlemine neden olur ve bu nedenle hızlı olur (Seçenek 1), ancak filtreler her alt klasörün okuduğu -> ek yükü her alt klasörden sonra silindikten sonra yalnızca küçük bir bellek kullanın.

Yanlışım varsa lütfen düzelt. Programlamaya oldukça yeni dediğim gibi ama sonunda bu konuda iyi olmak için daha derin bir anlayış kazanmak istiyorum :)

VB.NET kullanıyorsanız (veya bağımlılığı C # projenize aktardıysanız), aslında birden çok uzantı için filtrelemeye izin veren bir kolaylık yöntemi vardır:

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

VB.NET'te buna My-namespace üzerinden erişilebilir:

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

Ne yazık ki, bu kolaylık yöntemleri, tembel olarak değerlendirilen bir varyantı desteklemiyor Directory.EnumerateFiles().

hangi çözüm daha iyi olduğunu bilmiyorum, ama bunu kullanın:

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

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

Filtrelenmiş dosyaları almanın basit ve zarif bir yolu

var allowedFileExtensions = ".csv,.txt";


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

Veya uzantı dizesini String ^ biçimine dönüştürebilirsiniz

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

Uzantıyı filtrelemek için GetFiles arama modelini kullanmak güvenli değildir !! Örneğin iki Test1.xls ve Test2.xlsx dosyanız var ve xls dosyasını arama kalıbı * .xls kullanarak filtrelemek istiyorsunuz, ancak GetFiles Test1.xls ve Test2.xlsx dosyalarını geri döndürüyor Bunun farkında değildim ve üretimde hata aldım bazı geçici dosyaların aniden doğru dosyalar olarak işlendiği ortam. Arama kalıbı * .txt ve geçici dosyalar * .txt20181028_100753898 olarak adlandırıldı. Bu nedenle arama kalıbına güvenilemiyor, dosya adlarına da ek kontrol eklemeniz gerekiyor.