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