Bisakah Anda menelepon Directory.GetFiles () dengan beberapa filter?

Saya mencoba menggunakan Directory.GetFiles()metode ini untuk mengambil daftar file dari berbagai jenis, seperti mp3's dan jpg' s. Saya telah mencoba kedua hal berikut tanpa hasil:

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

Apakah ada cara untuk melakukan ini dalam satu panggilan?

Untuk .NET 4.0 dan yang lebih baru,

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

Untuk versi .NET yang lebih lama,

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

sunting: Silakan baca komentar. Peningkatan yang disarankan Paul Farry , dan masalah memori / kinerja yang ditunjukkan Christian.K sama-sama sangat penting.

Bagaimana dengan ini:

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

Saya menemukannya di sini (dalam komentar): http://msdn.microsoft.com/en-us/library/wz42302f.aspx

Jika Anda memiliki daftar ekstensi yang besar untuk diperiksa, Anda dapat menggunakan yang berikut ini. Saya tidak ingin membuat banyak pernyataan ATAU jadi saya memodifikasi apa yang ditulis lette.

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
}

untuk

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

Anda bisa:

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

• Jangan lupa .NET4 baru Directory.EnumerateFilesuntuk peningkatan kinerja ( Apa perbedaan antara Directory.EnumerateFiles vs Directory.GetFiles? )
• "IgnoreCase" harus lebih cepat dari "ToLower" ( .EndsWith("aspx", StringComparison.OrdinalIgnoreCase)daripada .ToLower().EndsWith("aspx"))

Tetapi manfaat nyata dari EnumerateFilesmuncul ketika Anda membagi filter dan menggabungkan hasilnya:

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

Ini akan menjadi sedikit lebih cepat jika Anda tidak harus mengubahnya menjadi gumpalan (yaitu exts = new[] {"*.mp3", "*.jpg"}sudah).

Evaluasi kinerja berdasarkan tes LinqPad berikut (catatan: Perfcukup ulangi delegasi 10.000 kali) https://gist.github.com/zaus/7454021

(mem-posting ulang dan meluas dari 'duplikat' karena pertanyaan itu secara khusus tidak meminta LINQ: Beberapa file-ekstensi searchPattern untuk System.IO.Directory.GetFiles )

Saya tahu ini pertanyaan lama tapi LINQ: (.NET40 +)

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

Ada juga solusi keturunan yang tampaknya tidak memiliki memori atau kinerja overhead dan cukup elegan:

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

Cara lain untuk menggunakan Linq, tetapi tanpa harus mengembalikan semuanya dan memfilternya dalam memori.

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

Ini sebenarnya 2 panggilan untuk GetFiles(), tetapi saya pikir itu konsisten dengan semangat pertanyaan dan mengembalikannya dalam satu enumerable.

Nggak. Coba yang berikut ini:

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

Diambil dari: http://blogs.msdn.com/markda/archive/2006/04/20/580075.aspx

Membiarkan

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

Kemudian

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

atau

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

Saya tidak dapat menggunakan .Wheremetode karena saya pemrograman dalam .NET Framework 2.0 (Linq hanya didukung dalam .NET Framework 3.5+).

Kode di bawah ini tidak peka huruf besar-kecil (jadi .CaBatau .cabakan dicantumkan juga).

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

Fungsi berikut mencari beberapa pola, dipisahkan dengan koma. Anda juga dapat menentukan pengecualian, misalnya: "! Web.config" akan mencari semua file dan mengecualikan "web.config". Pola bisa dicampur.

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

}

Pemakaian:

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

di .NET 2.0 (tanpa 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()
}

Kemudian gunakan:

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

Baru saja menemukan cara lain untuk melakukannya. Masih bukan satu operasi, tetapi membuangnya untuk melihat apa yang dipikirkan orang lain tentang itu.

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

Bagaimana dengan

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

Buat ekstensi yang Anda inginkan satu string yaitu ".mp3.jpg.wma.wmf" dan kemudian periksa apakah setiap file berisi ekstensi yang Anda inginkan. Ini berfungsi dengan .net 2.0 karena tidak menggunakan 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

   }
}

