여러 필터를 사용하여 Directory.GetFiles ()를 호출 할 수 있습니까?

내가 사용하려고 Directory.GetFiles()같은 여러 유형의 파일 목록을 검색하는 방법을 mp3의와 jpg의를. 나는 운없이 다음 두 가지를 모두 시도했다.

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

한 번의 호출로이를 수행 할 수있는 방법이 있습니까?

.NET 4.0 이상의 경우

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

이전 버전의 .NET의 경우

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

편집 : 의견을 읽으십시오. Paul Farry가 제안한 개선 과 Christian.K가 지적한 기억 / 성능 문제 는 매우 중요합니다.

이건 어때요:

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

나는 그것을 여기 (주석에서) 발견했다 : http://msdn.microsoft.com/en-us/library/wz42302f.aspx

확인할 확장명 목록이 많은 경우 다음을 사용할 수 있습니다. 나는 많은 OR 문을 만들고 싶지 않아서 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
}

...에 대한

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

당신은 할 수 있습니다 :

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

• Directory.EnumerateFiles성능 향상을위한 새로운 .NET4 를 잊지 마십시오 ( Directory.EnumerateFiles와 Directory.GetFiles의 차이점은 무엇입니까? )
• "IgnoreCase"는 "ToLower"보다 빠릅니다 ( .EndsWith("aspx", StringComparison.OrdinalIgnoreCase)대신 .ToLower().EndsWith("aspx")).

그러나 EnumerateFiles필터를 분할하고 결과를 병합 하면 실제 이점이 나타납니다.

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

그것들을 glob (즉, exts = new[] {"*.mp3", "*.jpg"}이미) 으로 바꿀 필요가 없다면 조금 더 빨라집니다 .

다음 LinqPad 테스트를 기반으로 한 성능 평가 (참고 : Perf델리게이트를 10000 회만 반복) https://gist.github.com/zaus/7454021

(그 질문에 구체적으로 어떤 LINQ를 요구하지 않기 때문에 재 게시와 '중복'에서 확장 : 여러 파일 확장 된 searchPattern System.IO.Directory.GetFiles에 대한 )

나는 그것이 오래된 질문이지만 LINQ : (.NET40 +)

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

메모리 나 성능 오버 헤드가없고 매우 우아해 보이는 하강 솔루션도 있습니다.

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

Linq를 사용하는 또 다른 방법이지만 모든 것을 반환하고 메모리에서 필터링하지 않아도됩니다.

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

실제로 2 GetFiles()번의 호출 이지만 질문의 정신과 일치하고 열거 가능한 것으로 반환합니다.

아니. 다음을 시도하십시오 :

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

출처 : http://blogs.msdn.com/markda/archive/2006/04/20/580075.aspx

허락하다

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

그때

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

또는

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

사용할 수 없습니다 .Where.NET Framework 2.0에서 프로그래밍 중이므로 메소드를 (Linq는 .NET Framework 3.5 이상에서만 지원됨).

아래 코드는 대소 문자를 구분합니다 (그렇지 않다 .CaB거나 .cab너무 나열됩니다).

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

다음 함수는 쉼표로 구분 된 여러 패턴을 검색합니다. 제외를 지정할 수도 있습니다 (예 : "! web.config"는 모든 파일을 검색하고 "web.config"제외). 패턴을 혼합 할 수 있습니다.

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

}

용법:

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

그런 다음 사용하십시오.

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

다른 방법을 찾았습니다. 여전히 하나의 작업이 아니라 다른 사람들이 그것에 대해 어떻게 생각하는지보기 위해 그것을 버립니다.

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

이건 어떤가요

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

하나의 문자열 (예 : ".mp3.jpg.wma.wmf")을 원하는 확장명으로 만든 다음 각 파일에 원하는 확장명이 있는지 확인하십시오. LINQ를 사용하지 않으므로 .net 2.0에서 작동합니다.

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

   }
}

이 접근 방식의 장점은 코드를 편집하지 않고 확장명을 추가하거나 제거 할 수 있다는 것입니다. 즉, png 이미지를 추가하려면 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();
}

