Example #1
0
        private void UpdatePie(string rootDirectory, int depth, bool showFiles)
        {
            if (!Directory.Exists(rootDirectory) && !File.Exists(rootDirectory))
            {
                return;
            }

            var dataPoints = new FileSystemEnumerable <PieDataPoint>(rootDirectory, (ref FileSystemEntry entry) => CreateDataPoint(ref entry, depth), new EnumerationOptions()
            {
                RecurseSubdirectories = true, AttributesToSkip = 0
            })
            {
                ShouldRecursePredicate = (ref FileSystemEntry entry) => GetDepth(ref entry) < depth,
                ShouldIncludePredicate = (ref FileSystemEntry entry) => showFiles || entry.IsDirectory
            };

            if (!showFiles)
            {
                var dataPoint = new PieDataPoint(GetDirectorySize(rootDirectory, recurse: depth == 0), ".");
                dataPoint.Label = String.Empty;
                this.pieSeries.DataPoints.Add(dataPoint);
            }

            foreach (var dataPoint in dataPoints)
            {
                dataPoint.Label = String.Empty;
                this.pieSeries.DataPoints.Add(dataPoint);
            }
        }
        private void IsHiddenAttributeInternal(bool useDotPrefix, bool useHiddenFlag)
        {
            string prefix = useDotPrefix ? "." : "";

            DirectoryInfo testDirectory = Directory.CreateDirectory(GetTestFilePath());

            FileInfo fileOne = new FileInfo(Path.Combine(testDirectory.FullName, GetTestFileName()));
            FileInfo fileTwo = new FileInfo(Path.Combine(testDirectory.FullName, prefix + GetTestFileName()));

            fileOne.Create().Dispose();
            fileTwo.Create().Dispose();

            if (useHiddenFlag)
            {
                fileTwo.Attributes |= FileAttributes.Hidden;
            }

            FileInfo fileCheck = new FileInfo(fileTwo.FullName);

            Assert.Equal(fileTwo.Attributes, fileCheck.Attributes);

            IEnumerable <string> enumerable = new FileSystemEnumerable <string>(
                testDirectory.FullName,
                (ref FileSystemEntry entry) => entry.ToFullPath(),
                new EnumerationOptions()
            {
                AttributesToSkip = 0
            })
            {
                ShouldIncludePredicate = (ref FileSystemEntry entry) => entry.IsHidden
            };

            Assert.Equal(new string[] { fileTwo.FullName }, enumerable);
        }