Keuntungan dengan pendekatan ini adalah Anda dapat menambah atau menghapus ekstensi tanpa mengedit kode yaitu untuk menambahkan gambar png, cukup tulis 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();
}

Tidak ... Saya yakin Anda harus membuat panggilan sebanyak jenis file yang Anda inginkan.

Saya akan membuat fungsi sendiri mengambil array pada string dengan ekstensi yang saya butuhkan dan kemudian beralih pada array yang membuat semua panggilan yang diperlukan. Fungsi itu akan mengembalikan daftar umum file yang cocok dengan ekstensi yang saya kirim.

Semoga ini bisa membantu.

Saya memiliki masalah yang sama dan tidak dapat menemukan solusi yang tepat jadi saya menulis fungsi yang disebut 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();
}

Fungsi ini akan memanggil Directory.Getfiles() hanya satu kali.

Misalnya, panggil fungsi seperti ini:

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

EDIT: Untuk mendapatkan satu file dengan banyak ekstensi gunakan yang ini:

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

Misalnya, panggil fungsi seperti ini:

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

Saya bertanya-tanya mengapa ada begitu banyak "solusi" yang diposting?

Jika pemahaman pemula saya tentang cara kerja GetFiles benar, hanya ada dua opsi dan salah satu solusi di atas dapat dibawa ke ini:

1. GetFiles, lalu filter: Cepat, tetapi seorang pembunuh memori karena menyimpan overhead sampai filter diterapkan

2. Saring sementara GetFiles: Lebih lambat filter lebih banyak ditetapkan, tetapi penggunaan memori rendah karena tidak ada overhead yang disimpan.
   Ini dijelaskan dalam salah satu posting di atas dengan patokan yang mengesankan: Setiap opsi filter menyebabkan operasi GetFile yang terpisah sehingga bagian yang sama dari harddisk dibaca beberapa kali.

Menurut pendapat saya Opsi 1) lebih baik, tetapi menggunakan Direktori SearchOption.AllDirectories pada folder seperti C: \ akan menggunakan memori dalam jumlah besar.
Oleh karena itu saya hanya akan membuat sub-metode rekursif yang melewati semua subfolder menggunakan opsi 1)

Ini seharusnya menyebabkan hanya 1 GetFiles-operasi pada setiap folder dan karenanya menjadi cepat (Opsi 1), tetapi hanya menggunakan sedikit memori karena filter diterapkan setelah pembacaan masing-masing subfolder -> overhead dihapus setelah masing-masing subfolder.

Tolong koreksi saya jika saya salah. Saya seperti yang saya katakan cukup baru untuk pemrograman tetapi ingin mendapatkan pemahaman yang lebih mendalam tentang hal-hal yang akhirnya menjadi baik dalam hal ini :)

Jika Anda menggunakan VB.NET (atau mengimpor ketergantungan ke proyek C # Anda), sebenarnya ada metode kenyamanan yang memungkinkan untuk memfilter beberapa ekstensi:

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

Di VB.NET ini dapat diakses melalui My-namespace:

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

Sayangnya, metode kenyamanan ini tidak mendukung varian malas yang dievaluasi seperti Directory.EnumerateFiles()halnya.

saya tidak tahu solusi apa yang lebih baik, tetapi saya menggunakan ini:

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

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

Berikut adalah cara sederhana dan elegan untuk mendapatkan file yang difilter

var allowedFileExtensions = ".csv,.txt";


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

Atau Anda bisa mengonversi string ekstensi ke 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;
}

Menggunakan pola pencarian GetFiles untuk memfilter ekstensi tidak aman !! Misalnya Anda memiliki dua file Test1.xls dan Test2.xlsx dan Anda ingin memfilter file xls menggunakan pola pencarian * .xls, tetapi GetFiles mengembalikan kedua Test1.xls dan Test2.xlsx Saya tidak mengetahui hal ini dan mendapatkan kesalahan dalam produksi lingkungan ketika beberapa file sementara tiba-tiba ditangani sebagai file yang benar. Pola pencarian adalah * .txt dan file temp bernama * .txt20181028_100753898 Jadi pola pencarian tidak dapat dipercaya, Anda harus menambahkan pemeriksaan tambahan pada nama file juga.