/// <summary>
/// A safe way to get all the files in a directory and sub directory without crashing on UnauthorizedException
/// </summary>
/// <param name="rootPath">Starting directory</param>
/// <param name="patternMatch">Filename pattern match</param>
/// <param name="searchOption">Search subdirectories or only top level directory for files</param>
/// <returns>List of files</returns>
public static IEnumerable<string> GetDirectoryFiles(string rootPath, string patternMatch, SearchOption searchOption)
{
IEnumerable<string> foundFiles = Enumerable.Empty<string>(); // Start with an empty container
if (searchOption == SearchOption.AllDirectories)
{
try
{
IEnumerable<string> subDirs = Directory.EnumerateDirectories(rootPath);
foreach (string dir in subDirs)
{
try
{
foundFiles = foundFiles.Concat(GetDirectoryFiles(dir, patternMatch, searchOption)); // Add files in subdirectories recursively to the list
}
catch (UnauthorizedAccessException) { } // Incase we have an access error - we don't want to mask the rest
}
}
catch (UnauthorizedAccessException) { } // Incase we have an access error - we don't want to mask the rest
}
try
{
foundFiles = foundFiles.Concat(Directory.EnumerateFiles(rootPath, patternMatch)); // Add files from the current directory to the list
}
catch (UnauthorizedAccessException) { } // Incase we have an access error - we don't want to mask the rest
return foundFiles; // This is it finally
}
internal override Uri RequestURL(SearchOption option)
{
StringBuilder sbQuery = new StringBuilder();
sbQuery.Append(this.SearchURL);
if (this.SearchURL.IndexOf('?') < 0)
sbQuery.Append('?');
else
sbQuery.Append('&');
if (!String.IsNullOrEmpty(option.Tags))
sbQuery.AppendFormat("{0}={1}&", TagsName, Uri.EscapeUriString(option.Tags));
if (option.Page != null)
sbQuery.AppendFormat("{0}={1}&", PageName, option.Page.Value);
if (option.Limit != null)
sbQuery.AppendFormat("{0}={1}&", LimitName, option.Limit.Value);
if (sbQuery[sbQuery.Length - 1] == '&')
sbQuery.Remove(sbQuery.Length - 1, 1);
if (sbQuery[sbQuery.Length - 1] == '?')
sbQuery.Remove(sbQuery.Length - 1, 1);
return new Uri(sbQuery.ToString());
}
/// <summary>
/// Gets information ( array of <see cref="FileInfo"/> objects ), found by files <paramref name="mask"/> according to provided <see cref="SearchOption"/>.
/// </summary>
/// <param name="directory">Directory to search files in.</param>
/// <param name="mask">Search pattern.</param>
/// <param name="searchHow">Search option.</param>
/// <returns>Array of <see cref="FileInfo"/> objects, containing information about files, that has been found.</returns>
/// <exception cref="DirectoryNotFoundException" />
public static FileInfo[] GetFiles( string directory, string mask, SearchOption searchHow )
{
if ( Directory.Exists(directory) )
return new DirectoryInfo(directory).GetFiles(mask, searchHow);
throw new DirectoryNotFoundException(String.Format("Directory '{0}' can't be found.", directory));
}
public static IEnumerable<string> EnumerateFiles(string path, string searchPattern, SearchOption searchOption)
{
DirectoryInfoEx rootDir = new DirectoryInfoEx(path);
IEnumerator<FileInfoEx> fileEnumerator = rootDir.EnumerateFiles(searchPattern, searchOption).GetEnumerator();
while (fileEnumerator.MoveNext())
yield return fileEnumerator.Current.FullName;
}
static List<MyFileInfo> GetAllInputFiles(List<string> inputFiles, SearchOption searchOption)
{
List<MyFileInfo> result = new List<MyFileInfo>();
foreach (var inputFile in inputFiles)
{
if (Path.HasExtension(inputFile))
{
string dir = Path.GetDirectoryName(inputFile);
string ext = Path.GetFileName(inputFile);
var files = Directory.EnumerateFiles(dir, ext, searchOption);
foreach (var file in files)
{
result.Add(new MyFileInfo() { Info = new FileInfo(file), Root = new DirectoryInfo(Path.GetDirectoryName(inputFile)) });
}
}
else
{
//is path
var files = Directory.EnumerateFiles(inputFile, "*.*", searchOption);
foreach (var file in files)
{
result.Add(new MyFileInfo() { Info = new FileInfo(file), Root = new DirectoryInfo(Path.GetDirectoryName(inputFile)) });
}
}
}
return result;
}
internal static IEnumerable<string> GetFilesRelativeToRoot(string root, string path, string filter = null, SearchOption searchOption = SearchOption.TopDirectoryOnly)
{
path = EnsureTrailingSlash(Path.Combine(root, path));
if (String.IsNullOrEmpty(filter))
{
filter = "*.*";
}
try
{
if (!Directory.Exists(path))
{
return Enumerable.Empty<string>();
}
return Directory.EnumerateFiles(path, filter, searchOption)
.Select(f => GetRelativePath(root, f));
}
catch (UnauthorizedAccessException)
{
}
catch (DirectoryNotFoundException)
{
}
return Enumerable.Empty<string>();
}
/// <summary>
/// Returns an enumerable collection of directory information that matches a specified search pattern and search subdirectory option.
/// Will return an empty enumerable on exception. Quick and dirty but does what I need just now.
/// </summary>
/// <param name="directoryInfo">
/// The <see cref="System.IO.DirectoryInfo"/> that this method extends.
/// </param>
/// <param name="searchPattern">
/// The search string to match against the names of directories. This parameter can contain a combination of valid literal path
/// and wildcard (* and ?) characters (see Remarks), but doesn't support regular expressions. The default pattern is "*", which returns all files.
/// </param>
/// <param name="searchOption">
/// One of the enumeration values that specifies whether the search operation should include only
/// the current directory or all subdirectories. The default value is TopDirectoryOnly.
/// </param>
/// <returns>
/// An enumerable collection of directories that matches searchPattern and searchOption.
/// </returns>
public static Task<IEnumerable<DirectoryInfo>> SafeEnumerateDirectoriesAsync(
this DirectoryInfo directoryInfo,
string searchPattern = "*",
SearchOption searchOption = SearchOption.TopDirectoryOnly)
{
return Task.Run(() => SafeEnumerateDirectories(directoryInfo, searchPattern, searchOption));
}
/// <summary>
/// Scans the given directories for files matching the given filters.
/// </summary>
/// <param name="IEnumerator">An enumerator of directories.</param>
/// <param name="SearchPattern">A simple search pattern like "*.jpg".</param>
/// <param name="SearchOption">Include or do not include subdirectories.</param>
/// <param name="FileFilter">A delegate for filtering the found files.</param>
/// <returns>An enumeration of file infos.</returns>
public static IEnumerable<FileInfo> FileFilterPipe(this IEnumerator<String> IEnumerator,
String SearchPattern = "*",
SearchOption SearchOption = SearchOption.TopDirectoryOnly,
FileFilter FileFilter = null)
{
return new FileFilterPipe(SearchPattern, SearchOption, FileFilter, null, IEnumerator);
}
public ScannerArgument(DirectoryInfo directory, SearchOption searchoption,
bool parseAdd, bool parseUpdate, bool removeDeadFiles,
string[] extensions, RawTrack[] existingFiles)
: this(directory, searchoption, parseAdd, parseUpdate, removeDeadFiles,
extensions, existingFiles, new string[0])
{
}
/// <summary>
/// Returns all valid (loadable) assembly files (dll and exe) in the given path.
/// </summary>
/// <param name="path">The path the dll files are located in.</param>
/// <param name="searchOption">Search option for finding the dll files.</param>
/// <returns>The filenames of all loadable assemblies in the given path.</returns>
public static string[] getAssemblyFiles(string path, SearchOption searchOption)
{
if (path == null)
throw new ArgumentNullException("The given search path must not be null.");
List<string> filenames = new List<string>();
string[] dllFiles = Directory.GetFiles(path, "*.dll", searchOption);
filenames.AddRange(dllFiles);
dllFiles = Directory.GetFiles(path, "*.exe", searchOption);
filenames.AddRange(dllFiles);
List<string> assemblyFiles = new List<string>();
foreach (string dllFile in filenames)
{
if (!File.Exists(dllFile))
continue;
try
{
// try to load the dll file as assembly
Assembly asm = Assembly.LoadFrom(dllFile);
// store file in list of valid assemblies.
assemblyFiles.Add(dllFile);
}
catch
{
// Error loading the assembly... could be a dll-file that isn't a C# assembly
}
}
return assemblyFiles.ToArray();
}
public FileQuery(string query, SearchOption searchOption)
{
if (string.IsNullOrEmpty(query))
{
throw new ArgumentException("The file query was null or empty");
}
this.mySearchOption = searchOption;
this.Query = Environment.ExpandEnvironmentVariables(query);
var gacidx = query.IndexOf("gac:\\", StringComparison.OrdinalIgnoreCase);
if (gacidx == 0)
{
if (query.Contains("*"))
{
throw new ArgumentException(string.Format("Wildcards are not supported in Global Assembly Cache search: {0}", query));
}
var fileName = query.Substring(5);
var dirName = GetFileNameWithOutDllExtension(fileName);
if (Directory.Exists(Path.Combine(GAC_32, dirName)))
{
this.Query = Path.Combine(Path.Combine(GAC_32, dirName), fileName);
}
if (Directory.Exists(Path.Combine(GAC_MSIL, dirName)))
{
this.Query = Path.Combine(Path.Combine(GAC_MSIL, dirName), fileName);
}
this.mySearchOption = SearchOption.AllDirectories;
}
}
internal AudioScan(DirectoryInfo directory, SearchOption searchoption,
bool parseAdd, bool parseUpdate, bool removeDeadFiles,
string[] extensions, IEnumerable<RawTrack> existingFiles, IEnumerable<string> ignoredFiles,
ScanFileEventHandler parsed,
ScanCompletedEventHandler done)
{
var thread = new Thread(Run);
_directory = directory;
_searchoption = searchoption;
_parseAdd = parseAdd;
_parseUpdate = parseUpdate;
_removeDeadFiles = removeDeadFiles;
_parser = new MediaParser();
_extensions = extensions;
_existingFiles = existingFiles.ToDictionary(rt => rt.File);
_ignoredFiles = (from s in ignoredFiles select new FileInfo(s)).ToArray();
Parsed = parsed;
Done = done;
_state = ScannerState.NotRunning;
_added = _updated = _skipped = _error = _removed = _total = 0;
thread.Start();
}
/// <summary>
/// Scans the given directories for files matching the given filters.
/// </summary>
/// <param name="IEnumerable">An enumeration of directories.</param>
/// <param name="SearchPattern">A simple search pattern like "*.jpg".</param>
/// <param name="SearchOption">Include or do not include subdirectories.</param>
/// <param name="FileFilter">A delegate for filtering the found files.</param>
/// <returns>An enumeration of file infos.</returns>
public static IEnumerable<FileInfo> FileFilterPipe(this IEndPipe<String> SourcePipe,
String SearchPattern = "*",
SearchOption SearchOption = SearchOption.TopDirectoryOnly,
FileFilter FileFilter = null)
{
return new FileFilterPipe(SourcePipe, SearchPattern, SearchOption, FileFilter).AsEnumerable();
}
public int IndexOf(string name, int startIndex, SearchOption opt)
{
int foundIndx = -1;
name = name.Trim();
for (int i = startIndex; i < this.bookList.Count; i++)
{
if (opt == SearchOption.Author)
{
if (this.bookList[i].Author == name)
{
foundIndx = i;
}
}
else
{
if (this.bookList[i].Title == name)
{
foundIndx = i;
}
}
}
return foundIndx;
}
/// <summary>
/// Finds a list of input files within the folder provided.
/// </summary>
/// <param name="folderPath"></param>
/// <returns></returns>
public static List<InputFile> FindDatasets(string folderPath, List<string> extensions, SearchOption options)
{
var datasetList = new List<InputFile>();
var candidates = new List<string>();
foreach (var extension in extensions)
{
var paths = Directory.GetFiles(folderPath, "*" + extension, options);
candidates.AddRange(paths);
}
foreach (var path in candidates)
{
var type = DatasetInformation.GetInputFileType(path);
if (type == InputFileType.NotRecognized)
{
continue;
}
var file = new InputFile();
file.Path = path;
file.FileType = type;
datasetList.Add(file);
}
return datasetList;
}
/// <summary>
/// �����ļ�
/// </summary>
/// <param name="path">·��</param>
/// <param name="searchPattern">�����ַ���</param>
/// <param name="searchOption">����ѡ��</param>
/// <returns>�ҵ����ļ���</returns>
public string[] SearchFile(string path, string searchPattern, SearchOption searchOption, SearcherEventHandler processCallBack = null)
{
ArrayList arrayList = new ArrayList();
try
{
string[] fs = Directory.GetFiles(path, searchPattern);
foreach (string file in fs)
{
if (processCallBack != null)
processCallBack(file, Path.GetFileName(file), 1);
arrayList.Add(file);
}
}
catch { }
if (searchOption == SearchOption.AllDirectories)
{
try
{
string[] ds = Directory.GetDirectories(path);
foreach (string dpath in ds)
{
if (processCallBack != null)
processCallBack(dpath, "", 2);
InternalGetFiles(dpath, arrayList, processCallBack);
}
}
catch { }
}
return (string[])arrayList.ToArray(typeof(string));
}
public ActionResult Search(SearchOption searchOption, string searchText)
{
switch ((int)searchOption)
{
case 0:
// search by Title Name
return RedirectToAction("/GetTitlesByName", new { titleName = searchText });
break;
case 1:
// search by Genre
return RedirectToAction("/GetTitlesByGenre", new { genre = searchText });
break;
case 2:
// search by Language
return RedirectToAction("/GetTitlesByLanguage", new { language = searchText });
break;
case 3:
// search by Participant
return RedirectToAction("/GetTitlesByParticipant", new { participant = searchText });
break;
default:
// All
return RedirectToAction("/GetAllTitles/");
break;
}
}
/// <summary>
/// Returns the names of files in a specified directories that match the specified patterns.
/// </summary>
/// <param name="source">The directory to search.</param>
/// <param name="fileExtensions">The comma separated list of file extensions. <example>cs,cshtml</example>. </param>
/// <param name="searchStrings">The list of search strings (ignore case).</param>
/// <param name="searchOption">The search options. Default value is AllDirectories.</param>
/// <returns> The list of files that match the specified criteria. </returns>
public static List<SearchMatch> Search(this DirectoryInfo source, string fileExtensions, IEnumerable<string> searchStrings, SearchOption searchOption = SearchOption.AllDirectories)
{
var fileExtensionsList = fileExtensions.Split(',').Select(fileExtension => string.Format(@"*.{0}", fileExtension)).ToList();
var filesToSearch = from searchPattern in fileExtensionsList
from files in Directory.GetFiles(source.FullName, searchPattern, searchOption)
select files;
var matches = new List<SearchMatch>();
foreach (var file in filesToSearch)
{
var lineNumber = 1;
var lines = File.ReadAllLines(file);
foreach (var line in lines)
{
lineNumber++;
matches.AddRange(from searchString in searchStrings
where line.Contains(searchString, StringComparison.OrdinalIgnoreCase)
select new SearchMatch(file, lineNumber, line.Trim()));
}
}
return matches;
}
public static String[] GetFiles(
string folder,
string jobExtension,
SearchOption searchOption)
{
return MyDirectory.GetFiles(folder, jobExtension, searchOption);
}
public static IEnumerable<string> GetDirectories(string path, SearchOption option)
{
IEnumerable<string> dirs = null;
try
{
dirs = Directory.EnumerateDirectories(path);
//dirs = Directory.GetDirectories(path).ToList();
}
catch (UnauthorizedAccessException)
{
}
if (dirs != null)
{
foreach (var dir in dirs)
{
if (option == SearchOption.AllDirectories)
{
foreach (var x in GetDirectories(dir, option))
{
yield return x;
}
}
yield return dir;
}
}
}
public static List<ImageDescriptor> LoadImages(Uri uri, SearchOption searchOption)
{
var folderPath = uri.OriginalString;
var fullNames = new string[] { };
if (!folderPath.Equals(string.Empty))
fullNames = Directory.GetFiles(folderPath, "*.*", searchOption);
var list = new List<ImageDescriptor>();
for (var i = 0; i < fullNames.Length; i++)
{
var filePath = fullNames[i];
var imgInfo = DecodeBitmapImage(ref filePath, 128);
if (imgInfo != null)
list.Add(imgInfo);
}
GC.Collect();
return list;
}
//根据关键字获得文件全名列表
public static string GetFileFullNameListByKeyword(string strFolderPath, string strKeyword, string searchPattern, SearchOption searchOption)
{
string strResult = "";
DirectoryInfo directoryInfo = new DirectoryInfo(strFolderPath);
//按文件名称升序排列
FileInfo[] fileInfos = directoryInfo.GetFiles(searchPattern, searchOption).OrderBy(p => p.Name).ToArray();
string strContent = "";
for (int i = 0; i < fileInfos.Length; i++)
{
StreamReader sr = new StreamReader(fileInfos[i].OpenRead(), Encoding.Default);
strContent = sr.ReadToEnd();
if (strContent.Contains(strKeyword))
{
strResult += fileInfos[i].FullName + "|";
}
sr.Close();
sr.Dispose();
strContent = "";
}
Array.Clear(fileInfos, 0, fileInfos.Length);
return strResult;
}
/// <summary>
/// Initializes a new instance of the <see cref="SearchData"/> class.
/// </summary>
/// <param name="fullPath">The full path.</param>
/// <param name="userPath">The user path.</param>
/// <param name="searchOptions">The search options.</param>
public SearchData(String fullPath, String userPath, SearchOption searchOptions)
{
Contract.Requires(fullPath != null);
Contract.Requires(searchOptions == SearchOption.AllDirectories || searchOptions == SearchOption.TopDirectoryOnly);
if( PathHelperMethods.IsDirectorySeparator(fullPath[fullPath.Length - 1]) )
{
this.fullPath = fullPath;
}
else
{
this.fullPath = fullPath + Path.DirectorySeparatorChar;
}
if( string.IsNullOrEmpty(userPath) || PathHelperMethods.IsDirectorySeparator(userPath[userPath.Length - 1]) )
{
this.userPath = userPath;
}
else
{
this.userPath = userPath + Path.DirectorySeparatorChar;
}
this.searchOptions = searchOptions;
}
/// <summary>
/// Static method to find files in a specified path.
/// </summary>
/// <param name="path">Path to the folder where to look for files.</param>
/// <param name="pattern">File name pPattern for the search.</param>
/// <param name="so">Search option. TopDirectoryOnly to search only in the top folder or AllDirectories to search also in the sub-directories. The default is TopDirectoryOnly.</param>
/// <returns></returns>
public static FileInfo[] FindFiles(string path, string pattern, SearchOption so = SearchOption.TopDirectoryOnly)
{
DirectoryInfo di = new System.IO.DirectoryInfo(path);
FileInfo[] fl = di.GetFiles(pattern, so);
return fl;
}
public string[] findFilesFromPath(string path, string fileNameParam, SearchOption searchOp)
{
string[] filenames = null;
filenames = Directory.GetFiles(@path, "*" + fileNameParam + "*", searchOp);
return filenames;
}
public static void CopyTo(this DirectoryInfo sourceDirectory, string target, SearchOption option, string searchPattern)
{
if (target[target.Length - 1] != Path.DirectorySeparatorChar)
{
target += Path.DirectorySeparatorChar;
}
if (!Directory.Exists(target))
{
Directory.CreateDirectory(target);
for (int i = 0; i < searchPattern.Length; i++)
{
foreach (string file in Directory.GetFiles(sourceDirectory.FullName, searchPattern))
{
Console.WriteLine("Copying {0} to {1}", file, target + Path.GetFileName(file));
File.Copy(file, target + Path.GetFileName(file), true);
}
}
// Copy subdirectories (recursively)
if (option == SearchOption.AllDirectories)
{
foreach (string element in Directory.GetDirectories(sourceDirectory.FullName))
{
DirectoryInfo d = new DirectoryInfo(element);
CopyTo(d, target + Path.GetFileName(element), option, searchPattern);
}
}
}
}
/// <summary>
/// Returns an enumerable collection of file names in a specified path.
/// </summary>
/// <param name="pattern">Search pattern. Uses Win32 native filtering.</param>
/// <param name="searchOption">Specifiy depth with <see cref="SearchOption"/></param>
/// <param name="pathFormatReturn">Specifies the type of path to return.</param>
/// <param name="enumerateOptions">Options</param>
/// <returns>An enumerable collection of the full names (including paths) for the files in the directory specified by path.</returns>
public IEnumerable<string> EnumerateFilePaths( String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOPathType pathFormatReturn = QuickIOPathType.Regular, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
Contract.Requires( !String.IsNullOrWhiteSpace( pattern ) );
Contract.Ensures( Contract.Result<IEnumerable<string>>() != null );
return QuickIODirectory.EnumerateFilePaths( FullNameUnc, pattern, searchOption, pathFormatReturn, enumerateOptions );
}
/// <summary>
/// Returns an enumerable collection of files in a specified path.
/// </summary>
/// <param name="pattern">Search pattern. Uses Win32 native filtering.</param>
/// <param name="searchOption">Specifiy depth with <see cref="SearchOption"/></param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>An enumerable collection of the full names (including paths) for the files in the directory specified by path.</returns>
public IEnumerable<QuickIOFileInfo> EnumerateFiles( String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
Contract.Requires( !String.IsNullOrWhiteSpace( pattern ) );
Contract.Ensures(Contract.Result<IEnumerable<QuickIOFileInfo>>() != null);
return QuickIODirectory.EnumerateFiles( FullNameUnc, pattern, searchOption );
}
public FileSearchTemplate(DirectoryInfo directory, string pattern, SearchOption option)
: this()
{
Pattern = pattern;
Directory = directory;
SearchOption = option;
}
public static string[] GetFileSystemEntries(string path, string searchPattern, SearchOption searchOption)
{
// Take the simple way home:
return(new List <string> (EnumerateFileSystemEntries(path, searchPattern, searchOption)).ToArray());
}
public static IEnumerable <string> EnumerateFileSystemEntries(string path, string searchPattern, SearchOption searchOption)
{
EnumerateCheck(path, searchPattern, searchOption);
return(EnumerateKind(path, searchPattern, searchOption, FileAttributes.Normal | FileAttributes.Directory));
}
private static FileInfo[] FindFilesOfType(string extension, SearchOption searchOption = SearchOption.TopDirectoryOnly)
{
var folder = new DirectoryInfo("./");
return(folder.GetFiles($"*{extension}", searchOption));
}
public IEnumerable <DirectoryInfo> EnumerateDirectories(String searchPattern, SearchOption searchOption)
{
if (searchPattern == null)
{
throw new ArgumentNullException("searchPattern");
}
if ((searchOption != SearchOption.TopDirectoryOnly) && (searchOption != SearchOption.AllDirectories))
{
throw new ArgumentOutOfRangeException("searchOption", SR.ArgumentOutOfRange_Enum);
}
Contract.EndContractBlock();
return(InternalEnumerateDirectories(searchPattern, searchOption));
}
public static IEnumerable <DirectoryInfo> EnumerateDirectoriesSafe(DirectoryInfo dir, string filter = "*.*", SearchOption opt = SearchOption.TopDirectoryOnly)
{
var retval = Enumerable.Empty <DirectoryInfo>();
try
{
retval = dir.EnumerateDirectories(filter, SearchOption.TopDirectoryOnly);
}
catch
{
Console.WriteLine("{0} Inaccessable.", dir.FullName);
}
if (opt == SearchOption.AllDirectories)
{
retval = retval.Concat(retval.SelectMany(x => EnumerateDirectoriesSafe(x, filter, opt)));
}
return(retval);
}
public IEnumerable <FileSystemInfo> EnumerateFileSystemInfos(string searchPattern, SearchOption searchOption) => EnumerateFileSystemInfos(searchPattern, EnumerationOptions.FromSearchOption(searchOption));
public IEnumerable <DirectoryInfo> EnumerateDirectories(string searchPattern, SearchOption searchOption) => EnumerateDirectories(searchPattern, EnumerationOptions.FromSearchOption(searchOption));
public DirectoryInfo[] GetDirectories(string searchPattern, SearchOption searchOption) => GetDirectories(searchPattern, EnumerationOptions.FromSearchOption(searchOption));
public FileSystemInfo[] GetFileSystemInfos(string searchPattern, SearchOption searchOption) => GetFileSystemInfos(searchPattern, EnumerationOptions.FromSearchOption(searchOption));
public EntryEnumerable(string path, string filter, SearchOption searchOption)
{
m_path = path;
m_filter = filter;
m_searchOption = searchOption;
}
public static IEnumerable <string> GetFiles(string root, string searchPattern, SearchOption p)
{
var pending = new Stack <string>();
pending.Push(root);
while (pending.Count != 0)
{
var path = pending.Pop();
string[] next = null;
try
{
next = Directory.GetFiles(path, searchPattern);
}
catch (Exception)
{
// ignored
}
if (next != null && next.Length != 0)
{
foreach (var file in next)
{
yield
return(file);
}
}
try
{
next = Directory.GetDirectories(path);
foreach (var item in next)
{
pending.Push(item);
}
}
catch (Exception)
{
// ignored
}
}
}
/// <summary>
/// Enumerates all files and directories from a given directory (PathTooLong safe, volume guid safe).
/// </summary>
public static List <WIN32_FILE> GetEntriesList(string path, string searchPattern, SearchOption searchOption)
{
IEnumerable <WIN32_FILE> IEn = EnumerateEntries(FixPath(path), searchPattern, searchOption);
List <WIN32_FILE> lEntries = new List <WIN32_FILE>(IEn);
return(lEntries);
}
// code from "A Faster Directory Enumerator" by wilsone8
// modified to make PathToLong-safe and to handle directories
public static IEnumerable <WIN32_FILE> EnumerateEntries(string path, string searchPattern, SearchOption searchOption)
{
return(new EntryEnumerable(path, searchPattern, searchOption));
}
public DSView DrawSeries(TimeSeries series, int padNumber, Color color, SimpleDSStyle style, SearchOption option, SmoothingMode smoothingMode)
{
throw new NotImplementedException();
}
public override Collections.Generic.IEnumerable <FileSystemInfo> EnumerateFileSystemInfos(string fullPath, string searchPattern, SearchOption searchOption, SearchTarget searchTarget)
{
return(Select(fullPath).EnumerateFileSystemInfos(fullPath, searchPattern, searchOption, searchTarget));
}
public static IEnumerable <string> EnumerateFileSystemEntries(string path, string searchPattern, SearchOption searchOption) => EnumerateFileSystemEntries(path, searchPattern, EnumerationOptions.FromSearchOption(searchOption));
public void DrawSeries(TimeSeries series, int padNumber, Color color, SearchOption option)
{
}
public static string[] GetDirectories(string path, string searchPattern, SearchOption searchOption) => GetDirectories(path, searchPattern, EnumerationOptions.FromSearchOption(searchOption));
public static string[] GetFileSystemEntries(string path, string searchPattern, SearchOption searchOption) => GetFileSystemEntries(path, searchPattern, EnumerationOptions.FromSearchOption(searchOption));
public override IFileInfo[] GetFiles(string path, SearchOption search_option)
{
throw new NotImplementedException();
}
/// <summary>
/// Enumerate subdirectories in a given directory
/// </summary>
/// <param name="BaseDir">Base directory to search in</param>
/// <param name="Pattern">Pattern for matching files</param>
/// <param name="Option">Options for the search</param>
/// <returns>Sequence of directory references</returns>
public static IEnumerable <DirectoryReference> EnumerateDirectories(DirectoryReference BaseDir, string Pattern, SearchOption Option)
{
foreach (string DirectoryName in Directory.EnumerateDirectories(BaseDir.FullName, Pattern, Option))
{
yield return(DirectoryReference.MakeFromNormalizedFullPath(DirectoryName));
}
}
public async Task <List <Picture> > GetPicturesFromFolderAsync(string folderPath,
SearchOption option = SearchOption.TopDirectoryOnly) =>
await GetPicturesFromFolderAsync(folderPath, option,
Global.ALL_SUPPORTED_PATTERNS.ToArray());
public override IDirectoryInfo[] GetDirectories(string path, SearchOption search_option)
{
throw new NotImplementedException();
}
/// <summary>
/// DirectoryUtilities.GetFiles is basicaly the same as Directory.GetFiles
/// however it returns IEnumerator, which means that it lazy. This is very important
/// for large directory trees. A searchPattern can be specified (Windows wildcard conventions)
/// that can be used to filter the set of archiveFile names returned.
///
/// Suggested Usage
///
/// foreach(string fileName in DirectoryUtilities.GetFiles("c:\", "*.txt")){
/// Console.WriteLine(fileName);
/// }
///
/// </summary>
/// <param variable="directoryPath">The base directory to enumerate</param>
/// <param variable="searchPattern">A pattern to filter the names (windows filename wildcards * ?)</param>
/// <param variable="searchOptions">Indicate if the search is recursive or not. </param>
/// <returns>The enumerator for all archiveFile names in the directory (recursively). </returns>
public static IEnumerable <string> GetFiles(string directoryPath, string searchPattern, SearchOption searchOptions)
{
string[] fileNames = Directory.GetFiles(directoryPath, searchPattern, SearchOption.TopDirectoryOnly);
Array.Sort <string>(fileNames, StringComparer.OrdinalIgnoreCase);
foreach (string fileName in fileNames)
{
yield return(fileName);
}
if (searchOptions == SearchOption.AllDirectories)
{
string[] subDirNames = Directory.GetDirectories(directoryPath);
Array.Sort <string>(subDirNames);
foreach (string subDir in subDirNames)
{
foreach (string fileName in DirectoryUtilities.GetFiles(subDir, searchPattern, searchOptions))
{
yield return(fileName);
}
}
}
}
public IEnumerable <string> EnumerateFiles(string path, string searchPattern, SearchOption searchOption)
{
Contract.Assert(searchOption == SearchOption.AllDirectories);
return(_files
.Where(kvp => kvp.Key.StartsWith(path) && kvp.Key.Contains(searchPattern))
.Select(kvp => kvp.Key));
}
private IEnumerable <DirectoryInfo> InternalEnumerateDirectories(String searchPattern, SearchOption searchOption)
{
Contract.Requires(searchPattern != null);
Contract.Requires(searchOption == SearchOption.AllDirectories || searchOption == SearchOption.TopDirectoryOnly);
return((IEnumerable <DirectoryInfo>)FileSystem.Current.EnumerateFileSystemInfos(FullPath, searchPattern, searchOption, SearchTarget.Directories));
}
public string[] GetFiles(string path, string searchPattern, SearchOption searchOption)
{
return(Directory.GetFiles(path, searchPattern, searchOption));
}
public IEnumerable <string> EnumerateFileSystemEntries(string path, string pattern = "*", SearchOption searchOption = SearchOption.TopDirectoryOnly)
{
if (_environmentSettings.Host.FileSystem.FileExists(path))
{
return(new[] { path });
}
if (_environmentSettings.Host.FileSystem.DirectoryExists(path))
{
return(_environmentSettings.Host.FileSystem.EnumerateFileSystemEntries(ProcessPath(path), pattern, searchOption));
}
return(Enumerable.Empty <string>());
}
public IEnumerable <string> GetFiles(string path, string pattern, SearchOption option)
{
throw new NotImplementedException();
}
internal static IEnumerable <string> EnumerateKind(string path, string searchPattern, SearchOption searchOption, FileAttributes kind)
{
if (searchPattern.Length == 0)
{
yield break;
}
bool stop;
string path_with_pattern = ValidateDirectoryListing(path, searchPattern, out stop);
if (stop)
{
yield return(path_with_pattern);
yield break;
}
IntPtr handle;
MonoIOError error;
FileAttributes rattr;
bool subdirs = searchOption == SearchOption.AllDirectories;
string s = MonoIO.FindFirst(path, path_with_pattern, out rattr, out error, out handle);
if (s == null)
{
yield break;
}
if (error != 0)
{
throw MonoIO.GetException(Path.GetDirectoryName(Path.Combine(path, searchPattern)), (MonoIOError)error);
}
try
{
if (((rattr & FileAttributes.ReparsePoint) == 0) && ((rattr & kind) != 0))
{
yield return(s);
}
while ((s = MonoIO.FindNext(handle, out rattr, out error)) != null)
{
if ((rattr & FileAttributes.ReparsePoint) != 0)
{
continue;
}
if ((rattr & kind) != 0)
{
yield return(s);
}
if (((rattr & FileAttributes.Directory) != 0) && subdirs)
{
foreach (string child in EnumerateKind(s, searchPattern, searchOption, kind))
{
yield return(child);
}
}
}
}
finally
{
MonoIO.FindClose(handle);
}
}
public IEnumerable<IFile> GetFiles(string searchPattern, SearchOption searchOption)
{
var storage = getStorage();
return storage.GetFileNames(searchPattern).Select(
filename => new IsolatedStorageFile(GetAbsolutePath(filename), getStorage, this)
);
}
