/// <summary> /// Determines whether specified dir looks like a Ignite home. /// </summary> /// <param name="dir">Directory.</param> /// <returns>Value indicating whether specified dir looks like a Ignite home.</returns> private static bool IsIgniteHome(DirectoryInfo dir) { return dir.Exists && (dir.EnumerateDirectories().Count(x => x.Name == "examples" || x.Name == "bin") == 2 && dir.EnumerateDirectories().Count(x => x.Name == "modules" || x.Name == "platforms") == 1) || // NuGet home (dir.EnumerateDirectories().Any(x => x.Name == "Libs") && (dir.EnumerateFiles("Apache.Ignite.Core.dll").Any() || dir.EnumerateFiles("Apache.Ignite.*.nupkg").Any())); }
public static void Main(string[] args) { var statistics = new Dictionary<string, int>(); IImageBinarizer binarizer = new ImageBinarizer(); var directoryInfo = new DirectoryInfo(Environment.CurrentDirectory).Parent.Parent.Parent; var path = Path.Combine(directoryInfo.FullName, Program.DataDirectoryName); directoryInfo = new DirectoryInfo(path); var imageClassifier = new ImageClassifier(binarizer, Program.Size * Program.Size); //Train foreach (DirectoryInfo directory in directoryInfo.EnumerateDirectories()) { foreach (var file in directory.EnumerateFiles("*.bmp")) { string fileName = Path.GetFileNameWithoutExtension(file.FullName); imageClassifier.Train(new ImageUnit { Id = fileName, Image = new Bitmap(file.FullName) }); } } foreach (DirectoryInfo directory in directoryInfo.EnumerateDirectories()) { foreach (var file in directory.EnumerateFiles("*.bmp")) { string fileName = Path.GetFileNameWithoutExtension(file.FullName); var patternDirectory = directory.EnumerateDirectories().FirstOrDefault(p => p.Name == ("Randomized_" + fileName)); foreach (var patternFile in patternDirectory.EnumerateFiles("*.bmp")) { string patternFileName = Path.GetFileNameWithoutExtension(patternFile.FullName); string[] nameParts = patternFileName.Split(new[] { "_" }, StringSplitOptions.RemoveEmptyEntries); string percentValue = nameParts[1]; if (statistics.ContainsKey(percentValue) == false) { statistics.Add(percentValue, 0); } string classificationResult = imageClassifier.Classify(new Bitmap(patternFile.FullName)); if (classificationResult.Equals(fileName, StringComparison.CurrentCulture)) { statistics[percentValue] += 1; } } } } Console.WriteLine("Classification result: "); foreach (var statistic in statistics) { Console.WriteLine("Percent - {0} Match - {1}", statistic.Key, statistic.Value); } Console.ReadLine(); }
public IObservable<FileSystemEntity> Iterate(string directoryFullName) { DirectoryInfo entry = new DirectoryInfo(directoryFullName); //Create a new data stream of FileSystemEntities (becoming our core data stream) var observableFileSystemEntities = Observable.Empty<FileSystemEntity>(); //Create a new data stream of DirectoryInfos from the command root directory var observableDirectories = entry.EnumerateDirectories("*", SearchOption.AllDirectories).ToObservable(); //Create a new data stream of FileSystemEntities based on the files laying inside the command root top level directory var observableFirstLevelFiles = entry.EnumerateFiles("*", SearchOption.TopDirectoryOnly) .ToObservable() .Select(x => new FileSystemEntity(x)); //merge previous data stream into our core data stream of FileSystemEntities observableFileSystemEntities = observableFileSystemEntities.Merge(observableFirstLevelFiles); //Based on our stream of DirectoryInfos, project it into a stream of FileSystemEntities and merge it //into our core data stream observableFileSystemEntities = observableFileSystemEntities.Merge(observableDirectories.Select(x => new FileSystemEntity(x))); //Based on our stream of DirectoryInfos, project each stream of FileInfos into a flat stream //of FileInfos, project this into a stream of FileSystemEntities and merge it into our core stream var observableFiles = observableDirectories.SelectMany(x => x.EnumerateFiles().ToObservable()).Select(x => new FileSystemEntity(x)); observableFileSystemEntities = observableFileSystemEntities.Merge(observableFiles); //return our core data stream return observableFileSystemEntities; }
/// <summary> /// Alls this instance. /// </summary> /// <returns></returns> public IEnumerable<DataModel.Release> All() { DirectoryInfo dir = new DirectoryInfo(Utilities.PathUtilities.MapPath(_configurationManager.HoardeBaseDirectory)); return dir.EnumerateDirectories("*", SearchOption.TopDirectoryOnly).Select(x => { string version = ""; var versionMatches = VERSION_PARSER.Match(x.Name); if (versionMatches.Success) { var matchedVersion = versionMatches.Groups[0]; version = matchedVersion.Value; } return new DataModel.Release { CreatedOn = DateTime.Now, Description = x.Name, Id = x.Name.Replace(version, string.Empty).Trim('.'), Version = version.Trim('.'), UpdatedOn = DateTime.Now, Title = x.Name, Summary = string.Empty, IconUrl = string.Empty, Listed = true, Published = DateTime.Now, ReleaseNotes = string.Empty, SHA1 = string.Empty, Tags = string.Empty }; }) .Where(r => !r.Id.Equals(DreyConstants.ConfigurationPackageName, StringComparison.OrdinalIgnoreCase)); }
/// <summary> /// Recurse into the directory structure looking for files which need compiler directives to ignore XML comment violations. /// </summary> /// <param name="directoryInfo">The current directory level.</param> private void RecurseIntoDirectory(DirectoryInfo directoryInfo) { // This is the recursion part. Look into every subdirectory at the current level for files that need the compiler directive. foreach (DirectoryInfo subDirectoryInfo in directoryInfo.EnumerateDirectories()) { this.RecurseIntoDirectory(subDirectoryInfo); } // At the current directory level, look for intermediate files and add the directive that will inhibit the check for comments. foreach (FileInfo fileInfo in directoryInfo.EnumerateFiles(IgnoreGeneratedFilesBuildTask.SearchPattern)) { // Read the entire file into a string buffer. string fileContent = File.ReadAllText(fileInfo.FullName); // Don't add the pragma if the code has already been modified. if (!fileContent.StartsWith("#pragma warning disable 1591", StringComparison.Ordinal)) { // If this module has been auto-generated (and hasn't already been modified), then add the directives at the start and end of the // document that will prevent any documentation errors from kicking out of the analyzer. if (fileContent.Contains("<auto-generated>")) { fileContent = "#pragma warning disable 1591\n" + fileContent + "#pragma warning restore 1591"; File.WriteAllText(fileInfo.FullName, fileContent); } } } }
public static void Visit(IFileSystemVisitor visitor, DirectoryInfo folder, bool recurse) { if (Visit(visitor, folder)) { FileInfo[] fileitems; DirectoryInfo[] diritems; //try //{ fileitems = folder.EnumerateFiles().ToArray(); diritems = (recurse) ? folder.EnumerateDirectories().ToArray() : null; //} //catch (Exception ex) //{ // visitor.OnException(folder, ex); // fileitems = new FileInfo[0]; // diritems = new DirectoryInfo[0]; //} foreach (var file in fileitems) { Visit(visitor, file); } Visited(visitor, folder); if (recurse) { foreach (var subfolder in diritems) { Visit(visitor, subfolder, recurse); } } } }
private void DeleteEmptyFolders(string path) { try { foreach (var folder in Directory.EnumerateDirectories(path)) { DirectoryInfo folderInfo = new DirectoryInfo(folder); foreach (var fileInfo in folderInfo.EnumerateFiles().Where(x => ext.Any(i => x.Extension != i))) { if (File.Exists(Path.Combine(path, fileInfo.Name))) File.Delete(Path.Combine(path, fileInfo.Name)); File.Move(fileInfo.FullName, Path.Combine(path, fileInfo.Name)); } if (folderInfo.EnumerateFiles().Any()) return; if (folderInfo.EnumerateDirectories().Any()) DeleteEmptyFolders(folder); Directory.Delete(folder); DeleteEmptyFolders(folder); } } catch (IOException ex) { Logger.WriteLine("An error occured while trying to delete empty folders in {0}: {1}", path, ex); } }
public static void ProcessDir(DirectoryInfo directoryInfo, string outDir) { if (!Directory.Exists(outDir)) Directory.CreateDirectory(outDir); // DirectoryInfo outDirInfo = new DirectoryInfo(outDir); // // Directories: // ObsoleteDirs obsoleteDirs = new ObsoleteDirs(outDirInfo); foreach (DirectoryInfo subDirectoryInfo in directoryInfo.EnumerateDirectories()) { obsoleteDirs.RemoveDirFromObsoleteList(subDirectoryInfo); // ProcessDir(subDirectoryInfo, Path.Combine(outDir, subDirectoryInfo.Name)); } obsoleteDirs.DeleteDirs(); // // Files: // ObsoleteFiles obsoleteFiles = new ObsoleteFiles(outDirInfo); foreach (FileInfo fileInfo in directoryInfo.EnumerateFiles()) { string outFileName = processFile(fileInfo, outDir); obsoleteFiles.RemoveFileFromObsoleteList(outFileName); } obsoleteFiles.DeleteFiles(); }
private Dictionary <DirectoryInfo, List <string> > GetItemsToProcess() { var rootDirectory = new System.IO.DirectoryInfo(_ftpFolderPath); var itemsToProcess = new Dictionary <System.IO.DirectoryInfo, List <string> >(); foreach (var leve2bDirectory in rootDirectory.EnumerateDirectories()) { if (leve2bDirectory.Name.ToLower() == _processed) { continue; } foreach (var leve3bDirectory in leve2bDirectory.EnumerateDirectories()) { foreach (var file in leve3bDirectory.EnumerateFiles(_fileTypesToEnumerate)) { if (itemsToProcess.ContainsKey(leve2bDirectory)) { itemsToProcess[leve2bDirectory].Add(file.FullName); } else { var fileList = new List <string>(); fileList.Add(file.FullName); itemsToProcess.Add(leve2bDirectory, fileList); } } } } return(itemsToProcess); }
protected DirectoryInfo GetReferenceFileDirectory(params string[] subDirectories) { var dir = new DirectoryInfo(Directory.GetCurrentDirectory()); while (dir != null) { var refDir = dir.EnumerateDirectories().FirstOrDefault(x => x.Name == "reference"); if (refDir != null) { if (subDirectories == null || subDirectories.Length == 0) dir = refDir; else { foreach (var directory in subDirectories) { if (refDir != null) refDir = refDir.EnumerateDirectories().FirstOrDefault(x => x.Name == directory); } dir = refDir; } break; } dir = dir.Parent; } return dir; }
public void GetApplicationFolderReturnsSubfolderFromVarTmpIfTmpDirIsTooLongInNonWindows() { if (!ApplicationFolderProvider.IsWindowsOperatingSystem()) { string longDirectoryName = Path.Combine(this.testDirectory.FullName, new string('A', 300)); var varTmpdir = new System.IO.DirectoryInfo(NonWindowsStorageProbePathVarTmp); // Initialize ApplicationfolderProvider var environmentVariables = new Hashtable { { "TMPDIR", longDirectoryName }, }; var provider = new ApplicationFolderProvider(environmentVariables); IPlatformFolder applicationFolder = provider.GetApplicationFolder(); // Evaluate Assert.IsNotNull(applicationFolder); Assert.IsFalse(Directory.Exists(longDirectoryName), "TEST ERROR: This directory should not be created."); Assert.IsTrue(Directory.Exists(varTmpdir.FullName), "TEST ERROR: This directory should be created."); Assert.IsTrue(varTmpdir.GetDirectories().Any(r => r.Name.Equals("Microsoft")), "TEST FAIL: TEMP subdirectories were not created"); varTmpdir.EnumerateDirectories().ToList().ForEach(d => { if (d.Name == "Microsoft") { d.Delete(true); } }); } }
public string print(string path) { if (File.Exists(path)) { StringBuilder sb = new StringBuilder(); FileAttributes fas = File.GetAttributes(path); if ((fas & FileAttributes.Directory) == FileAttributes.Directory) { DirectoryInfo di = new DirectoryInfo(path); AppendLeaf(sb, 0, di.Name); foreach (FileInfo fileInfo in di.EnumerateFiles()) { AppendLeaf(sb, 1, fileInfo.Name); } foreach (DirectoryInfo dirInfo in di.EnumerateDirectories()) { AppendLeaf(sb, 1, dirInfo.Name); } Console.WriteLine("Given path is directory"); } else { // is path to a file AppendLeaf(sb, 0, path); return sb.ToString(); } } throw new ArgumentException("No such path exists"); }
protected IEnumerable<KeyValuePair<string, IEnumerable<KeyValuePair<string, string>>>> RenderDirectoryTree(DirectoryInfo rootDirectory, DirectoryInfo currentDirectory) { return currentDirectory .EnumerateDirectories() .SelectMany(directoryInfo => RenderDirectoryTree(rootDirectory, directoryInfo)) .Concat(Enumerable.Repeat(RenderDirectoryViews(rootDirectory, currentDirectory), 1)); }
internal IEnumerable<FileInfo> GetFilesRecursive(DirectoryInfo rootDirectory) { foreach (var directory in rootDirectory.EnumerateDirectories()) { if (directory.Name.StartsWith("_")) { continue; } foreach (var file in GetFilesRecursive(directory)) { if (!file.Name.StartsWith("_")) { yield return file; } } } foreach (var file in rootDirectory.EnumerateFiles()) { if (file.Name.StartsWith("_")) continue; yield return file; } }
public override InteriorField[,] GetLayout() { OpenFileDialog openFileDialog = new OpenFileDialog(); openFileDialog.DefaultExt = "txt"; DirectoryInfo currentDir = new DirectoryInfo(Environment.CurrentDirectory); openFileDialog.InitialDirectory = (currentDir.EnumerateDirectories().FirstOrDefault(d => d.Name == DataSubdirName) ?? currentDir).FullName; if (openFileDialog.ShowDialog().GetValueOrDefault()) { this.LayoutIdentifier = openFileDialog.FileName; using (StreamReader readLines = new StreamReader(openFileDialog.OpenFile())) { List<List<InteriorField>> layout = readLines .ReadToEnd() .Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries) .Select(s => s .Select(c => this.CreateField(c)).ToList()).ToList(); int columnsCount = layout.Max(l => l.Count); InteriorField[,] result = new InteriorField[layout.Count, columnsCount]; for (int row = 0; row < layout.Count; row++) { for (int col = 0; col < layout[row].Count; col++) { result[row, col] = layout[row][col]; } } return result; } } else { return null; } }
private void BindData() { var directoryInfo = new DirectoryInfo(baseFolder); gwRepos.DataSource = directoryInfo.EnumerateDirectories(string.Format("*.{0}", Git.GIT_EXTENSION), SearchOption.AllDirectories); gwRepos.DataBind(); }
public static Tuple<DirectoryEntry, ImmutableList<ProjectEntry>> Create(DirectoryInfo dir, string relativePath) { if (relativePath == "packages") return new Tuple<DirectoryEntry, ImmutableList<ProjectEntry>>(PackagesEntry.Create(dir), null); if (relativePath != null && File.Exists(Path.Combine(dir.FullName, "project.json"))) return ProjectEntry.Create(dir, relativePath); var dirsAndProjects = from d in dir.EnumerateDirectories() where !d.IsHidden() orderby d.Name select Create(d, Path.Combine(relativePath, d.Name)); var dirs = ImmutableList.CreateBuilder<DirectoryEntry>(); var projects = ImmutableList.CreateBuilder<ProjectEntry>(); foreach (var dap in dirsAndProjects) { if (dap.Item2 != null) projects.AddRange(dap.Item2); dirs.Add(dap.Item1); } var files = from f in dir.EnumerateFiles() where !f.IsHidden() orderby f.Name select (Entry)FileEntry.Create(f, Path.Combine(relativePath, f.Name)); return new Tuple<DirectoryEntry, ImmutableList<ProjectEntry>>( new DirectoryEntry(relativePath, false, dir, dirs.ToImmutable(), files.ToImmutableList()), projects.ToImmutable()); }
public List<FileInfo> EnumerateAllJPGs(String Path) { List<FileInfo> Output = new List<FileInfo>(); #region enumerate all .jpg in ./pics DirectoryInfo diTop = new DirectoryInfo(Path); foreach (var di in diTop.EnumerateDirectories("*")) { try { foreach (var fi in di.EnumerateFiles("*", SearchOption.AllDirectories)) { try { if (fi.Extension.ToUpper() == ".JPG") Output.Add(fi); } catch (UnauthorizedAccessException UnAuthFile) { } } } catch (UnauthorizedAccessException UnAuthSubDir) { } } #endregion return Output; }
private void button2_Click(object sender, EventArgs e) { try { textBox2.Clear(); string path = textBox1.Text; if (string.IsNullOrEmpty(path) || string.IsNullOrWhiteSpace(path)) { MessageBox.Show("Hatalı Dizin Adresi / Directory Path should be checked."); } else { path.Trim(); DirectoryInfo d = new DirectoryInfo(path); IEnumerable<DirectoryInfo> fi = d.EnumerateDirectories(); textBox1.ScrollBars = ScrollBars.Vertical; foreach (var directory in fi) { DirSortProcess dp = new DirSortProcess(); textBox2.Text += directory.Name + "\r\n"; textBox2.Text += dp.GetDirections(directory.FullName); } } } catch (Exception ex) { MessageBox.Show(ex.Message); } }
private static IEnumerable<FileInfo> FindFiles(DirectoryInfo directory, Regex pattern) { if (directory.Exists) { try { return directory.EnumerateFiles("*.*") .Where(x => { try { return pattern.IsMatch(x.FullName); } catch (PathTooLongException) { } catch (UnauthorizedAccessException) { } return false; }) .Concat(directory.EnumerateDirectories().SelectMany(x => FindFiles(x, pattern))); } catch (PathTooLongException) { } catch (UnauthorizedAccessException) { } } return Enumerable.Empty<FileInfo>(); }
private void run(DirectoryInfo baseDir) { try { foreach (var file in baseDir.EnumerateFiles(fileNameTemplate)) { if (OnFoundFile != null) OnFoundFile(file); } foreach (var dir in baseDir.EnumerateDirectories()) { run(dir); } } catch (SecurityException e) { if (OnException != null) OnException(e); } catch (DirectoryNotFoundException e) { if (OnException != null) OnException(e); } catch (System.UnauthorizedAccessException e) { if (OnException != null) OnException(e); } }
public void ForceDelete(string path) { if (!Directory.Exists(path)) { return; } var baseFolder = new DirectoryInfo(path); foreach (var item in baseFolder.EnumerateDirectories("*", SearchOption.AllDirectories)) { ResetAttributes(item); } foreach (var item in baseFolder.EnumerateFiles("*", SearchOption.AllDirectories)) { ResetAttributes(item); } try { baseFolder.Delete(true); } catch (Exception exception) { Logger.LogInfrastructureError(string.Format(Messages.ErrorDirectoryDeletion, baseFolder.FullName), exception); } }
private static Dictionary<Version, string> FindPythonSdkFromDirectories(params string[] directories) { var pythonSdkMap = new Dictionary<Version, string>(); try { if (directories != null) { for (int i = 0; i < directories.Length; i++) { var rootDirectoryInfo = new DirectoryInfo(directories[i]); if (rootDirectoryInfo.Exists) { foreach (var dirInfo in rootDirectoryInfo.EnumerateDirectories()) { Version pythonUwpVersion; if (Version.TryParse(dirInfo.Name, out pythonUwpVersion)) { var prefixPath = dirInfo.GetDirectories(PythonUwpConstants.InterpreterRelativePath).FirstOrDefault(); if (prefixPath.Exists) { var targetsFile = prefixPath?.GetFiles(PythonUwpConstants.InterpreterFile).FirstOrDefault(); var libPath = prefixPath?.GetDirectories(PythonUwpConstants.InterpreterLibPath).FirstOrDefault(); if (targetsFile != null && libPath != null) { // Note, the order of discovery is important. The last one wins. pythonSdkMap[pythonUwpVersion] = prefixPath.FullName; } } } } } } } } catch (IOException) { // IOException is not critical here, just means we cannot interrogate for factories at this point } return pythonSdkMap; }
private static Model.DirectoryInfo Map(string absoluteFilePath, string rootPath) { var result = new Model.DirectoryInfo(); if (Directory.Exists(absoluteFilePath)) { var d = new System.IO.DirectoryInfo(absoluteFilePath); var r = d.FullName.RelativePath(rootPath); result.Name = d.Name; result.Path = r.ToBase64(); result.FullName = r; foreach (var f in d.EnumerateFiles()) { result.Files.Add(Map(f, rootPath)); } foreach (var enumerateDirectory in d.EnumerateDirectories()) { result.Directories.Add(Map(enumerateDirectory.FullName, rootPath)); } } else { var f = new System.IO.FileInfo(absoluteFilePath); result.Files.Add(Map(f, rootPath)); } return(result); }
public void GIVEN__FilesAreCreatedOnDisk__WHEN__RootFtpFolderIsEnumerated__THEN__FilesToProcessAreDiscovered() { //Arrange string rootPath = @"C:\Users\Dave\Documents\Visual Studio 2013\Projects\XMLFeedImporter\XMLFeedImporter\ftp"; var rootDirectory = new System.IO.DirectoryInfo(rootPath); var subDirectoryFiles = new List <string>(); bool filesToProcessDiscovered = false; //Act foreach (var leve2bDirectory in rootDirectory.EnumerateDirectories()) { foreach (var leve3bDirectory in leve2bDirectory.EnumerateDirectories()) { foreach (var file in leve3bDirectory.EnumerateFiles("*.xml")) { subDirectoryFiles.Add(file.FullName); } } } filesToProcessDiscovered = subDirectoryFiles.Count() > 0; //Assert Assert.IsTrue(filesToProcessDiscovered); }
//main function, returns the XML of a entire directory (subdirectories included) internal static XElement GetDirectoryXml(String dir, string[] fileExtensions) { //Create DirectoryInfo DirectoryInfo Dir = new DirectoryInfo(dir); //Will be used to store the bad files List<FileInfo> BadFiles = new List<FileInfo>(); //Will be used to store the processed files List<FileInfo> AlreadyProcessedFiles = new List<FileInfo>(); //Mandatory to avoid invalid xml var info = new XElement("Root"); //Gather file information ComputeFileInfo(Dir.EnumerateFiles().Where(f => fileExtensions.Contains(f.Extension.ToLower())).ToArray(), ref info, BadFiles, AlreadyProcessedFiles, fileExtensions); foreach (var subDir in Dir.EnumerateDirectories()) { info.Add(GetDirectoryXml(subDir.FullName, fileExtensions)); } return info; }
public static void ClearDirectory(string dir) { try { if (string.IsNullOrWhiteSpace(dir)) { return; } DirectoryInfo di = new DirectoryInfo(dir); if (!di.Exists) { return; } foreach (var item in di.EnumerateDirectories()) { //item.Delete(true); DeleteDirectoryCheck(item.FullName); } foreach (var item in di.EnumerateFiles()) { //item.Delete(); DeleteFileCheck(item.FullName); } } catch(Exception ex) { System.Diagnostics.Debug.Assert(false); _logger.Error(null, ex); } }
private static void PrepareDirectory(DirectoryInfo sourcePath, DirectoryInfo targetPath) { if (!sourcePath.Exists) { throw new DirectoryNotFoundException("Source directory " + sourcePath.FullName + " does not exist."); } targetPath.Create(); foreach (var file in sourcePath.EnumerateFiles()) { var overwrite = !file.Extension.Equals("yml", StringComparison.OrdinalIgnoreCase); var target = Path.Combine(targetPath.FullName, file.Name); // If file exists and should not be directly overwritten, just remember the user to manually update the file as needed. if (File.Exists(target) && !overwrite) { var oldTarget = target; target += ".dist"; Console.Error.WriteLine( "WARNING: File {0} needs a manual update! Compare with {1} and rewrite your file.", oldTarget, target); } file.CopyTo(target, overwrite); } foreach (var subdirectory in sourcePath.EnumerateDirectories()) { PrepareDirectory(subdirectory, targetPath.CreateSubdirectory(subdirectory.Name)); } }
/// <summary> /// Downloads one or more packages. /// </summary> /// <param name="packageContainer"> /// The packageto downloaded. /// </param> /// <param name="repositoryDirectory"> /// The directory to which to download the packages. /// </param> /// <param name="overwrite"> /// If set to <see langword="true"/>, any existing directory will be deleted. /// </param> /// <returns> /// A <see cref="Task"/> that represents the asynchronous operation /// </returns> public static async Task<DirectoryInfo> DownloadAndExtract(IArchiveContainer packageContainer, DirectoryInfo repositoryDirectory, bool overwrite) { // Create the directory into which to extract string directoryName = $"{packageContainer.Name}-{packageContainer.Revision}"; // Figure out whether that directory already exists. DirectoryInfo targetDirectory; targetDirectory = repositoryDirectory.EnumerateDirectories(directoryName).SingleOrDefault(); // If it does, proceed based on the value of the overwrite flag if (targetDirectory != null) { if (overwrite) { // Delete the directory & proceed as usual. targetDirectory.Delete(true); targetDirectory = null; } else { // Nothing left to do. return targetDirectory; } } targetDirectory = repositoryDirectory.CreateSubdirectory(directoryName); foreach (var package in packageContainer.Archives) { Console.WriteLine($"Downloading package {package.Url} for {package.HostOs}"); await package.DownloadAndExtract(targetDirectory); } return targetDirectory; }
private static void FindAllFoldersAndFiles(DirectoryInfo di, Folder root) { try { var files = di.EnumerateFiles(); foreach (var file in files) { var currentFile = new File(file.Name, file.Length); root.Files.Add(currentFile); } var folders = di.EnumerateDirectories(); foreach (var folder in folders) { var currentFolder = new Folder(folder.Name); root.ChildFolders.Add(currentFolder); FindAllFoldersAndFiles(folder, currentFolder); } } catch (UnauthorizedAccessException e) { Console.WriteLine(e.Message); } }
private static async Task ServeDirectoryListingAsync(DirectoryInfo root, DirectoryInfo directory, HttpListenerResponse response) { StringBuilder listBuilder = new StringBuilder(); foreach (FileInfo file in directory.EnumerateFiles()) { String target = directory.IsSameDirectory(root) ? file.Name : Path.Combine(directory.Name, file.Name); listBuilder.AppendFormat("<li><a href=\"{0}\">{1}</a></li>", target, file.Name); } foreach (DirectoryInfo subDirectory in directory.EnumerateDirectories()) { String target = directory.IsSameDirectory(root) ? subDirectory.Name : Path.Combine(directory.Name, subDirectory.Name); listBuilder.AppendFormat("<li><a href=\"{0}\">{1}</a></li>", target, subDirectory.Name); } String htmlResponse = String.Format("<ul>{0}</ul>", listBuilder.ToString()); response.ContentType = "text/html"; response.ContentLength64 = htmlResponse.Length; response.AddHeader("Date", DateTime.Now.ToString("r")); response.StatusCode = (Int32)HttpStatusCode.OK; // Must be set before writing to OutputStream. using (StreamWriter writer = new StreamWriter(response.OutputStream)) { await writer.WriteAsync(htmlResponse).ConfigureAwait(false); } }
public Form1() { InitializeComponent(); //カレントディレクトリ内のフォルダ列挙 System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(System.IO.Directory.GetCurrentDirectory()); IEnumerable <System.IO.DirectoryInfo> files = di.EnumerateDirectories("*", System.IO.SearchOption.TopDirectoryOnly); //ファイルを列挙する foreach (System.IO.DirectoryInfo f in files) { systemList.Items.Add(f.Name); } StreamReader sr = new StreamReader(Directory.GetCurrentDirectory() + "/" + "SystemFolder" + "/" + "system.txt", Encoding.GetEncoding("Shift_JIS")); string str = sr.ReadToEnd(); sr.Close(); for (int no = 0; no < colorMode.Items.Count; no++) { if (str == colorMode.Items[no].ToString()) { colorMode.SelectedIndex = no; break; } } isEdit = true; }
private void RecurseChildDirectories(DirectoryInfo directory, List<FileInfo> files) { foreach (DirectoryInfo dir in directory.EnumerateDirectories()) { files.AddRange(GetProjectFiles(dir)); } }
public static JObject Browse(string path = null) { if (path == null) path = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments); var dir = new DirectoryInfo(path); var dirs = from d in dir.EnumerateDirectories() select new JObject( new JProperty("name", new JValue(d.Name)), new JProperty("type", new JValue("dir")), new JProperty("path", new JValue(d.FullName)) ); var files = from f in dir.EnumerateFiles() select new JObject( new JProperty("name", new JValue(f.Name)), new JProperty("type", new JValue("file")), new JProperty("path", new JValue(f.FullName)) ); if (dir.Parent != null) dirs = new[] { new JObject( new JProperty("name", new JValue("..")), new JProperty("type", new JValue("dir")), new JProperty("path", new JValue(dir.Parent.FullName)) ) }.Concat(dirs); return new JObject( new JProperty("name", new JValue("browse")), new JProperty("title", new JValue("Open project")), new JProperty("path", new JValue(path)), new JProperty("folders", new JArray(dirs.ToArray())), new JProperty("files", new JArray(files.ToArray())) ); }
private void EnumerateFilesRecursiveAsync(DirectoryInfo folder, AccountFile destDirectory, AsyncTask task, CancellationToken token) { foreach (var file in folder.EnumerateFiles()) { if (token.IsCancellationRequested) return; //var newTask = task == null // ? new UploadFileTask(Account, AccountName, 0, null, file.FullName, destDirectory) // : new UploadFileTask(Account, AccountName, 0, new[] { task }, file.FullName, null); var newTask = new UploadFileTask(Account, AccountName, 0, new[] { task }, file.FullName, null); AddTask(newTask); lastTask.AddParent(newTask); } foreach (var dir in folder.EnumerateDirectories()) { if (token.IsCancellationRequested) return; //var newTask = task == null // ? new CreateFolderTask(Account, AccountName, 0, null, dir.Name, destDirectory) // : new CreateFolderTask(Account, AccountName, 0, new[] { task }, dir.Name, null); var newTask = new CreateFolderTask(Account, AccountName, 0, new[] { task }, dir.Name, null); AddTask(newTask); lastTask.AddParent(newTask); EnumerateFilesRecursiveAsync(dir, destDirectory, newTask, token); } OnProgress(new AsyncTaskProgressEventArgs(0, null)); }
private void ProcessDirectory(LocalDirectory parentDirectory, IO.DirectoryInfo directoryInfo) { if (parentDirectory == null) { throw new ArgumentNullException(nameof(parentDirectory)); } if (directoryInfo == null) { throw new ArgumentNullException(nameof(directoryInfo)); } try { LocalDirectory directory = (LocalDirectory)parentDirectory.GetSubdirectory(directoryInfo.Name); if (directory == null) { directory = parentDirectory.CreateSubDirectory(directoryInfo.Name, directoryInfo.FullName); } foreach (var fileInfo in directoryInfo.EnumerateFiles().Where(f => !f.Name.StartsWith("."))) { IndexingFile?.Invoke(this, new FilenameEventArgs(fileInfo.FullName)); LocalFile file = (LocalFile)directory.GetFile(fileInfo.Name); if (file == null) { file = directory.CreateFile(fileInfo); } else { // XXX: Update file info } if (string.IsNullOrEmpty(file.InfoHash)) { this.hasher.HashFile(file); } } foreach (var subDirectoryInfo in directoryInfo.EnumerateDirectories().Where(d => !d.Name.StartsWith("."))) { //ProcessDirectory(directory, subDirectoryInfo); this.queue.Add(new QueueItem(directory, subDirectoryInfo), this.cancellation.Token); } } catch (ThreadAbortException) { // Canceled, ignore error. } catch (Exception ex) { this.loggingService.LogError("Error while re-indexing shared files:", ex); ErrorIndexing?.Invoke(this, new ErrorEventArgs(ex)); } }
private void InitPresets(string directory) { var dir = new System.IO.DirectoryInfo(Path.Combine("AppData", "Presets")); foreach (var item in dir.EnumerateDirectories()) { this.Presets.Add(new Preset(item.Name, item.FullName)); } }
public WorldLoaderState(DwarfGame Game) : base(Game) { this.ProceedButtonText = "Load"; this.NoItemsText = "No worlds found."; this.InvalidItemText = "This world was saved by an earlier version of DwarfCorp and is not compatible."; this.ValidateItem = (item) => { return(NewOverworldFile.CheckCompatibility(item) ? "" : "Incompatible save file."); }; this.GetItemName = (item) => { return(NewOverworldFile.GetOverworldName(item)); }; this.ItemSource = () => { System.IO.DirectoryInfo worldDirectory = System.IO.Directory.CreateDirectory(DwarfGame.GetWorldDirectory()); var dirs = worldDirectory.EnumerateDirectories().ToList(); dirs.Sort((a, b) => { var aMeta = a.GetFiles("meta.txt"); var bMeta = b.GetFiles("meta.txt"); if (aMeta.Length > 0 && bMeta.Length > 0) { return(bMeta[0].LastWriteTime.CompareTo(aMeta[0].LastWriteTime)); } return(b.LastWriteTime.CompareTo(a.LastWriteTime)); }); return(dirs); }; this.ScreenshotSource = (path) => { try { return(AssetManager.LoadUnbuiltTextureFromAbsolutePath(path + global::System.IO.Path.DirectorySeparatorChar + "screenshot.png")); } catch (Exception exception) { Console.Error.WriteLine(exception.ToString()); return(null); } }; this.OnProceedClicked = (path) => { var file = NewOverworldFile.Load(path); GameStateManager.PopState(); var genState = new WorldGeneratorState(Game, file.CreateSettings(), WorldGeneratorState.PanelStates.Launch); GameStateManager.PushState(genState); }; }
static void RecursiveDirectoryDelete(System.IO.DirectoryInfo baseDir) { if (!baseDir.Exists) { return; } foreach (var dir in baseDir.EnumerateDirectories()) { RecursiveDirectoryDelete(dir); } baseDir.Delete(true); }
static public int EnumerateDirectories(IntPtr l) { try { System.IO.DirectoryInfo self = (System.IO.DirectoryInfo)checkSelf(l); var ret = self.EnumerateDirectories(); pushValue(l, true); pushValue(l, ret); return(2); } catch (Exception e) { return(error(l, e)); } }
/// <summary> /// Search a directory or archive and add any files or sub-directories /// to the list of candidates currently being resolved /// </summary> /// <param name="candidates">Candidates currently being resolved</param> public void Explode(SubmissionCandidates candidates, string workingDirectory) { if (IsArchive) { // Archives in Archives!! if (IsArchivedFile) { string exportPath = Path.Combine(workingDirectory, HunterConfig.GalileoDefaultDataFolder + Path.DirectorySeparatorChar + "galileo_" + Guid.ToString() + FileExtension); ArchiveInfo.Extract(ReadPath, exportPath); _resolvePath = exportPath; } if (_fileType == FileTypes.Types.Zip) { _archiveInfo = new ZipArchiveInfo(ReadPath); _archiveChildren = new List <SubmissionCandidate>(10); if (_archiveInfo.IsOpen == false) { // Probably best to do something better than this? throw new Exception("Could not open archive???"); } foreach (var fileName in _archiveInfo) { SubmissionCandidate candidate = candidates.Add(fileName, _depth + 1, this); _archiveChildren.Add(candidate); } // We leave _archiveInfo open, because later the files // will want to be inspected and possibly extracted. } } else if (IsDirectory) { System.IO.DirectoryInfo info = new System.IO.DirectoryInfo(ReadPath); foreach (var file in info.EnumerateFiles()) { candidates.Add(file.FullName, _depth + 1, this); } foreach (var directory in info.EnumerateDirectories()) { candidates.Add(directory.FullName, _depth + 1, this); } } }
private void SystemList_SelectedIndexChanged(object sender, EventArgs e) { scenarioList.Items.Clear(); systemName.Text = systemList.SelectedItem.ToString(); System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(System.IO.Directory.GetCurrentDirectory() + "/" + systemName.Text); IEnumerable <System.IO.DirectoryInfo> files = di.EnumerateDirectories("*", System.IO.SearchOption.TopDirectoryOnly); //ファイルを列挙する foreach (System.IO.DirectoryInfo f in files) { scenarioList.Items.Add(f.Name); } }
public string GetFileServerProjectPath(Entity.Store store) { var programMappedPath = Configuration.ConfigHandler.InstanceOf.FileServerMappings.Where( x => x.Key == store.Program); string result = ""; foreach (var pair in programMappedPath) { var path = new System.IO.DirectoryInfo(pair.Value); Logger.LoggerAsync.InstanceOf.GeneralLogger.Info("Preparing to enumerate directories under {0} looking for {1}", path.FullName, store.ProjectNumber); try { var subFolders = path.EnumerateDirectories("*" + store.ProjectNumber + "*", System.IO.SearchOption.TopDirectoryOnly); if (subFolders.Count() > 1) { foreach (var folder in subFolders) { result = this.GetFileServerProjectPath(store); } } else if (subFolders.Count() < 1) { continue; } else { var folder = subFolders.First(); var rfi = this.FindFileServerRfi(folder); result = rfi.FullName; } } catch (Exception x) { Logger.LoggerAsync.InstanceOf.GeneralLogger.Error(x); throw x; } } this.path = result; return(result); }
static public int EnumerateDirectories__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.EnumerateDirectories(a1, a2); pushValue(l, true); pushValue(l, ret); return(2); } catch (Exception e) { return(error(l, e)); } }
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 }
private System.IO.DirectoryInfo ClearTempFolder() { System.IO.DirectoryInfo tempDirectory = new System.IO.DirectoryInfo(System.IO.Path.Combine(ResourceManager.Root, "temp")); if (!tempDirectory.Exists) { tempDirectory.Create(); } foreach (System.IO.DirectoryInfo directory in tempDirectory.EnumerateDirectories()) { try { directory.Delete(true); } catch (System.Exception ex_50) { } } return(tempDirectory); }
public void GetApplicationFolderReturnsSubfolderFromVarTmpFolderIfTmpDirIsNotAvailableInNonWindows() { if (!ApplicationFolderProvider.IsWindowsOperatingSystem()) { var dir = new System.IO.DirectoryInfo(NonWindowsStorageProbePathVarTmp); var provider = new ApplicationFolderProvider(); IPlatformFolder applicationFolder = provider.GetApplicationFolder(); Assert.IsNotNull(applicationFolder); Assert.IsTrue(dir.GetDirectories().Any(r => r.Name.Equals("Microsoft"))); dir.EnumerateDirectories().ToList().ForEach(d => { if (d.Name == "Microsoft") { d.Delete(true); } }); } }
private System.IO.DirectoryInfo FindFileServerRfi(System.IO.DirectoryInfo folder) { try { var rfiFolder = folder.EnumerateDirectories("*RFI*"); if (rfiFolder.Count() > 1) { var ex = new ArgumentOutOfRangeException("FindFileServerRfi", "There cannot be more than one RFI folder per project"); Logger.LoggerAsync.InstanceOf.GeneralLogger.Error("Error at FindFileServerRfi {0}", ex); throw ex; } return(rfiFolder.FirstOrDefault()); } catch (Exception x) { Logger.LoggerAsync.InstanceOf.GeneralLogger.Error(x); throw x; } }
public async Task <FolderItem> GetFolderDetail(string hostUrl, string relativeFolderPath) { if (Hosts.TryGetValue(hostUrl, out var host)) { var ServiceAddress = OperationContext.Current.IncomingMessageHeaders.To; var UrlBuilder = new UriBuilder(host.UrlRoot) { Host = ServiceAddress.Host }; var folder = new System.IO.DirectoryInfo(System.IO.Path.Combine(host.LocalFilePath ?? ".", relativeFolderPath.Trim('\\', '/'))); if (folder.Exists) { var folders = folder.EnumerateDirectories() .Select(x => new FolderItem { Name = x.Name, FullPath = $"{UrlBuilder.ToString()}{relativeFolderPath}{host.DirectorySeparatorChar.ToString()}{x.Name }", RelativePath = $"{relativeFolderPath}{host.DirectorySeparatorChar.ToString()}{x.Name }", }); var files = folder.EnumerateFiles() .Select(x => new FileItem { Name = x.Name, FullPath = $"{UrlBuilder.ToString()}{relativeFolderPath}{host.DirectorySeparatorChar.ToString()}{x.Name }", RelativePath = $"{relativeFolderPath}{host.DirectorySeparatorChar.ToString()}{x.Name }", }); return(await Task.FromResult(new FolderItem { FullPath = folder.FullName, Name = folder.Name, Files = new Collection <FileItem>(files.ToList()), Folders = new Collection <FolderItem>(folders.ToList()), RelativePath = relativeFolderPath })); } } return(null); }
public void GetApplicationFolderReturnsSubfolderFromTmpFolderIfVarTmpIsNotAvailableInNonWindows() { if (!ApplicationFolderProvider.IsWindowsOperatingSystem()) { var dir = new System.IO.DirectoryInfo(NonWindowsStorageProbePathTmp); var provider = new ApplicationFolderProvider(); var vartmpPathFieldInfo = provider.GetType().GetField("nonWindowsStorageProbePathVarTmp", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance); vartmpPathFieldInfo.SetValue(provider, ""); IPlatformFolder applicationFolder = provider.GetApplicationFolder(); Assert.IsNotNull(applicationFolder); Assert.IsTrue(dir.GetDirectories().Any(r => r.Name.Equals("Microsoft"))); dir.EnumerateDirectories().ToList().ForEach(d => { if (d.Name == "Microsoft") { d.Delete(true); } }); } }
public IActionResult Index(string path = "") { path = ValidatePath(path); path = path.Replace('!', '/'); var baseDir = new System.IO.DirectoryInfo(path); var model = new RssListViewModel { CurrentDir = baseDir, Directories = baseDir.EnumerateDirectories() .Where(x => !x.Attributes.HasFlag(FileAttributes.Hidden)) .Take(100) .OrderBy(x => x.Name), Files = baseDir.EnumerateFiles() .Where(x => !x.Attributes.HasFlag(FileAttributes.Hidden)) .Take(100) .OrderBy(x => x.Name), }; model.DisplayParentLink = path != _baseDir && model.CurrentDir.Parent != null; return(View(model)); }
public IEnumerable <IDirectoryInfo> EnumerateDirectories() { return(_inner.EnumerateDirectories().Select(Wrap).WhereNotNull()); }
private Dictionary <string, string> MergeImage(System.IO.DirectoryInfo di, Guid requestId) { var resultFiles = new Dictionary <string, string>(); var resultDir = di.EnumerateDirectories($"{requestId}").FirstOrDefault(); if (resultDir != null) { foreach (var dir in resultDir.EnumerateDirectories()) { var imageFiles = dir.EnumerateFiles("*.png").ToList(); var manifestFile = dir.EnumerateFiles($@"{dir.Name}.json").FirstOrDefault(); if (imageFiles.Any() && manifestFile != null) { var ssInfo = JsonConvert.DeserializeObject <ScreenshotDetail>(System.IO.File.ReadAllText(manifestFile.FullName)); var imageInfo = imageFiles.First(); var image = System.Drawing.Image.FromFile($"{imageInfo.FullName}"); var width = image.Width; var height = image.Height; var canvasFullHeight = image.Height * imageFiles.Count; var resutingImage = new System.Drawing.Bitmap(width, canvasFullHeight, System.Drawing.Imaging.PixelFormat.Format32bppArgb); using (var g = System.Drawing.Graphics.FromImage(resutingImage)) { var index = 0; var accumulatedHeight = 0d; foreach (var imgInf in imageFiles) { var posY = index * height; var img = System.Drawing.Image.FromFile($"{imgInf.FullName}"); var advanceAccumulatedHeight = accumulatedHeight + ssInfo.WindowHeight; if (advanceAccumulatedHeight > ssInfo.DocHeight) { var ratio = height / ssInfo.WindowHeight; var offset = (ssInfo.DocHeight - accumulatedHeight) * ratio; var cropRect = new System.Drawing.Rectangle(0, (int)Math.Ceiling((offset - height) * -1), width, (int)Math.Ceiling(offset)); var cropedImg = new System.Drawing.Bitmap(cropRect.Width, cropRect.Height); using (var gc = System.Drawing.Graphics.FromImage(cropedImg)) { gc.DrawImage( img, new System.Drawing.Rectangle(0, 0, cropedImg.Width, cropedImg.Height), cropRect, System.Drawing.GraphicsUnit.Pixel); } g.DrawImage(cropedImg, new System.Drawing.Point(0, posY)); cropedImg.Dispose(); } else { g.DrawImage(img, new System.Drawing.Point(0, posY)); } img.Dispose(); index++; accumulatedHeight = advanceAccumulatedHeight; } } image.Dispose(); var filepath = $@"{di.FullName}\{dir.Name}.png"; resutingImage.Save(filepath); resutingImage.Dispose(); resultFiles.Add(dir.Name, filepath); } } } return(resultFiles); }
public IEnumerable <IDirectoryInfo> EnumerateDirectories() { return(inner.EnumerateDirectories().Select(Wrap)); }
/// <summary> /// Returns an enumerable collection of directory information in the current /// directory. /// </summary> /// <returns> /// An enumerable collection of directories in the current directory. /// </returns> /// <exception cref=" <exception cref="System.IO.DirectoryNotFoundException">"> /// The path encapsulated in the System.IO.DirectoryInfo 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 <System.IO.DirectoryInfo> EnumerateDirectories() { return(_directoryInfo.EnumerateDirectories()); }