아니요. 원하는 파일 형식만큼 많이 호출해야한다고 생각합니다.

필요한 확장명을 가진 문자열에 배열을 취하는 함수를 직접 만든 다음 해당 배열을 반복하여 필요한 모든 호출을 수행합니다. 이 함수는 내가 보낸 확장명과 일치하는 파일의 일반 목록을 반환합니다.

도움이 되길 바랍니다.

나는 같은 문제가 있었고 올바른 해결책을 찾지 못하여 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();
}

이 기능은 Directory.Getfiles()한 번만 호출 합니다.

예를 들어 다음과 같이 함수를 호출하십시오.

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

편집 : 확장명이 여러 개인 파일을 얻으려면 다음 파일을 사용하십시오.

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

예를 들어 다음과 같이 함수를 호출하십시오.

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

왜 이렇게 많은 "솔루션"이 게시되어 있는지 궁금합니다.

GetFiles의 작동 방식에 대한 신인 이해가 옳다면 두 가지 옵션 만 있으며 위의 솔루션 중 하나를 다음과 같이 해결할 수 있습니다.

1. GetFiles, 필터 : 빠르지 만 필터가 적용될 때까지 오버 헤드가 저장되어 메모리 킬러

2. GetFiles 동안 필터링 : 더 많은 필터가 설정 될수록 느리지 만 오버 헤드가 저장되지 않으므로 메모리 사용량이 적습니다.
   이것은 위의 게시물 중 하나에서 인상적인 벤치 마크로 설명됩니다. 각 필터 옵션은 별도의 GetFile 작업을 유발하므로 하드 드라이브의 동일한 부분이 여러 번 읽 힙니다.

제 생각에는 옵션 1)이 더 좋지만 C : \와 같은 폴더에서 SearchOption.AllDirectories를 사용하면 많은 양의 메모리가 사용됩니다.
따라서 옵션 1을 사용하여 모든 하위 폴더를 통과하는 재귀 하위 메서드를 만들 것입니다.)

이로 인해 각 폴더에서 GetFiles 작업이 1 개만 발생하므로 속도가 빨라야하지만 (옵션 1) 각 하위 폴더를 읽은 후 필터가 적용되고 각 하위 폴더 다음에 오버 헤드가 삭제되므로 적은 양의 메모리 만 사용하십시오.

내가 틀렸다면 정정 해주세요. 나는 프로그래밍에 대해 아주 새로운 말을했지만 결국 이것에 익숙해지기 위해 사물에 대해 더 깊이 이해하고 싶습니다 :)

VB.NET을 사용하는 경우 (또는 C # 프로젝트로 종속성을 가져온 경우) 실제로 여러 확장을 필터링 할 수있는 편리한 방법이 있습니다.

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

VB.NET에서는 My-namespace를 통해 액세스 할 수 있습니다.

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

불행히도 이러한 편의 방법은 느리게 평가 된 변형을 지원 Directory.EnumerateFiles()하지 않습니다.

어떤 솔루션이 더 나은지 모르겠지만 이것을 사용합니다.

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

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

필터링 된 파일을 얻는 간단하고 우아한 방법은 다음과 같습니다.

var allowedFileExtensions = ".csv,.txt";


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

또는 확장 문자열을 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;
}

확장명을 필터링하기 위해 GetFiles 검색 패턴을 사용하는 것은 안전하지 않습니다 !! 예를 들어 Test1.xls 및 Test2.xlsx 파일이 두 개이고 검색 패턴 * .xls를 사용하여 xls 파일을 필터링하려고하지만 GetFiles는 Test1.xls와 Test2.xlsx를 모두 반환합니다. 일부 임시 파일이 갑자기 올바른 파일로 처리 된 환경. 검색 패턴은 * .txt이고 임시 파일 이름은 * .txt20181028_100753898이므로 검색 패턴을 신뢰할 수 없으므로 파일 이름을 추가로 확인해야합니다.