internal override IEnumerable<FileSystemEntry> ImplFindFiles(String Path) { String CachedRealPath = RealPath(Path); DirectoryInfo DirectoryInfo = new DirectoryInfo(CachedRealPath); foreach (var Item in DirectoryInfo.EnumerateFileSystemInfos()) { if (!Item.FullName.StartsWith(CachedRealPath)) { throw(new Exception("Unexpected FullName")); } if (Item.Attributes.HasFlag(FileAttributes.Hidden)) { continue; } var FileSystemEntry = new LocalFileSystemEntry(this, Path + "/" + Item.Name, Item); //FileSystemEntry.Size = File.get //Item.Attributes == FileAttributes. // //FileSystemEntry.Time = Item. yield return FileSystemEntry; } }
protected override Task<HttpResponseMessage> CreateDirectoryGetResponse(DirectoryInfo info, string localFilePath) { HttpResponseMessage response = Request.CreateResponse(); using (var zip = new ZipFile()) { foreach (FileSystemInfo fileSysInfo in info.EnumerateFileSystemInfos()) { bool isDirectory = (fileSysInfo.Attributes & FileAttributes.Directory) != 0; if (isDirectory) { zip.AddDirectory(fileSysInfo.FullName, fileSysInfo.Name); } else { // Add it at the root of the zip zip.AddFile(fileSysInfo.FullName, "/"); } } using (var ms = new MemoryStream()) { zip.Save(ms); response.Content = ms.AsContent(); } } response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/zip"); response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment"); // Name the zip after the folder. e.g. "c:\foo\bar\" --> "bar" response.Content.Headers.ContentDisposition.FileName = Path.GetFileName(Path.GetDirectoryName(localFilePath)) + ".zip"; return Task.FromResult(response); }
private bool TestCoreCLRIssue() { string root = null; try { root = Path.GetTempFileName(); File.Delete(root); Directory.CreateDirectory(root); var testDir = new DirectoryInfo(root); var betaDir = Path.Combine(root, "beta"); Directory.CreateDirectory(betaDir); var beta = testDir.EnumerateFileSystemInfos("beta", SearchOption.TopDirectoryOnly).First() as DirectoryInfo; return !beta.Exists; } finally { if (root != null && Directory.Exists(root)) { Directory.Delete(root, true); } } }
public static void AddDirectory(this ZipArchive archive, string sourceDir) { DirectoryInfo directoryInfo = new DirectoryInfo(sourceDir); sourceDir = directoryInfo.FullName; foreach (FileSystemInfo entry in directoryInfo.EnumerateFileSystemInfos("*", SearchOption.AllDirectories)) { string relativePath = entry.FullName.Substring(sourceDir.Length, entry.FullName.Length - sourceDir.Length); relativePath = relativePath.TrimStart(new char[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }); if (entry is FileInfo) { archive.AddFile(entry.FullName, relativePath); } else { DirectoryInfo subDirInfo = entry as DirectoryInfo; if (subDirInfo != null && !subDirInfo.EnumerateFileSystemInfos().Any()) { archive.CreateEntry(relativePath + Path.DirectorySeparatorChar); } } } }
public INode GetTree(string rootPath) { var directoryInfo = new DirectoryInfo(rootPath); if (directoryInfo.Attributes != FileAttributes.Directory) { var file = new FileInfo(rootPath); return new Node { Id = file.FullName, Name = file.Name, NodeType = NodeType.File, Children = new INode[0], }; } var result = new Node { Id = directoryInfo.FullName, Name = directoryInfo.Name, NodeType = NodeType.Folder }; result.Children = directoryInfo.EnumerateFileSystemInfos().Select(fileSystemInfo => new Node { Id = fileSystemInfo.FullName, Name = fileSystemInfo.Name, Children = new INode[0] }).ToList(); return result; }
public static bool MightContainSolution(this ISimpleRepositoryModel repository) { var dir = new DirectoryInfo(repository.LocalPath); return dir.EnumerateFileSystemInfos("*", SearchOption.TopDirectoryOnly) .Any(x => ((x.Attributes.HasFlag(FileAttributes.Directory) || x.Attributes.HasFlag(FileAttributes.Normal)) && !x.Name.StartsWith(".", StringComparison.Ordinal) && !x.Name.StartsWith("readme", StringComparison.OrdinalIgnoreCase))); }
protected override Task<HttpResponseMessage> CreateDirectoryGetResponse(DirectoryInfo info, string localFilePath) { HttpResponseMessage response = Request.CreateResponse(); using (var ms = new MemoryStream()) { using (var zip = new ZipArchive(ms, ZipArchiveMode.Create, leaveOpen: true)) { foreach (FileSystemInfo fileSysInfo in info.EnumerateFileSystemInfos()) { DirectoryInfo directoryInfo = fileSysInfo as DirectoryInfo; if (directoryInfo != null) { zip.AddDirectory(new DirectoryInfoWrapper(directoryInfo), fileSysInfo.Name); } else { // Add it at the root of the zip zip.AddFile(fileSysInfo.FullName, String.Empty); } } } response.Content = ms.AsContent(); } response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/zip"); response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment"); // Name the zip after the folder. e.g. "c:\foo\bar\" --> "bar" response.Content.Headers.ContentDisposition.FileName = Path.GetFileName(Path.GetDirectoryName(localFilePath)) + ".zip"; return Task.FromResult(response); }
public static void ZipDirectory(string dir) { string zipfile_name = dir + ".zip"; if (File.Exists(zipfile_name)) { return; } using (var zip = new ZipFile(Encoding.GetEncoding("shift_jis"))) { zip.CompressionLevel = Ionic.Zlib.CompressionLevel.BestCompression; var di = new DirectoryInfo(dir); foreach (var i in di.EnumerateFileSystemInfos()) { if (FileAttributes.Directory == (i.Attributes & FileAttributes.Directory)) { zip.AddDirectory(i.FullName, i.Name); } else if (FileAttributes.Hidden != (i.Attributes & FileAttributes.Hidden)) { zip.AddFile(i.FullName, ""); } } zip.Save(zipfile_name); } }
private bool CleanDirectoryPath(CmdletProgress bar, DateTime dtNow, TimeSpan age, DirectoryInfo currentDirecotry, string relativePath) { var empty = true; foreach (var fsi in currentDirecotry.EnumerateFileSystemInfos()) { var currentRelativePath = Path.Combine(relativePath, fsi.Name); var di = fsi as DirectoryInfo; var fi = fsi as FileInfo; if (di != null) { if (CleanDirectoryPath(bar, dtNow, age, di, currentRelativePath)) { directoriesDeleted++; empty = DeleteSafe(bar, di.Delete, currentRelativePath); } else empty = false; } else if (fi != null) { if (IsOutAged(dtNow, fi.LastAccessTime, age) || IsOutAged(dtNow, fi.LastWriteTime, age) || IsOutAged(dtNow, fi.LastAccessTime, age)) { bytesDeleted += fi.Length; filesDeleted++; if (!DeleteSafe(bar, fi.Delete, currentRelativePath)) empty = false; } else empty = false; } } return empty; }
public static AsmAdjancyGraph GetDpxAdjGraph(string binDir) { try { if (string.IsNullOrWhiteSpace(binDir) || !Directory.Exists(binDir)) { var asmAdjGraph = new AsmAdjancyGraph { Msg = $"The bin directory {binDir} is null or does not exist.", St = MetadataTokenStatus.Error }; return asmAdjGraph; } //get all the dll files in the dir var di = new DirectoryInfo(binDir); var dllsFullNames = di.EnumerateFileSystemInfos("*.dll", SearchOption.TopDirectoryOnly).Select(x => x.FullName).ToArray(); if (!dllsFullNames.Any()) { var asmAdjGraph = new AsmAdjancyGraph { Msg = $"The directory {binDir} does not contain any files with a .dll extension.", St = MetadataTokenStatus.Error }; return asmAdjGraph; } //get all the assembly names of direct files and each of thier ref's var asmIndxBuffer = new List<Tuple<RankedMetadataTokenAsm, RankedMetadataTokenAsm[]>>(); foreach (var dll in dllsFullNames) { var asmName = AssemblyName.GetAssemblyName(dll); if (asmName == null) continue; var asm = Asm.NfLoadFrom(dll); var refs = asm.GetReferencedAssemblies().ToArray(); var mdta = new RankedMetadataTokenAsm { AssemblyName = asm.GetName().FullName, IndexId = -1, DllFullName = dll, HasPdb = File.Exists(Path.ChangeExtension(dll, "pdb")) }; asmIndxBuffer.Add(new Tuple<RankedMetadataTokenAsm, RankedMetadataTokenAsm[]>(mdta, refs.Select(x => new RankedMetadataTokenAsm { AssemblyName = x.FullName, IndexId = -2}).ToArray())); } return GetDpxAdjGraph(asmIndxBuffer); } catch (Exception ex) { return new AsmAdjancyGraph {Msg = ex.Message, St = MetadataTokenStatus.Error}; } }
void ScanDirectory(string directory) { DirectoryInfo directoryInfo = new DirectoryInfo (directory); foreach (FileSystemInfo info in directoryInfo.EnumerateFileSystemInfos ()) { queue.Enqueue (info); if ((info.Attributes & FileAttributes.Directory) != 0) { ScanDirectory (info.FullName); } } queue.Enqueue (null); }
private static void Run_DirectoryInfo_Enumerate() { System.Console.Write(" -- Run_DirectoryInfo_Enumerate "); var stopwatch = Stopwatch.StartNew(); var baseDir = new DirectoryInfo(_baseDir); var entries = baseDir.EnumerateFileSystemInfos("*", SearchOption.AllDirectories); var count = entries.Count(); stopwatch.Stop(); System.Console.Write(" -- Count: {0} -- Time {1} = {2}/sec", count, stopwatch.Elapsed, 1000.0 * count / stopwatch.ElapsedMilliseconds); }
private void DeleteEmptyFolders(DirectoryInfo directoryInfo) { foreach (var directory in directoryInfo.EnumerateDirectories()) { DeleteEmptyFolders(directory); } if (!directoryInfo.EnumerateFileSystemInfos().Any()) { directoryInfo.Delete(); } }
private static Task CreateFromDirectoryHelper(string sourcePath, string archiveFilePath, IProgress<float> progress, CancellationToken cancelToken) { sourcePath = Path.GetFullPath(sourcePath); archiveFilePath = Path.GetFullPath(archiveFilePath); var folderSeparators = new char[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }; return Task.Run(() => { using (var zipArchive = ZipFile.Open(archiveFilePath, ZipArchiveMode.Create, Encoding.UTF8)) { var directoryInfo = new DirectoryInfo(sourcePath); // this code results in two run-throughs of the source folder, but // because of windows file system caching, the second run-through below, // will be much faster than the first var totalBytes = directoryInfo .EnumerateFiles("*", SearchOption.AllDirectories) .Sum(fi => fi.Length); var currentBytes = 0L; cancelToken.ThrowIfCancellationRequested(); foreach (var info in directoryInfo.EnumerateFileSystemInfos("*", SearchOption.AllDirectories)) { cancelToken.ThrowIfCancellationRequested(); int length = info.FullName.Length - sourcePath.Length; var entryName = info.FullName.Substring(sourcePath.Length, length).TrimStart(folderSeparators); if (info is FileInfo) { var sourceInfo = (FileInfo)info; using (var source = sourceInfo.OpenRead()) { var entry = zipArchive.CreateEntry(entryName); entry.LastWriteTime = sourceInfo.GetLastWriteTime(); using (var destination = entry.Open()) { currentBytes += StreamCopyHelper(source, destination, progress, totalBytes, currentBytes, cancelToken); } } } else if (info is DirectoryInfo) { if (IsFolderEmpty(info.FullName)) { // create entry for empty folder zipArchive.CreateEntry(string.Concat(entryName, Path.DirectorySeparatorChar)); } } } } }); }
public void Execute(ProjectConfiguration configuration, string selectedProject) { DirectoryInfo projectDirectory = new DirectoryInfo(configuration.RootPath); List<FileSystemInfo> projectFiles = projectDirectory .EnumerateFileSystemInfos("*.csproj", SearchOption.AllDirectories) .ToList(); var targetProjects = configuration.ResolveAssemblies(selectedProject); if (_checkOnlyDependencies) { var projectSetup = new ProjectSetup { WhenAssemblyKeyFileNotFound = ProjectSetupBehavior.Valid, WhenContainsFileReferences = ProjectSetupBehavior.Valid, WhenContainsProjectReferences = ProjectSetupBehavior.Warn, WhenReferenceNotResolved = ProjectSetupBehavior.Warn, WhenReferenceResolvedInDifferentLocation = ProjectSetupBehavior.Warn, WhenRequiredProjectLinkNotFound = ProjectSetupBehavior.Valid }; var consoleLogger = ConsoleLogger.Default; var generator = new SolutionGenerator.Toolkit.SolutionGenerator(consoleLogger); var projectLoader = generator.GetProjectLoader(projectSetup, configuration.RootPath); var targetProjectFiles = generator.GetTargetProjectFiles(projectLoader, targetProjects); ReferenceWalker walker = new ReferenceWalker(consoleLogger); var dependencies = walker.WalkReferencesRecursively( projectSetup, projectLoader, targetProjectFiles, new[] {configuration.ThirdPartiesRootPath}, new HashSet<string>()); projectFiles = new List<FileSystemInfo>(); foreach (var dependency in dependencies) { var project = projectLoader.GetProjectById(dependency); projectFiles.Add(new FileInfo(project.ProjectFileLocation)); } } ChangeOutputPath(projectFiles, configuration.RootPath, configuration.BinariesOutputPath, targetProjects); ChangeReferences(projectFiles, configuration.RootPath, configuration.BinariesOutputPath, configuration.TargetFrameworkVersion, configuration.GetSystemRuntimeReferenceMode, configuration.GetSpecificVersionReferenceMode, targetProjects); ChangeProjectSettings(projectFiles); }
static public int EnumerateFileSystemInfos(IntPtr l) { try { System.IO.DirectoryInfo self = (System.IO.DirectoryInfo)checkSelf(l); var ret = self.EnumerateFileSystemInfos(); pushValue(l, true); pushValue(l, ret); return(2); } catch (Exception e) { return(error(l, e)); } }
static void Tidy(DirectoryInfo tree) { foreach (DirectoryInfo di in tree.EnumerateDirectories()) { Tidy(di); } tree.Refresh(); if (!tree.EnumerateFileSystemInfos().Any()) { tree.Delete(); } return; }
private static List <Result> DirectorySearch(EnumerationOptions enumerationOption, Query query, string search, string searchCriteria, CancellationToken token) { var results = new List <Result>(); var path = FilesFolders.ReturnPreviousDirectoryIfIncompleteString(search); var folderList = new List <Result>(); var fileList = new List <Result>(); try { var directoryInfo = new System.IO.DirectoryInfo(path); foreach (var fileSystemInfo in directoryInfo.EnumerateFileSystemInfos(searchCriteria, enumerationOption)) { if (fileSystemInfo is System.IO.DirectoryInfo) { folderList.Add(ResultManager.CreateFolderResult(fileSystemInfo.Name, fileSystemInfo.FullName, fileSystemInfo.FullName, query, true, false)); } else { fileList.Add(ResultManager.CreateFileResult(fileSystemInfo.FullName, query, true, false)); } token.ThrowIfCancellationRequested(); } } catch (Exception e) { if (!(e is ArgumentException)) { throw e; } results.Add(new Result { Title = e.Message, Score = 501 }); return(results); #if DEBUG // Please investigate and handle error from DirectoryInfo search #else Log.Exception($"|Flow.Launcher.Plugin.Explorer.DirectoryInfoSearch|Error from performing DirectoryInfoSearch", e); #endif } // Initial ordering, this order can be updated later by UpdateResultView.MainViewModel based on history of user selection. return(results.Concat(folderList.OrderBy(x => x.Title)).Concat(fileList.OrderBy(x => x.Title)).ToList()); }
public IEnumerable<IFileSystemObject> GetContentsEnumerable(string path) { DirectoryInfo pathDir = new DirectoryInfo(path); if (!pathDir.Exists) { throw new ArgumentException(path + " does not exist"); } return pathDir.EnumerateFileSystemInfos() .OrderBy(c => { if (c.Attributes.HasFlag(FileAttributes.Directory)) { return 0; } else if (c.Attributes.HasFlag(FileAttributes.Archive)) { return 1; } else { return 2; } }) .Select(c => Create(c)); }
private static void CopyDirectory(string source, string destination, bool overwrite, bool copyEmptyDirectories, bool copySubDirectories, ref int count) { DirectoryInfo sourceDirectory = new DirectoryInfo(source); if (!copyEmptyDirectories && !sourceDirectory.EnumerateFileSystemInfos().Any()) return; foreach (FileInfo fileInfo in sourceDirectory.GetFiles()) CopyFile(fileInfo.FullName, Path.Combine(destination, fileInfo.Name), overwrite, true, ref count); if (!copySubDirectories) return; foreach (DirectoryInfo directoryInfo in sourceDirectory.GetDirectories()) CopyDirectory(directoryInfo.FullName, Path.Combine(destination, directoryInfo.Name), overwrite, copyEmptyDirectories, copySubDirectories, ref count); }
static public int EnumerateFileSystemInfos__String__SearchOption(IntPtr l) { try { System.IO.DirectoryInfo self = (System.IO.DirectoryInfo)checkSelf(l); System.String a1; checkType(l, 2, out a1); System.IO.SearchOption a2; checkEnum(l, 3, out a2); var ret = self.EnumerateFileSystemInfos(a1, a2); pushValue(l, true); pushValue(l, ret); return(2); } catch (Exception e) { return(error(l, e)); } }
public QueryResult<FolderModel> ReadChildren(GetDataInfo getInfo, string parentKey, int level, string path, bool includeFiles) { string fullpath = Path.GetFullPath(Path.Combine(ROOT,path)); DirectoryInfo dinfo = new DirectoryInfo(fullpath); if (!includeFiles) { var dirs = dinfo.EnumerateDirectories(); var res = dirs.Select(d => new FolderModel { Key = Guid.NewGuid().ToString(), ParentKey = parentKey, HasSubDirs = d.EnumerateDirectories().Any(), Level = level, Name = d.Name, IsFolder = true }).OrderBy(d=>d.Name); return new QueryResult<FolderModel>(res); } else { var fileSyst = dinfo.EnumerateFileSystemInfos(); var res2 = fileSyst.Select(d => new FolderModel { Key = Guid.NewGuid().ToString(), ParentKey = parentKey, HasSubDirs = (d is DirectoryInfo) ? ((DirectoryInfo)d).EnumerateFileSystemInfos().Any() : false, Level = level, Name = d.Name, IsFolder = (d is DirectoryInfo) }).OrderByDescending(d=>d.IsFolder).ThenBy(d=>d.Name); return new QueryResult<FolderModel>(res2); } }
public static void DirectoryInfoTest() { Console.WriteLine("\n ------------ DIRECTORYINFO CLASS TEST ++++++++++++ "); var path = Directory.GetCurrentDirectory() + "\\DirInfo"; var path2 = Directory.GetCurrentDirectory() + "\\DirInfo2"; /*Creation */ DirectoryInfo di = new System.IO.DirectoryInfo(path); // via ctrol di.Create(); di.CreateSubdirectory("SubDir"); var dinfo = Directory.CreateDirectory(path + "\\newDir"); //via Directory.CreateDirectory FileAttributes fileAttributes = di.Attributes; //enum Console.WriteLine(fileAttributes.ToString()); //di.CreateObjRef todo: wtf Console.WriteLine("Created: {0}", di.CreationTime.ToShortTimeString()); //di.Delete(); //di.EnumerateDirectories(); var dirs = di.EnumerateDirectories(searchPattern: "*", searchOption: SearchOption.AllDirectories);// IEnumerable<DirInfo> Parallel.ForEach(dirs, (dir) => { Console.WriteLine(dir); }); var files = di.EnumerateFiles(searchPattern: "*.txt"); // IEnumerable<FileInfo> Parallel.ForEach(files, (file) => { Console.WriteLine(file); });; IEnumerable <FileSystemInfo> filesSystemInfo = di.EnumerateFileSystemInfos(searchPattern: "*"); Console.WriteLine("Exists: {0} ", di.Exists); Console.WriteLine("Extension: {0}", di.Extension); Console.WriteLine(di.FullName); DirectoryInfo[] dis = di.GetDirectories(); di.GetFiles(searchOption: SearchOption.AllDirectories, searchPattern: "*.txt"); // object lts = di.GetLifetimeService(); todo: wtf //di.GetObjectData() wtf //di.MoveTo() di.InitializeLifetimeService(); //todo }
public ActionResult Files(string id, string path) { var dir = GetFolder(id).Parent; if (path == null) path = ""; path = path.Replace("/" + id, "\\"); dir = new DirectoryInfo(dir.FullName + "\\" + path); //if (!dir.Exists) // return HttpNotFound("Not found " + dir.FullName); var files = dir.EnumerateFileSystemInfos().Select(x => new { x.Name, IsDirectory = x is DirectoryInfo, Size = (x is FileInfo) ? ((FileInfo)x).Length : 0 , LastModified = x.LastWriteTimeUtc }).OrderByDescending(x=>x.IsDirectory).ThenBy(x=>x.Name); return Json(files, JsonRequestBehavior.AllowGet); }
private static IPropagatorBlock<string, KeyValuePair<string, long>> CreateCustomBlock() { var directoryBrowserBlock = new TransformManyBlock<string, string>(path => { var dir = new DirectoryInfo(path); return dir.EnumerateFileSystemInfos() .Select(fi => fi.FullName); }); var fileSizeCalculator = new TransformBlock<string, KeyValuePair<string, long>>(fileName => { var fi = new FileInfo(fileName); return new KeyValuePair<string, long>(fileName, fi.Length); }); directoryBrowserBlock.LinkTo(fileSizeCalculator, new DataflowLinkOptions { PropagateCompletion = true }, File.Exists); var customBlock = DataflowBlock.Encapsulate(directoryBrowserBlock, fileSizeCalculator); return customBlock; }
private List<ExtendedFileInfo> GetExtendedFileInfo(DirectoryInfo directoryInfo) { List<ExtendedFileInfo> filesToProcess = new List<ExtendedFileInfo>(); if (configuration.TagFolders.Contains(directoryInfo.Name)) { foreach (FileSystemInfo toRename in directoryInfo.EnumerateFileSystemInfos()) { filesToProcess.AddRange(GetExtendedFileInfo(toRename)); } } else { foreach (FileInfo file in directoryInfo.GetFiles("*", SearchOption.AllDirectories)) { filesToProcess.Add(GetExtendedFileInfo(file)); } } return filesToProcess; }
public string CompileFromFolder(string folder, out byte[] buffer) { var dirInfo = new DirectoryInfo(HostingEnvironment.MapPath(folder)); if (!dirInfo.Exists) { buffer = new byte[0]; return "Pasta {0} não encontada".Fmt(folder); } Dictionary<string, string> source = new Dictionary<string, string>(); foreach (var file in dirInfo.EnumerateFileSystemInfos("*.cs", SearchOption.AllDirectories)) { var src = File.ReadAllText(file.FullName); source.Add(file.Name, src); } return CompileFromSource(source, out buffer); }
private void sendFolder(string path) { string head, body, html, pathFromRoot = path.Substring(ServerInstance.WebRoot.Length); if (pathFromRoot.Equals("/")) { pathFromRoot = ""; } head = @"<head><title>" + pathFromRoot + @"</title></head>"; body = @"<body><lu>"; DirectoryInfo dirInfo = new DirectoryInfo(path); FileSystemInfo[] fileSystemInfos = dirInfo.EnumerateFileSystemInfos().ToArray(); foreach (FileSystemInfo info in fileSystemInfos) { body += @"<li><a href='" + pathFromRoot + "/" + info.Name + @"'>" + info.Name + @"</a></li>"; } body += @"</lu></body>"; html = @"<html>" + head + body + @"</html>"; sendHTMLString(html, 200, "OK"); }
/// <summary>Delete the associated test directory.</summary> protected virtual void Dispose(bool disposing) { try { try { Directory.Delete(TestDirectory, recursive: true); } catch (UnauthorizedAccessException) { DirectoryInfo di = new DirectoryInfo(TestDirectory); foreach (FileSystemInfo fsi in di.EnumerateFileSystemInfos("*", SearchOption.AllDirectories)) { fsi.Attributes = FileAttributes.Normal; } Directory.Delete(TestDirectory, recursive: true); } } catch { } // avoid exceptions escaping Dispose }
public static IEnumerable <FileInfo> EnumerateAllFiles(this DirectoryInfo directory) { if (directory != null) { foreach (FileSystemInfo item in directory.EnumerateFileSystemInfos()) { DirectoryInfo directoryInfo = item as DirectoryInfo; if (directoryInfo != null) { foreach (var fileinfo in directoryInfo.EnumerateAllFiles()) { yield return(fileinfo); } } else if (item is FileInfo) { yield return(item as FileInfo); } } } }
/// <summary> /// /// </summary> private void CheckRemoveOldFiles() { System.IO.DirectoryInfo dinfo = new System.IO.DirectoryInfo(mLogDirector); Dictionary <DateTime, string> logFiles = new Dictionary <DateTime, string>(); if (dinfo.Exists) { foreach (var vv in dinfo.EnumerateFileSystemInfos()) { string sfileName = vv.Name; DateTime dt = new DateTime(int.Parse(sfileName.Substring(0, 4)), int.Parse(sfileName.Substring(4, 2)), int.Parse(sfileName.Substring(6, 2)), int.Parse(sfileName.Substring(8, 2)), int.Parse(sfileName.Substring(10, 2)), int.Parse(sfileName.Substring(12, 2))); if (!logFiles.ContainsKey(dt)) { logFiles.Add(dt, vv.FullName); } } } if (logFiles.Count > 6) { foreach (var vv in logFiles.OrderBy(e => e.Key).Take(5)) { if (System.IO.File.Exists(vv.Value)) { try { if (System.IO.File.GetAttributes(vv.Value) != FileAttributes.ReadOnly) { System.IO.File.Delete(vv.Value); } } catch { } } } } }
public static void EnumFiles(this DirectoryInfo directory, Func <FileInfo, bool> action) { if (directory != null) { foreach (FileSystemInfo item in directory.EnumerateFileSystemInfos()) { DirectoryInfo directoryInfo = item as DirectoryInfo; if (directoryInfo != null) { directoryInfo.EnumFiles(action); } else { bool?continu = action?.Invoke(item as FileInfo); if (continu != true) { break; } } } } }
public IEnumerable <IFileSystemInfo> EnumerateFileSystemInfos() { return(_inner.EnumerateFileSystemInfos().Select(Wrap).WhereNotNull()); }
private static void DoGetFileSystemInfos_Delete() { String chkptFlag = "chkpt_dgim_"; int failCount = 0; s_utils.CreateTestDirs(); // directoryinfo DirectoryInfo di = new DirectoryInfo(s_utils.testDir); IEnumerable<FileSystemInfo> fis = di.EnumerateFileSystemInfos("*", SearchOption.AllDirectories); HashSet<String> disAsHS = new HashSet<string>(); int count = 0; try { foreach (FileSystemInfo d in fis) { disAsHS.Add(d.FullName); count++; if (count == 2) s_utils.ChangeFSDelete(); } if (!disAsHS.SetEquals(new HashSet<String>(s_utils.expected_Dirs_Changed.Union(s_utils.expected_Files_Changed)))) { failCount++; Console.WriteLine(chkptFlag + "1: didn't get expected files...."); foreach (FileSystemInfo f in fis) { Console.WriteLine(f.Name); } } } catch (Exception ex) { failCount++; Console.WriteLine(chkptFlag + "2: got wrong exception"); Console.WriteLine(ex); } String testName = "deleteFilesWhileEnumerating"; s_utils.PrintTestStatus(testName, "DirectoryInfo.EnumerateFileSystemInfos", failCount); }
private static void TestGetFileSystemInfosFast(String path, String pattern, String testDescription, Exception expectedException) { int failCount = 0; String chkptFlag = "chkpt_spgfse_"; String methodName = "DirectoryInfo.EnumerateFileSystemInfos"; try { DirectoryInfo di = new DirectoryInfo(path); IEnumerable<FileSystemInfo> dirs1 = di.EnumerateFileSystemInfos(pattern); Console.WriteLine(chkptFlag + "1: didn't throw"); failCount++; } catch (Exception e) { if (e.GetType() != expectedException.GetType()) { failCount++; Console.WriteLine(chkptFlag + "2: threw wrong exception"); Console.WriteLine(e); } } try { DirectoryInfo di = new DirectoryInfo(path); IEnumerable<FileSystemInfo> dirs2 = di.EnumerateFileSystemInfos(pattern, SearchOption.AllDirectories); Console.WriteLine(chkptFlag + "3: didn't throw"); failCount++; } catch (Exception e) { if (e.GetType() != expectedException.GetType()) { failCount++; Console.WriteLine(chkptFlag + "4: threw wrong exception"); Console.WriteLine(e); } } s_utils.PrintTestStatus(testDescription, methodName, failCount); }
private static void DoDirectoryInfoGetFileSystemInfosTest(String path, String searchPattern, SearchOption searchOption, HashSet<String> expected) { String chkptFlag = "chkpt_dgi1_"; int failCount = 0; // directoryinfo DirectoryInfo di = new DirectoryInfo(path); IEnumerable<FileSystemInfo> fis = di.EnumerateFileSystemInfos(searchPattern, searchOption); HashSet<String> disAsHS = new HashSet<string>(); foreach (FileSystemInfo d in fis) { disAsHS.Add(d.FullName); } if (!disAsHS.SetEquals(expected)) { failCount++; Console.WriteLine(chkptFlag + "1: didn't get expected files...."); foreach (FileSystemInfo f in fis) { Console.WriteLine(f.Name); } } String testName = String.Format("SP={0}, SO={1}", searchPattern, searchOption); s_utils.PrintTestStatus(testName, "DirectoryInfo.EnumerateFileSystemInfos", failCount); }
// From MSDN: http://msdn.microsoft.com/en-us/library/bb762914.aspx public static void CopyDirectoryRecursive(string sourceDirPath, string destinationDirPath, bool overwrite = true) { // Get the subdirectories for the specified directory. var sourceDir = new DirectoryInfo(sourceDirPath); if (!sourceDir.Exists) { throw new DirectoryNotFoundException( "Source directory does not exist or could not be found: " + sourceDirPath); } // If the destination directory doesn't exist, create it. if (!DirectoryExists(destinationDirPath)) { CreateDirectory(destinationDirPath); } // Get the files in the directory and copy them to the new location. foreach (FileSystemInfo sourceFileSystemInfo in sourceDir.EnumerateFileSystemInfos()) { var sourceFile = sourceFileSystemInfo as FileInfo; if (sourceFile != null) { string destinationFilePath = Path.Combine(destinationDirPath, sourceFile.Name); Instance.File.Copy(sourceFile.FullName, destinationFilePath, overwrite); } else { var sourceSubDir = sourceFileSystemInfo as DirectoryInfo; if (sourceSubDir != null) { // Copy sub-directories and their contents to new location. string destinationSubDirPath = Path.Combine(destinationDirPath, sourceSubDir.Name); CopyDirectoryRecursive(sourceSubDir.FullName, destinationSubDirPath, overwrite); } } } }
private static void DeleteEmptyFolders(DirectoryInfo di) { if (!di.Exists) { return; } foreach (var d in di.EnumerateDirectories()) { DeleteEmptyFolders(d); } if (!di.EnumerateFileSystemInfos().Any()) { di.Delete(); } }
/// <summary> /// Enumerates the file system infos. /// </summary> /// <param name="This">This DirectoryInfo.</param> /// <param name="mode">The recursion mode.</param> /// <param name="recursionFilter">The filter to use for recursing into sub-directories (Walks on <c>true</c>; otherwise, skips recursion).</param> /// <returns> /// The FileSystemInfos /// </returns> /// <exception cref="System.NotSupportedException">RecursionMode</exception> public static IEnumerable <FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo This, RecursionMode mode, Func <DirectoryInfo, bool> recursionFilter = null) { switch (mode) { case RecursionMode.ToplevelOnly: { #if NET40 foreach (var result in This.EnumerateFileSystemInfos()) #else foreach (var result in This.GetFileSystemInfos()) #endif { yield return(result); } break; } case RecursionMode.ShortestPathFirst: { var results = new Queue <DirectoryInfo>(); results.Enqueue(This); while (results.Any()) { var result = results.Dequeue(); #if NET40 foreach (var fsi in result.EnumerateFileSystemInfos()) { #else foreach (var fsi in result.GetFileSystemInfos()) { #endif yield return(fsi); var di = fsi as DirectoryInfo; if (di == null) { continue; } if (recursionFilter == null || recursionFilter(di)) { results.Enqueue(di); } } } break; } case RecursionMode.DeepestPathFirst: { var results = new Stack <DirectoryInfo>(); results.Push(This); while (results.Any()) { var result = results.Pop(); #if NET40 foreach (var fsi in result.EnumerateFileSystemInfos()) { #else foreach (var fsi in result.GetFileSystemInfos()) { #endif yield return(fsi); var di = fsi as DirectoryInfo; if (di == null) { continue; } if (recursionFilter == null || recursionFilter(di)) { results.Push(di); } } } break; } default: { throw new NotSupportedException(nameof(RecursionMode)); } } }
public IEnumerable <IFileSystemInfo> EnumerateFileSystemInfos() { return(inner.EnumerateFileSystemInfos().Select(Wrap)); }
/// <summary> /// Enumerate a directory at the given path, if any. /// </summary> /// <param name="subpath">A path under the root directory</param> /// <returns>Contents of the directory. Caller must check Exists property.</returns> public IDirectoryContents GetDirectoryContents(string subpath) { try { if (subpath == null) { return new NotFoundDirectoryContents(); } // Relative paths starting with a leading slash okay if (subpath.StartsWith("/", StringComparison.Ordinal)) { subpath = subpath.Substring(1); } // Absolute paths not permitted. if (Path.IsPathRooted(subpath)) { return new NotFoundDirectoryContents(); } var fullPath = GetFullPath(subpath); if (fullPath != null) { var directoryInfo = new DirectoryInfo(fullPath); if (!directoryInfo.Exists) { return new NotFoundDirectoryContents(); } var physicalInfos = directoryInfo .EnumerateFileSystemInfos() .Where(info => !FileSystemInfoHelper.IsHiddenFile(info)); var virtualInfos = new List<IFileInfo>(); foreach (var fileSystemInfo in physicalInfos) { var fileInfo = fileSystemInfo as FileInfo; if (fileInfo != null) { virtualInfos.Add(new PhysicalFileInfo(_filesWatcher, fileInfo)); } else { virtualInfos.Add(new PhysicalDirectoryInfo((DirectoryInfo)fileSystemInfo)); } } return new EnumerableDirectoryContents(virtualInfos); } } catch (DirectoryNotFoundException) { } catch (IOException) { } return new NotFoundDirectoryContents(); }
/// <summary> /// Returns an enumerable collection of file system information in the current /// directory. /// </summary> /// <returns> /// An enumerable collection of file system information in the current directory. /// </returns> /// <exception cref=" <exception cref="System.IO.DirectoryNotFoundException">"> /// The path encapsulated in the System.IO.FileSystemInfo object is invalid (for /// example, it is on an unmapped drive). /// </exception> /// <exception cref="System.Security.SecurityException"> /// The caller does not have the required permission. /// </exception> public IEnumerable <FileSystemInfo> EnumerateFileSystemInfos() { return(_directoryInfo.EnumerateFileSystemInfos()); }