Example #3
0
        public static async Task UploadAsync(
            string sourceDirectory,
            string destination,
            IProgress <StructuredReport> progress,
            CancellationToken cancellationToken)
        {
            var structuredProgress = progress.Start("Logging in and enumerating files");

            var((client, itemRequestBuilderFactory), files) = await(
                GetClientAndItemRequestBuilderFactoryAsync(),
                Task.Run(
                    () =>
            {
                var enumerable = new FileSystemEnumerable <EnumeratedFileData>(
                    sourceDirectory,
                    EnumeratedFileData.FromFileSystemEntry,
                    new EnumerationOptions
                {
                    AttributesToSkip      = FileAttributes.System,
                    RecurseSubdirectories = true,
                    IgnoreInaccessible    = false,
                });

                enumerable.ShouldIncludePredicate = ShouldInclude;

                return(enumerable.ToImmutableArray());
        public void IsReadOnlyAttribute()
        {
            DirectoryInfo testDirectory = Directory.CreateDirectory(GetTestFilePath());

            FileInfo fileOne = new FileInfo(Path.Combine(testDirectory.FullName, GetTestFileName()));
            FileInfo fileTwo = new FileInfo(Path.Combine(testDirectory.FullName, GetTestFileName()));

            fileOne.Create().Dispose();
            fileTwo.Create().Dispose();

            fileTwo.Attributes |= FileAttributes.ReadOnly;

            IEnumerable <string> enumerable = new FileSystemEnumerable <string>(
                testDirectory.FullName,
                (ref FileSystemEntry entry) => entry.ToFullPath(),
                new EnumerationOptions()
            {
                AttributesToSkip = 0
            })
            {
                ShouldIncludePredicate = (ref FileSystemEntry entry) => (entry.Attributes & FileAttributes.ReadOnly) != 0
            };

            Assert.Equal(new string[] { fileTwo.FullName }, enumerable);
        }
Example #5
0
        public void IsHiddenAttribute()
        {
            DirectoryInfo testDirectory = Directory.CreateDirectory(GetTestFilePath());
            FileInfo      fileOne       = new FileInfo(Path.Combine(testDirectory.FullName, GetTestFileName()));

            // Put a period in front to make it hidden on Unix
            FileInfo fileTwo = new FileInfo(Path.Combine(testDirectory.FullName, "." + GetTestFileName()));

            fileOne.Create().Dispose();
            fileTwo.Create().Dispose();
            if (PlatformDetection.IsWindows)
            {
                fileTwo.Attributes = fileTwo.Attributes | FileAttributes.Hidden;
            }

            IEnumerable <string> enumerable = new FileSystemEnumerable <string>(
                testDirectory.FullName,
                (ref FileSystemEntry entry) => entry.ToFullPath(),
                new EnumerationOptions()
            {
                AttributesToSkip = 0
            })
            {
                ShouldIncludePredicate = (ref FileSystemEntry entry) => entry.IsHidden
            };

            Assert.Equal(new string[] { fileTwo.FullName }, enumerable);
        }
Example #6
0
        public void DiscoverFiles(string directory, Action <string> action)
        {
            var enumerationOptions = new EnumerationOptions()
            {
                RecurseSubdirectories = false,
                AttributesToSkip      = FileAttributes.Directory
                                        | FileAttributes.Device | FileAttributes.Hidden
            };

            var files = new FileSystemEnumerable <FileInfo>(directory,
                                                            (ref FileSystemEntry entry) => (FileInfo)entry.ToFileSystemInfo(),
                                                            enumerationOptions)
            {
                ShouldIncludePredicate = (ref FileSystemEntry entry) =>
                                         FileHelper.IsImage(entry.FileName.ToString())
            };

            _logger.Log($"Found {files.Count()} files");

            foreach (var file in files)
            {
                _logger.Log($"Uploading {file.FullName}");
                action.Invoke(file.FullName);
            }
        }
Example #7
0
        /// <summary>
        /// loads the files contained in the current folder
        /// </summary>
        private void LoadFolderDetailGridView()
        {
            DirectoryInfo         dirInfo = new DirectoryInfo(folder);
            IEnumerable <LogFile> info    = new FileSystemEnumerable(dirInfo, "*.log", SearchOption.AllDirectories).Cast <FileInfo>().Select(a => new LogFile {
                Name = a.Name, FullPath = a.FullName, Size = a.Length
            });

            FileListGridView.ItemsSource = info.ToList <LogFile>();
        }
Example #8
0
    public IEnumerator <FileSystemInfo> GetEnumerator()
    {
        if (_root == null || !_root.Exists)
        {
            yield break;
        }

        IEnumerable <FileSystemInfo> matches = new List <FileSystemInfo>();

        try
        {
            //_logger.DebugFormat("Attempting to enumerate '{0}'", _root.FullName);
            matches = _patterns.Aggregate(matches, (current, pattern) => current.Concat(_root.EnumerateDirectories(pattern, SearchOption.TopDirectoryOnly))
                                          .Concat(_root.EnumerateFiles(pattern, SearchOption.TopDirectoryOnly)));
        }
        catch (UnauthorizedAccessException)
        {
            //_logger.WarnFormat("Unable to access '{0}'. Skipping...", _root.FullName);
            yield break;
        }
        catch (PathTooLongException)
        {
            //_logger.Warn(string.Format(@"Could not process path '{0}\{1}'.", _root.Parent.FullName, _root.Name), ptle);
            yield break;
        }
        catch (System.IO.IOException)
        {
            // "The symbolic link cannot be followed because its type is disabled."
            // "The specified network name is no longer available."
            //_logger.Warn(string.Format(@"Could not process path (check SymlinkEvaluation rules)'{0}\{1}'.", _root.Parent.FullName, _root.Name), e);
            yield break;
        }


        //_logger.DebugFormat("Returning all objects that match the pattern(s) '{0}'", string.Join(",", _patterns));
        foreach (var file in matches)
        {
            yield return(file);
        }

        if (_option != SearchOption.AllDirectories)
        {
            yield break;
        }

        //_logger.DebugFormat("Enumerating all child directories.");
        foreach (var dir in _root.EnumerateDirectories("*", SearchOption.TopDirectoryOnly))
        {
            //_logger.DebugFormat("Enumerating '{0}'", dir.FullName);
            var fileSystemInfos = new FileSystemEnumerable(dir, _patterns, _option);
            foreach (var match in fileSystemInfos)
            {
                yield return(match);
            }
        }
    }
Example #9
0
    public IEnumerator <FileSystemInfo> GetEnumerator()
    {
        if (_root == null || !_root.Exists)
        {
            yield break;
        }

        IEnumerable <FileSystemInfo> matches = new List <FileSystemInfo>();

        try
        {
            _logger.DebugFormat("Attempting to enumerate '{0}'", _root.FullName);
            foreach (var pattern in _patterns)
            {
                _logger.DebugFormat("Using pattern '{0}'", pattern);
                matches = matches.Concat(_root.EnumerateDirectories(pattern, SearchOption.TopDirectoryOnly))
                          .Concat(_root.EnumerateFiles(pattern, SearchOption.TopDirectoryOnly));
            }
        }
        catch (UnauthorizedAccessException)
        {
            _logger.WarnFormat("Unable to access '{0}'. Skipping...", _root.FullName);
            yield break;
        }
        catch (PathTooLongException ptle)
        {
            _logger.Warn(string.Format(@"Could not process path '{0}\{1}'.", _root.Parent.FullName, _root.Name), ptle);
            yield break;
        }

        _logger.DebugFormat("Returning all objects that match the pattern(s) '{0}'", string.Join(",", _patterns));
        foreach (var file in matches)
        {
            yield return(file);
        }

        if (_option == SearchOption.AllDirectories)
        {
            _logger.DebugFormat("Enumerating all child directories.");
            foreach (var dir in _root.EnumerateDirectories("*", SearchOption.TopDirectoryOnly))
            {
                _logger.DebugFormat("Enumerating '{0}'", dir.FullName);
                var fileSystemInfos = new FileSystemEnumerable(dir, _patterns, _option);
                foreach (var match in fileSystemInfos)
                {
                    yield return(match);
                }
            }
        }
    }
Example #10
0
        public void EnumerateFileSystemEntries_LinksWithCycles_ShouldNotThrow()
        {
            DirectoryInfo testDirectory = CreateDirectoryContainingSelfReferencingSymbolicLink();

            IEnumerable <string> enumerable = new FileSystemEnumerable <string>(
                testDirectory.FullName,
                (ref FileSystemEntry entry) => entry.ToFullPath(),
                // Skipping attributes would force a disk hit which enters the cyclic symlink
                new EnumerationOptions()
            {
                AttributesToSkip = 0
            });

            Assert.Single(enumerable);
        }
        public void GetFileNamesEnumerable()
        {
            DirectoryInfo testDirectory = Directory.CreateDirectory(GetTestFilePath());

            File.Create(Path.Join(testDirectory.FullName, "one")).Dispose();
            File.Create(Path.Join(testDirectory.FullName, "two")).Dispose();
            Directory.CreateDirectory(Path.Join(testDirectory.FullName, "three"));

            IEnumerable <string> fileNames =
                new FileSystemEnumerable <string>(
                    testDirectory.FullName,
                    (ref FileSystemEntry entry) => entry.FileName.ToString())
            {
                ShouldIncludePredicate = (ref FileSystemEntry entry) => !entry.IsDirectory
            };

            FSAssert.EqualWhenOrdered(new string[] { "one", "two" }, fileNames);
        }
Example #12
0
        public void GetFileNamesEnumerable()
        {
            // https://blogs.msdn.microsoft.com/jeremykuhne/2018/03/09/custom-directory-enumeration-in-net-core-2-1/
            DirectoryInfo testDirectory = Directory.CreateDirectory(GetTestFilePath());

            File.Create(Path.Join(testDirectory.FullName, "one")).Dispose();
            File.Create(Path.Join(testDirectory.FullName, "two")).Dispose();
            Directory.CreateDirectory(Path.Join(testDirectory.FullName, "three"));

            IEnumerable <string> fileNames =
                new FileSystemEnumerable <string>(
                    testDirectory.FullName,
                    (ref FileSystemEntry entry) => entry.FileName.ToString())
            {
                ShouldIncludePredicate = (ref FileSystemEntry entry) => !entry.IsDirectory
            };

            FSAssert.EqualWhenOrdered(new string[] { "one", "two" }, fileNames);
        }
Example #13
0
    public IEnumerator <string> GetEnumerator()
    {
        if (_root == null || !Directory.Exists(_root))
        {
            yield break;
        }

        IEnumerable <string> matches = new List <string>();

        try
        {
            foreach (string pattern in _patterns)
            {
                matches = matches.Concat(Directory.EnumerateDirectories(_root, pattern, SearchOption.TopDirectoryOnly))
                          .Concat(Directory.EnumerateFiles(_root, pattern, SearchOption.TopDirectoryOnly));
            }
        }
        catch (UnauthorizedAccessException)
        {
            yield break;
        }
        catch (PathTooLongException)
        {
            yield break;
        }

        foreach (var file in matches)
        {
            yield return(file);
        }

        if (_option == SearchOption.AllDirectories)
        {
            foreach (var dir in Directory.EnumerateDirectories(_root, "*", SearchOption.TopDirectoryOnly))
            {
                var fileSystemInfos = new FileSystemEnumerable(dir, _patterns, _option);
                foreach (var match in fileSystemInfos)
                {
                    yield return(match);
                }
            }
        }
    }
Example #14
0
        static void Main()
        {
            var enumeration = new FileSystemEnumerable <string>(
                directory: Path.GetTempPath(),                                // search Temp directory
                transform: (ref FileSystemEntry entry) => entry.ToFullPath(), // map FileSystemEntry to string (see FileSystemEnumerable generic argument)
                options: new EnumerationOptions()
            {
                RecurseSubdirectories = true
            })
            {
                // The following predicate will be used to filter the file entries
                ShouldIncludePredicate = (ref FileSystemEntry entry) => !entry.IsDirectory && Path.GetExtension(entry.ToFullPath()) == ".tmp"
            };

            // Prints all ".tmp" files from Temp directory
            foreach (string filePath in enumeration)
            {
                Console.WriteLine(filePath);
            }
        }
Example #15
0
        public void EnumerateFiles_LinksWithCycles_ShouldNotThrow()
        {
            DirectoryInfo testDirectory = CreateDirectoryContainingSelfReferencingSymbolicLink();

            IEnumerable <string> enumerable = new FileSystemEnumerable <string>(
                testDirectory.FullName,
                (ref FileSystemEntry entry) => entry.ToFullPath(),
                // Skipping attributes would force a disk hit which enters the cyclic symlink
                new EnumerationOptions()
            {
                AttributesToSkip = 0
            })
            {
                ShouldIncludePredicate = (ref FileSystemEntry entry) => !entry.IsDirectory
            };

            // Windows differentiates between dir symlinks and file symlinks
            int expected = OperatingSystem.IsWindows() ? 0 : 1;

            Assert.Equal(expected, enumerable.Count());
        }
Example #16
0
        static void ScanFiles(string path)
        {
            DriveInfo drive = ScannedDrives.First(d => path.StartsWith(d.CurrentDriveLetter));

            WindowsInterop.RtlSetProcessPlaceholderCompatibilityMode(2);
            int baseBuffer = 8192;
            FileSystemEnumerable <ScannedFileInfo> fse =
                new FileSystemEnumerable <ScannedFileInfo>(path,
                                                           (ref FileSystemEntry entry) => new ScannedFileInfo()
            {
                FullPath = entry.ToFullPath(), Size = entry.Length, Drive = drive
            },
                                                           new EnumerationOptions()
            {
                RecurseSubdirectories = true
            });

            var context = new WTFContext();

            context.FilePaths.AddRange(fse);
            context.SaveChanges();
        }
 public DelegateEnumerator(FileSystemEnumerable <TResult> enumerable, bool isNormalized)
     : base(enumerable._directory, isNormalized, enumerable._options)
 {
     _enumerable = enumerable;
 }
Example #18
0
 public DelegateEnumerator(FileSystemEnumerable <TResult> enumerable)
     : base(enumerable._directory, enumerable._options)
 {
     _enumerable = enumerable;
 }
Example #19
0
        /// <inheritdoc />
        protected override IEnumerable <FileSystemItem> EnumerateItemsImpl(UPath path, SearchOption searchOption, SearchPredicate?searchPredicate)
        {
            if (IsOnWindows)
            {
                if (IsWithinSpecialDirectory(path))
                {
                    if (!SpecialDirectoryExists(path))
                    {
                        throw NewDirectoryNotFoundException(path);
                    }

                    // Only sub folder "/drive/" on root folder /
                    if (path == UPath.Root)
                    {
                        var item = new FileSystemItem(this, PathDrivePrefixOnWindows, true);
                        if (searchPredicate == null || searchPredicate(ref item))
                        {
                            yield return(item);
                        }

                        if (searchOption == SearchOption.AllDirectories)
                        {
                            foreach (var subItem in EnumerateItemsImpl(PathDrivePrefixOnWindows, searchOption, searchPredicate))
                            {
                                yield return(subItem);
                            }
                        }

                        yield break;
                    }

                    // When listing for /drive, return the list of drives available
                    if (path == PathDrivePrefixOnWindows)
                    {
                        var pathDrives = new List <UPath>();
                        foreach (var drive in DriveInfo.GetDrives())
                        {
                            if (drive.Name.Length < 2 || drive.Name[1] != ':')
                            {
                                continue;
                            }

                            var pathDrive = PathDrivePrefixOnWindows / char.ToLowerInvariant(drive.Name[0]).ToString();

                            pathDrives.Add(pathDrive);

                            var item = new FileSystemItem(this, pathDrive, true);
                            if (searchPredicate == null || searchPredicate(ref item))
                            {
                                yield return(item);
                            }
                        }

                        if (searchOption == SearchOption.AllDirectories)
                        {
                            foreach (var pathDrive in pathDrives)
                            {
                                foreach (var subItem in EnumerateItemsImpl(pathDrive, searchOption, searchPredicate))
                                {
                                    yield return(subItem);
                                }
                            }
                        }

                        yield break;
                    }
                }
            }
            var pathOnDisk = ConvertPathToInternal(path);

            if (!Directory.Exists(pathOnDisk))
            {
                yield break;
            }

#if NETSTANDARD2_1
            var enumerable = new FileSystemEnumerable <FileSystemItem>(pathOnDisk, TransformToFileSystemItem, searchOption == SearchOption.AllDirectories ? CompatibleRecursive : Compatible);

            foreach (var item in enumerable)
            {
                var localItem = item;
                if (searchPredicate == null || searchPredicate(ref localItem))
                {
                    yield return(localItem);
                }
            }
#else
            var results = Directory.EnumerateFileSystemEntries(pathOnDisk, "*", searchOption);
            foreach (var subPath in results)
            {
                var fileInfo = new FileInfo(subPath);
                var fullPath = ConvertPathFromInternal(subPath);
                var item     = new FileSystemItem
                {
                    FileSystem     = this,
                    AbsolutePath   = fullPath,
                    Path           = fullPath,
                    Attributes     = fileInfo.Attributes,
                    CreationTime   = fileInfo.CreationTimeUtc.ToLocalTime(),
                    LastAccessTime = fileInfo.LastAccessTimeUtc.ToLocalTime(),
                    LastWriteTime  = fileInfo.LastWriteTimeUtc.ToLocalTime(),
                    Length         = (fileInfo.Attributes & FileAttributes.Directory) > 0 ? 0 : fileInfo.Length
                };
                if (searchPredicate == null || searchPredicate(ref item))
                {
                    yield return(item);
                }
            }
#endif
        }