FileSystem

There is a rich functionality for working with the file system implemented as extension methods in the FileSystemInfoExtension class and allows you to enumerate file system objects (files and directories) starting from the specified directory using custom filtering and sorting. Methods for copying, moving and deleting these objects are also implemented. Methods with the Ex suffix in the searchPattern delegate, filtering predicate and output selector (for custom types) take the list of parent directories from the start directory. Thus, there is ready information about the nesting level of the current object and its parent directories. For methods of copying, moving, and deleting file system objects the action is specified by a delegate parameter that takes a file system object and returns a TryOut<T> object. A true value in the Success property of this object indicates that the action should be performed with the options from the Value property, a false value in the Success indicates that the action should be skipped for this object. The following describes the common parameters used in these methods:

startDirectoryInfo DirectoryInfo The starting directory from which file system objects are enumerated.

searchPattern string The search string to match against the names of files in path. This parameter can contain a combination of valid literal path and wildcard (* and ?) characters, but it doesn't support regular expressions. Null value is not allowed for compatibility with the standard API..

searchPatternSelector Delegate Delegate that returns a SearchPattern. If the delegate returns null string as the search pattern for the current directory then no filesystem entries are searched for in that directory. Null value is not allowed.

If the method does not specify the searchPattern or searchPatternSelector parameter, then in this case the search pattern ***** is used, i.e. all elements will be output.

searchOption SearchOption One of the enumeration values that specifies whether the search operation should include only the current directory or should include all subdirectories.

maxDepth int The maximum descent depth to enumerate file system objects. 0 - depth of the start directory node.

If no searchOption or maxDepth traversal depth parameter is specified in these extension methods, then by default it is considered that the traversal is performed to the maximum possible depth of the subtree.

traversalOptions FileSystemTraversalOptions

Enum type flags value specifying file system object enumeration options.

None - no action.
ExcludeStartDirectory - excludes the start directory from the resulting list of objects.
ExcludeEmptyDirectory - excludes empty directories from the resulting list of objects. If a directory contains empty subdirectories, then it will also be considered empty and will be excluded from the list.
Refresh - causes the state of file system objects to be updated before they are used directly. In some cases, this will avoid the generation of exceptions in the presence of logical errors in the actions performed. For example, when you enumerate a directory in depth and move it or delete it along with its contents. After the content directory is moved or deleted, the underlying items in the list will no longer be valid. When this option is set, the state of the objects will be updated and actions to move or delete them will be skipped. But the correct solution would be to describe a recursive action with each element, or in the case of moving or deleting a directory with contents, limit the depth of enumeration descent.
ShowFileOccurrence - shows occurrence of file objects.
ShowDirectoryEnter - shows the directory objects after entering its from the top level (preorder traversal).
ShowDirectoryLeave - shows the directory objects before leaving its to the top level (postorder traversal).
ShowDirectoryOccurrence (ShowDirectoryEnter | ShowDirectoryLeave) - shows both occurrences (after entering and before leaving) of directory objects.
ShowAllOccurrence (ShowFileOccurrence | ShowDirectoryOccurrence) - shows all occurrences of file system objects (files and directories).
PreorderTraversal (ShowFileOccurrence | ShowDirectoryEnter) - specifies a combination of flags for preorder traversal of the file system object tree.
PostorderTraversal (ShowFileOccurrence | ShowDirectoryLeave) - specifies a combination of flags for postorder traversal of the file system object tree.

The presence of this parameter is a hallmark of all extension methods described here.

The methods of copying, moving, or deleting must be passed a delegate that returns options for the corresponding operation for each object from the enumeration. This delegate must return a TryOut<TOp> structure where TOp is the type of the options for the corresponding operation. The Success property with a value of false reports skipping the operation for the specified object, the value of true and options of type TOp will set the operation execution mode for the specified object. The options for the copy, move, and delete operations are described below:

traversalMarker FileSystemTraversalMarker

Enum type value specifying file system object enumeration marker.

None - object is not marked.
EnterDirectory - marks a directory object after entering it from the top level.
LeaveDirectory - marks a directory object before leaving it to the top level.

manipulationOptions FileSystemManipulationOptions

Enum type flags value specifying file system object manipulation options.

None - no action.
EnsureDirectory - ensures that the directory is created before using it.
CleanupDirectory - ensures that an empty directory is deleted after it has been used.
ClearReadOnly - clears the readonly attribute for the specified file system objects.
SkipEmptyDirectory - skips any processing for empty directories.
Refresh - causes the state of file system objects to be updated before they are used directly. In some cases, this will avoid the generation of exceptions in the presence of logical errors in the actions performed. For example, when you enumerate a directory in depth and move it or delete it along with its contents. After the content directory is moved or deleted, the underlying items in the list will no longer be valid. When this option is set, the state of the objects will be updated and actions to move or delete them will be skipped. But the correct solution would be to describe a recursive action with each element, or in the case of moving or deleting a directory with contents, limit the depth of enumeration descent.

manipulationMarker FileSystemManipulationMarker

Enum type flags value specifying file system object manipulation marker.

None - no action
ElementProcessed - filesystem element was processed successfully.
ElementError - an error occurred while processing a file system element.
DirectoryCreated - before processing the file system element, the creation of the necessary directories was ensured.
DirectoryDeleted - after processing a directory, it was deleted as empty, or after processing a file, the directory containing it was deleted as empty.

maxConcurrents int Specifies the maximum number of concurrently executed actions. This parameter is used in methods for manipulating file system objects. Parallel execution is performed only for file methods. Directories are processed sequentially.

errorHandler Delegate A delegate that allows you to specify external error handling. Should return boolean true to suppress propagation of the raised exception.

public readonly record struct MarkedInfo<TInfo>
  where TInfo : FileSystemInfo
{
  public TInfo Info { get; }

  public FileSystemTraversalMarker TraversalMarker { get; }
}

IEnsuringOptions The implementation of this interface by a structure or class of parameters in methods to work with file system objects allows you to specify a list of directories required to perform this operation, which will be created before its execution. Directories are only created when the EnsureDirectory flag is set in the manipulationOptions parameter. In the case of directory creation, the manipulationMarker value of type FileSystemManipulationMarker followed by each processed file system element is set to the DirectoryCreated flag.

public interface IEnsuringOptions
{
  IEnumerable<string> EnsuringDirectories { get; }
}

IProcessingOptions The implementation of this interface by a structure or class of parameters in methods to work with file system objects and specifying the implemented NoProcessing flag allows you to prohibit their main processing. However, it does not suppress the pre-creation of directories or the deletion of empty directories at the end of processing.

public interface IProcessingOptions
{
  bool NoProcessing { get; }
}

TransferOptions The type containing parameters for methods to copy and move file system objects. The copy methods only work on files, while the move methods work on both files and directories.

public record struct TransferOptions : IEnsuringOptions, IProcessingOptions
{
  // Destination path
  public string? DestinationPath { get; init; }

  // Overwrite target object if already exists with same name.
  public bool Overwrite { get; init; }

  // Allows you to prohibit the processing of this element.
  public bool NoProcessing { get; init; }
}

ReplaceOptions The type containing parameters for methods to replace file system objects. The replace methods only work on files.

public readonly record struct ReplaceOptions : IEnsuringOptions, IProcessingOptions
{
  // Destination path
  public string DestinationPath { get; init; }

  // Destination backup path
  public string? DestinationBackupPath { get; init; }

  // Ignore merge errors (such as attributes and ACLs) from the replaced file to the replacement file
  public bool IgnoreMetadataErrors { get; init; }

  // Allows you to prohibit the processing of this element.
  public bool NoProcessing { get; init; }
}

DeleteOptions The type containing parameters for methods to delete file system objects. The delete methods work on both files and directories.

public readonly record struct DeleteOptions : IProcessingOptions
{
  // Delete directory recursively.
  public bool Recursive { get; init; }

  // Allows you to prohibit the processing of this element.
  public bool NoProcessing { get; init; }
}

ReplicateOptions The type containing parameters for methods to replicate directories.

public readonly record struct ReplicateOptions : IEnsuringOptions, IProcessingOptions
{
  public string DestinationPath { get; init; }
}

InfoResult The result type for each file system object returned by the Delete and Cleanup methods.

public readonly record struct InfoResult<TInfo>
  where TInfo : FileSystemInfo
{
  // File system info
  public TInfo Info { get; }

  // A marker to traverse the tree structure object of the file system.
  public FileSystemTraversalMarker TraversalMarker { get; }

  // A marker of the operations applied to the specified file system object.
  public FileSystemManipulationMarker ManipulationMarker { get; }
}

TransferResult The result type for each file system object returned by the copy or move methods.

public readonly record struct TransferResult<TInfo>
  where TInfo : FileSystemInfo
{
  // Source file system info
  public TInfo SourceInfo { get; }

  // Destination file system info
  public TInfo? DestinationInfo { get; }

  // A marker to traverse the tree structure object of the file system.
  public FileSystemTraversalMarker TraversalMarker { get; }

  // A marker of the operations applied to the specified file system object.
  public FileSystemManipulationMarker ManipulationMarker { get; }
}

ReplaceResult The result type for each file system object returned by the replace methods.

public readonly record struct ReplaceResult<TInfo>
  where TInfo : FileSystemInfo
{
  // Source file system info
  public TInfo SourceInfo { get; }
  
  // Destination file system info
  public TInfo? DestinationInfo { get; }

  // Destination backup file system info
  public TInfo? DestinationBackupInfo { get; }

  // A marker to traverse the tree structure object of the file system.
  public FileSystemTraversalMarker TraversalMarker { get; }

  // A marker of the operations applied to the specified file system object.
  public FileSystemManipulationMarker ManipulationMarker { get; }
}

There are several categories of methods:

EnumerateFileSystemInfos methods - enumerate filesystem objects.

Regular methods

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer);

Regular methods with custom output

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfos<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, FileSystemTraversalMarker, TFileSystemInfo> selector);

Extended methods

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo fileSystemInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo fileSystemInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo fileSystemInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileSystemInfo> EnumerateFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo fileSystemInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, IComparer<FileSystemInfo>? comparer);

Extended methods with custom output

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo fileSystemInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo fileSystemInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo fileSystemInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, FileSystemTraversalMarker, TFileSystemInfo> selector);

public static IEnumerable<TFileSystemInfo> EnumerateFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo fileSystemInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, FileSystemTraversalMarker, TFileSystemInfo> selector);

GetFileSystemInfos methods - materialize enumerated filesystem objects into an array.

Regular methods

public static FileSystemInfo[] GetFileSystemInfos(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison);

public static FileSystemInfo[] GetFileSystemInfos(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison);

public static FileSystemInfo[] GetFileSystemInfos(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison);

public static FileSystemInfo[] GetFileSystemInfos(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison);

public static FileSystemInfo[] GetFileSystemInfos(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison);

public static FileSystemInfo[] GetFileSystemInfos(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison);

public static FileSystemInfo[] GetFileSystemInfos(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison);

public static FileSystemInfo[] GetFileSystemInfos(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer);

public static FileSystemInfo[] GetFileSystemInfos(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer);

public static FileSystemInfo[] GetFileSystemInfos(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer);

public static FileSystemInfo[] GetFileSystemInfos(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer);

public static FileSystemInfo[] GetFileSystemInfos(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer);

public static FileSystemInfo[] GetFileSystemInfos(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer);

public static FileSystemInfo[] GetFileSystemInfos(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer);

Regular methods with custom output

public static TFileSystemInfo[] GetFileSystemInfos<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfos<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfos<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfos<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfos<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfos<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfos<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileSystemInfo>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfos<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfos<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfos<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfos<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfos<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfos<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfos<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileSystemInfo>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, TFileSystemInfo> selector);

Extended methods

public static FileSystemInfo[] GetFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<FileSystemInfo>? comparison);

public static FileSystemInfo[] GetFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<FileSystemInfo>? comparison);

public static FileSystemInfo[] GetFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<FileSystemInfo>? comparison);

public static FileSystemInfo[] GetFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<FileSystemInfo>? comparison);

public static FileSystemInfo[] GetFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<FileSystemInfo>? comparison);

public static FileSystemInfo[] GetFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo fileSystemInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, Comparison<FileSystemInfo>? comparison);

public static FileSystemInfo[] GetFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo fileSystemInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, Comparison<FileSystemInfo>? comparison);

public static FileSystemInfo[] GetFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<FileSystemInfo>? comparer);

public static FileSystemInfo[] GetFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<FileSystemInfo>? comparer);

public static FileSystemInfo[] GetFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<FileSystemInfo>? comparer);

public static FileSystemInfo[] GetFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<FileSystemInfo>? comparer);

public static FileSystemInfo[] GetFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<FileSystemInfo>? comparer);

public static FileSystemInfo[] GetFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo fileSystemInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, IComparer<FileSystemInfo>? comparer);

public static FileSystemInfo[] GetFileSystemInfosEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo fileSystemInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, IComparer<FileSystemInfo>? comparer);

Extended methods with custom output

public static TFileSystemInfo[] GetFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo fileSystemInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileSystemInfo fileSystemInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, Comparison<FileSystemInfo>? comparison, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo fileSystemInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, TFileSystemInfo> selector);

public static TFileSystemInfo[] GetFileSystemInfosEx<TFileSystemInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileSystemInfo fileSystemInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, IComparer<FileSystemInfo>? comparer, Func<FileSystemInfo, IReadOnlyList<DirectoryInfo>, TFileSystemInfo> selector);

EnumerateDirectories methods - enumerate directory objects.

Regular methods

public static IEnumerable<DirectoryInfo> EnumerateDirectories(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison);

public static IEnumerable<DirectoryInfo> EnumerateDirectories(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison);

public static IEnumerable<DirectoryInfo> EnumerateDirectories(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison);

public static IEnumerable<DirectoryInfo> EnumerateDirectories(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison);

public static IEnumerable<DirectoryInfo> EnumerateDirectories(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison);

public static IEnumerable<DirectoryInfo> EnumerateDirectories(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison);

public static IEnumerable<DirectoryInfo> EnumerateDirectories(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison);

public static IEnumerable<DirectoryInfo> EnumerateDirectories(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer);

public static IEnumerable<DirectoryInfo> EnumerateDirectories(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer);

public static IEnumerable<DirectoryInfo> EnumerateDirectories(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer);

public static IEnumerable<DirectoryInfo> EnumerateDirectories(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer);

public static IEnumerable<DirectoryInfo> EnumerateDirectories(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer);

public static IEnumerable<DirectoryInfo> EnumerateDirectories(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer);

public static IEnumerable<DirectoryInfo> EnumerateDirectories(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer);

Regular methods with custom output

public static IEnumerable<TDirectoryInfo> EnumerateDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, TDirectoryInfo> selector);

Extended methods

public static IEnumerable<DirectoryInfo> EnumerateDirectoriesEx(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<DirectoryInfo>? comparison);

public static IEnumerable<DirectoryInfo> EnumerateDirectoriesEx(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<DirectoryInfo>? comparison);

public static IEnumerable<DirectoryInfo> EnumerateDirectoriesEx(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<DirectoryInfo>? comparison);

public static IEnumerable<DirectoryInfo> EnumerateDirectoriesEx(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<DirectoryInfo>? comparison);

public static IEnumerable<DirectoryInfo> EnumerateDirectoriesEx(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<DirectoryInfo>? comparison);

public static IEnumerable<DirectoryInfo> EnumerateDirectoriesEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, Comparison<DirectoryInfo>? comparison);

public static IEnumerable<DirectoryInfo> EnumerateDirectoriesEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, Comparison<DirectoryInfo>? comparison);

public static IEnumerable<DirectoryInfo> EnumerateDirectoriesEx(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<DirectoryInfo>? comparer);

public static IEnumerable<DirectoryInfo> EnumerateDirectoriesEx(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<DirectoryInfo>? comparer);

public static IEnumerable<DirectoryInfo> EnumerateDirectoriesEx(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<DirectoryInfo>? comparer);

public static IEnumerable<DirectoryInfo> EnumerateDirectoriesEx(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<DirectoryInfo>? comparer);

public static IEnumerable<DirectoryInfo> EnumerateDirectoriesEx(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<DirectoryInfo>? comparer);

public static IEnumerable<DirectoryInfo> EnumerateDirectoriesEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, IComparer<DirectoryInfo>? comparer);

public static IEnumerable<DirectoryInfo> EnumerateDirectoriesEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, IComparer<DirectoryInfo>? comparer);

Extended methods with custom output

public static IEnumerable<TDirectoryInfo> EnumerateDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static IEnumerable<TDirectoryInfo> EnumerateDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

GetDirectories methods - materialize enumerated directory objects into an array.

Regular methods

public static DirectoryInfo[] GetDirectories(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison);

public static DirectoryInfo[] GetDirectories(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison);

public static DirectoryInfo[] GetDirectories(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison);

public static DirectoryInfo[] GetDirectories(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison);

public static DirectoryInfo[] GetDirectories(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison);

public static DirectoryInfo[] GetDirectories(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison);

public static DirectoryInfo[] GetDirectories(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison);

public static DirectoryInfo[] GetDirectories(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer);

public static DirectoryInfo[] GetDirectories(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer);

public static DirectoryInfo[] GetDirectories(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer);

public static DirectoryInfo[] GetDirectories(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer);

public static DirectoryInfo[] GetDirectories(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer);

public static DirectoryInfo[] GetDirectories(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer);

public static DirectoryInfo[] GetDirectories(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer);

Regular methods with custom output

public static TDirectoryInfo[] GetDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<DirectoryInfo>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectories<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<DirectoryInfo>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, TDirectoryInfo> selector);

Extended methods

public static DirectoryInfo[] GetDirectoriesEx(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<DirectoryInfo>? comparison);

public static DirectoryInfo[] GetDirectoriesEx(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<DirectoryInfo>? comparison);

public static DirectoryInfo[] GetDirectoriesEx(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<DirectoryInfo>? comparison);

public static DirectoryInfo[] GetDirectoriesEx(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<DirectoryInfo>? comparison);

public static DirectoryInfo[] GetDirectoriesEx(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<DirectoryInfo>? comparison);

public static DirectoryInfo[] GetDirectoriesEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, Comparison<DirectoryInfo>? comparison);

public static DirectoryInfo[] GetDirectoriesEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, Comparison<DirectoryInfo>? comparison);

public static DirectoryInfo[] GetDirectoriesEx(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<DirectoryInfo>? comparer);

public static DirectoryInfo[] GetDirectoriesEx(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<DirectoryInfo>? comparer);

public static DirectoryInfo[] GetDirectoriesEx(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<DirectoryInfo>? comparer);

public static DirectoryInfo[] GetDirectoriesEx(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<DirectoryInfo>? comparer);

public static DirectoryInfo[] GetDirectoriesEx(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<DirectoryInfo>? comparer);

public static DirectoryInfo[] GetDirectoriesEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, IComparer<DirectoryInfo>? comparer);

public static DirectoryInfo[] GetDirectoriesEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, IComparer<DirectoryInfo>? comparer);

Extended methods with custom output

public static TDirectoryInfo[] GetDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, Comparison<DirectoryInfo>? comparison, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

public static TDirectoryInfo[] GetDirectoriesEx<TDirectoryInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? predicate, IComparer<DirectoryInfo>? comparer, Func<DirectoryInfo, IReadOnlyList<DirectoryInfo>, TDirectoryInfo> selector);

EnumerateFiles methods - enumerate file objects.

Regular methods

public static IEnumerable<FileInfo> EnumerateFiles(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileInfo> EnumerateFiles(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileInfo> EnumerateFiles(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileInfo> EnumerateFiles(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileInfo> EnumerateFiles(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileInfo> EnumerateFiles(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileInfo> EnumerateFiles(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileInfo> EnumerateFiles(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileInfo> EnumerateFiles(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileInfo> EnumerateFiles(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileInfo> EnumerateFiles(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileInfo> EnumerateFiles(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileInfo> EnumerateFiles(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileInfo> EnumerateFiles(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

Regular methods with custom output

public static IEnumerable<TFileInfo> EnumerateFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, TFileInfo> selector);

Extended methods

public static IEnumerable<FileInfo> EnumerateFilesEx(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileInfo> EnumerateFilesEx(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileInfo> EnumerateFilesEx(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileInfo> EnumerateFilesEx(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileInfo> EnumerateFilesEx(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileInfo> EnumerateFilesEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo fileInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? filePredicate, Predicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileInfo> EnumerateFilesEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo fileInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? filePredicate, Predicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static IEnumerable<FileInfo> EnumerateFilesEx(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileInfo> EnumerateFilesEx(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileInfo> EnumerateFilesEx(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileInfo> EnumerateFilesEx(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileInfo> EnumerateFilesEx(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileInfo> EnumerateFilesEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo fileInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? filePredicate, IPredicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static IEnumerable<FileInfo> EnumerateFilesEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo fileInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? filePredicate, IPredicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

Extended methods with custom output

public static IEnumerable<TFileInfo> EnumerateFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo fileInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? filePredicate, Predicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo fileInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? filePredicate, Predicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo fileInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? filePredicate, IPredicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static IEnumerable<TFileInfo> EnumerateFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo fileInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? filePredicate, IPredicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

GetFiles methods - materialize enumerated file objects into an array.

Regular methods

public static FileInfo[] GetFiles(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static FileInfo[] GetFiles(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static FileInfo[] GetFiles(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static FileInfo[] GetFiles(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static FileInfo[] GetFiles(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static FileInfo[] GetFiles(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static FileInfo[] GetFiles(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static FileInfo[] GetFiles(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static FileInfo[] GetFiles(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static FileInfo[] GetFiles(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static FileInfo[] GetFiles(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static FileInfo[] GetFiles(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static FileInfo[] GetFiles(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static FileInfo[] GetFiles(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

Regular methods with custom output

public static TFileInfo[] GetFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, TFileInfo> selector);

public static TFileInfo[] GetFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, TFileInfo> selector);

public static TFileInfo[] GetFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, TFileInfo> selector);

public static TFileInfo[] GetFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, TFileInfo> selector);

public static TFileInfo[] GetFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, TFileInfo> selector);

public static TFileInfo[] GetFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, TFileInfo> selector);

public static TFileInfo[] GetFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<FileInfo>? filePredicate, Predicate<DirectoryInfo>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, TFileInfo> selector);

public static TFileInfo[] GetFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, TFileInfo> selector);

public static TFileInfo[] GetFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, TFileInfo> selector);

public static TFileInfo[] GetFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, TFileInfo> selector);

public static TFileInfo[] GetFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, TFileInfo> selector);

public static TFileInfo[] GetFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, TFileInfo> selector);

public static TFileInfo[] GetFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, TFileInfo> selector);

public static TFileInfo[] GetFiles<TFileInfo>(this DirectoryInfo startDirectoryInfo, Func<DirectoryInfo, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<FileInfo>? filePredicate, IPredicate<DirectoryInfo>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, TFileInfo> selector);

Extended methods

public static FileInfo[] GetFilesEx(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static FileInfo[] GetFilesEx(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static FileInfo[] GetFilesEx(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static FileInfo[] GetFilesEx(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static FileInfo[] GetFilesEx(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static FileInfo[] GetFilesEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo fileInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? filePredicate, Predicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static FileInfo[] GetFilesEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo fileInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? filePredicate, Predicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? directoryPredicate, Comparison<FileSystemInfo>? comparison);

public static FileInfo[] GetFilesEx(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static FileInfo[] GetFilesEx(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static FileInfo[] GetFilesEx(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static FileInfo[] GetFilesEx(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static FileInfo[] GetFilesEx(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static FileInfo[] GetFilesEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo fileInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? filePredicate, IPredicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

public static FileInfo[] GetFilesEx(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo fileInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? filePredicate, IPredicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? directoryPredicate, IComparer<FileSystemInfo>? comparer);

Extended methods with custom output

public static TFileInfo[] GetFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static TFileInfo[] GetFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static TFileInfo[] GetFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static TFileInfo[] GetFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static TFileInfo[] GetFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, Predicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static TFileInfo[] GetFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo fileInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? filePredicate, Predicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static TFileInfo[] GetFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, Predicate<(FileInfo fileInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? filePredicate, Predicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? directoryPredicate, Comparison<FileSystemInfo>? comparison, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static TFileInfo[] GetFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static TFileInfo[] GetFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static TFileInfo[] GetFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static TFileInfo[] GetFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static TFileInfo[] GetFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, string searchPattern, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo, IReadOnlyList<DirectoryInfo>)>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static TFileInfo[] GetFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, SearchOption searchOption, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo fileInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? filePredicate, IPredicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

public static TFileInfo[] GetFilesEx<TFileInfo>(this DirectoryInfo startDirectoryInfo, Func<IReadOnlyList<DirectoryInfo>, string?> searchPatternSelector, int maxDepth, FileSystemTraversalOptions traversalOptions, IPredicate<(FileInfo, IReadOnlyList<DirectoryInfo>)>? filePredicate, IPredicate<(DirectoryInfo directoryInfo, IReadOnlyList<DirectoryInfo> parentalDirectoryInfos)>? directoryPredicate, IComparer<FileSystemInfo>? comparer, Func<FileInfo, IReadOnlyList<DirectoryInfo>, TFileInfo> selector);

ManipulateFileSystemInfos methods - File System objects manipulation methods.

File System objects manipulation asynchronus methods

public static IAsyncEnumerable<TManipulationResult> ManipulateFileSystemInfosAsync<TFileSystemItem, TManipulationParams, TManipulationInterim, TManipulationResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, TManipulationParams> manipulationParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TManipulationParams, TManipulationInterim?> fileSystemHandler, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TManipulationInterim?, TManipulationResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IAsyncEnumerable<TManipulationResult> ManipulateFileSystemInfosAsync<TFileSystemItem, TManipulationParams, TManipulationResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, TManipulationParams> manipulationParamsSelector, Action<FileSystemInfo, FileSystemTraversalMarker, TManipulationParams> fileSystemHandler, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TManipulationResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default)

File System objects manipulation deferred methods

public static IEnumerable<TManipulationResult> ManipulateFileSystemInfosDefer<TFileSystemItem, TManipulationParams, TManipulationInterim, TManipulationResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, TManipulationParams> manipulationParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TManipulationParams, TManipulationInterim?> fileSystemHandler, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TManipulationInterim?, TManipulationResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TManipulationResult> ManipulateFileSystemInfosDefer<TFileSystemItem, TManipulationParams, TManipulationInterim, TManipulationResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, TManipulationParams> manipulationParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TManipulationParams, TManipulationInterim?> fileSystemHandler, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TManipulationInterim?, TManipulationResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TManipulationResult> ManipulateFileSystemInfosDefer<TFileSystemItem, TManipulationParams, TManipulationResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, TManipulationParams> manipulationParamsSelector, Action<FileSystemInfo, FileSystemTraversalMarker, TManipulationParams> fileSystemHandler, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TManipulationResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TManipulationResult> ManipulateFileSystemInfosDefer<TFileSystemItem, TManipulationParams, TManipulationResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, TManipulationParams> manipulationParamsSelector, Action<FileSystemInfo, FileSystemTraversalMarker, TManipulationParams> fileSystemHandler, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TManipulationResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

File System objects manipulation direct methods

public static TManipulationResult[] ManipulateFileSystemInfos<TFileSystemItem, TManipulationParams, TManipulationInterim, TManipulationResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, TManipulationParams> manipulationParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TManipulationParams, TManipulationInterim?> fileSystemHandler, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TManipulationInterim?, TManipulationResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TManipulationResult[] ManipulateFileSystemInfos<TFileSystemItem, TManipulationParams, TManipulationInterim, TManipulationResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, TManipulationParams> manipulationParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TManipulationParams, TManipulationInterim?> fileSystemHandler, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TManipulationInterim?, TManipulationResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TManipulationResult[] ManipulateFileSystemInfos<TFileSystemItem, TManipulationParams, TManipulationResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, TManipulationParams> manipulationParamsSelector, Action<FileSystemInfo, FileSystemTraversalMarker, TManipulationParams> fileSystemHandler, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TManipulationResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TManipulationResult[] ManipulateFileSystemInfos<TFileSystemItem, TManipulationParams, TManipulationResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, TManipulationParams> manipulationParamsSelector, Action<FileSystemInfo, FileSystemTraversalMarker, TManipulationParams> fileSystemHandler, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TManipulationResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

CopyFileSystemInfos methods - File System objects copy methods.

File System objects asynchronus copy methods

public static IAsyncEnumerable<TTransferResult> CopyFileSystemInfosAsync<TFileSystemItem, TTransferResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, TransferOptions> copyParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, FileSystemInfo?, TTransferResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IAsyncEnumerable<TransferResult<FileSystemInfo>> CopyFileSystemInfosAsync(this IEnumerable<MarkedInfo<FileSystemInfo>> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions> copyParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IAsyncEnumerable<TransferResult<FileSystemInfo>> CopyFileSystemInfosAsync(this IEnumerable<FileSystemInfo> fileSystemInfos, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, TransferOptions> copyParamsSelector, Func<FileSystemInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

File System objects deferred copy methods

public static IEnumerable<TTransferResult> CopyFileSystemInfosDefer<TFileSystemItem, TTransferResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, TransferOptions> copyParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, FileSystemInfo?, TTransferResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TTransferResult> CopyFileSystemInfosDefer<TFileSystemItem, TTransferResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, TransferOptions> copyParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, FileSystemInfo?, TTransferResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TransferResult<FileSystemInfo>> CopyFileSystemInfosDefer(this IEnumerable<MarkedInfo<FileSystemInfo>> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions> copyParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TransferResult<FileSystemInfo>> CopyFileSystemInfosDefer(this IEnumerable<MarkedInfo<FileSystemInfo>> fileSystemItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions> copyParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TransferResult<FileSystemInfo>> CopyFileSystemInfosDefer(this IEnumerable<FileSystemInfo> fileSystemInfos, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, TransferOptions> copyParamsSelector, Func<FileSystemInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TransferResult<FileSystemInfo>> CopyFileSystemInfosDefer(this IEnumerable<FileSystemInfo> fileSystemInfos, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileSystemInfo, TransferOptions> copyParamsSelector, Func<FileSystemInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

File System objects direct copy methods

public static TTransferResult[] CopyFileSystemInfos<TFileSystemItem, TTransferResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, TransferOptions> copyParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, FileSystemInfo, TTransferResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TTransferResult[] CopyFileSystemInfos<TFileSystemItem, TTransferResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, TransferOptions> copyParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, FileSystemInfo, TTransferResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TransferResult<FileSystemInfo>[] CopyFileSystemInfos(this IEnumerable<MarkedInfo<FileSystemInfo>> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions> copyParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TransferResult<FileSystemInfo>[] CopyFileSystemInfos(this IEnumerable<MarkedInfo<FileSystemInfo>> fileSystemItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions> copyParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TransferResult<FileSystemInfo>[] CopyFileSystemInfos(this IEnumerable<FileSystemInfo> fileSystemInfos, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, TransferOptions> copyParamsSelector, Func<FileSystemInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TransferResult<FileSystemInfo>[] CopyFileSystemInfos(this IEnumerable<FileSystemInfo> fileSystemInfos, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileSystemInfo, TransferOptions> copyParamsSelector, Func<FileSystemInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

MoveFileSystemInfos methods - File System objects move methods.

File System objects asynchronus move methods

public static IAsyncEnumerable<TTransferResult> MoveFileSystemInfosAsync<TFileSystemItem, TTransferResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, TransferOptions> moveParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, FileSystemInfo?, TTransferResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IAsyncEnumerable<TransferResult<FileSystemInfo>> MoveFileSystemInfosAsync(this IEnumerable<MarkedInfo<FileSystemInfo>> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions> moveParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IAsyncEnumerable<TransferResult<FileSystemInfo>> MoveFileSystemInfosAsync(this IEnumerable<FileSystemInfo> fileSystemInfos, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, TransferOptions> moveParamsSelector, Func<FileSystemInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

File System objects deferred move methods

public static IEnumerable<TTransferResult> MoveFileSystemInfosDefer<TFileSystemItem, TTransferResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, TransferOptions> moveParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, FileSystemInfo?, TTransferResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TTransferResult> MoveFileSystemInfosDefer<TFileSystemItem, TTransferResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, TransferOptions> moveParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, FileSystemInfo, TTransferResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TransferResult<FileSystemInfo>> MoveFileSystemInfosDefer(this IEnumerable<MarkedInfo<FileSystemInfo>> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions> moveParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TransferResult<FileSystemInfo>> MoveFileSystemInfosDefer(this IEnumerable<MarkedInfo<FileSystemInfo>> fileSystemItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions> moveParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TransferResult<FileSystemInfo>> MoveFileSystemInfosDefer(this IEnumerable<FileSystemInfo> fileSystemInfos, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, TransferOptions> moveParamsSelector, Func<FileSystemInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TransferResult<FileSystemInfo>> MoveFileSystemInfosDefer(this IEnumerable<FileSystemInfo> fileSystemInfos, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileSystemInfo, TransferOptions> moveParamsSelector, Func<FileSystemInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

File System objects direct move methods

public static TTransferResult[] MoveFileSystemInfos<TFileSystemItem, TTransferResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, TransferOptions> moveParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, FileSystemInfo, TTransferResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TTransferResult[] MoveFileSystemInfos<TFileSystemItem, TTransferResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, TransferOptions> moveParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, FileSystemInfo, TTransferResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TransferResult<FileSystemInfo>[] MoveFileSystemInfos(this IEnumerable<MarkedInfo<FileSystemInfo>> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions> moveParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TransferResult<FileSystemInfo>[] MoveFileSystemInfos(this IEnumerable<MarkedInfo<FileSystemInfo>> fileSystemItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions> moveParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TransferResult<FileSystemInfo>[] MoveFileSystemInfos(this IEnumerable<FileSystemInfo> fileSystemInfos, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, TransferOptions> moveParamsSelector, Func<FileSystemInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TransferResult<FileSystemInfo>[] MoveFileSystemInfos(this IEnumerable<FileSystemInfo> fileSystemInfos, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileSystemInfo, TransferOptions> moveParamsSelector, Func<FileSystemInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

ReplaceFileSystemInfos methods - File System objects replace methods.

File System objects asynchronus replace methods

public static IAsyncEnumerable<TReplaceResult> ReplaceFileSystemInfosAsync<TFileSystemItem, TReplaceResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, ReplaceOptions> replaceParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, FileSystemInfo, FileSystemInfo?, TReplaceResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IAsyncEnumerable<ReplaceResult<FileSystemInfo>> ReplaceFileSystemInfosAsync(this IEnumerable<MarkedInfo<FileSystemInfo>> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, FileSystemTraversalMarker, ReplaceOptions> replaceParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IAsyncEnumerable<ReplaceResult<FileSystemInfo>> ReplaceFileSystemInfosAsync(this IEnumerable<FileSystemInfo> fileSystemInfos, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, ReplaceOptions> replaceParamsSelector, Func<FileSystemInfo, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

File System objects deferred replace methods

public static IEnumerable<TReplaceResult> ReplaceFileSystemInfosDefer<TFileSystemItem, TReplaceResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, ReplaceOptions> replaceParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, FileSystemInfo, FileSystemInfo?, TReplaceResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TReplaceResult> ReplaceFileSystemInfosDefer<TFileSystemItem, TReplaceResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, ReplaceOptions> replaceParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, FileSystemInfo, FileSystemInfo?, TReplaceResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<ReplaceResult<FileSystemInfo>> ReplaceFileSystemInfosDefer(this IEnumerable<MarkedInfo<FileSystemInfo>> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, FileSystemTraversalMarker, ReplaceOptions> replaceParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<ReplaceResult<FileSystemInfo>> ReplaceFileSystemInfosDefer(this IEnumerable<MarkedInfo<FileSystemInfo>> fileSystemItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileSystemInfo, FileSystemTraversalMarker, ReplaceOptions> replaceParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<ReplaceResult<FileSystemInfo>> ReplaceFileSystemInfosDefer(this IEnumerable<FileSystemInfo> fileSystemInfos, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, ReplaceOptions> replaceParamsSelector, Func<FileSystemInfo, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<ReplaceResult<FileSystemInfo>> ReplaceFileSystemInfosDefer(this IEnumerable<FileSystemInfo> fileSystemInfos, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileSystemInfo, ReplaceOptions> replaceParamsSelector, Func<FileSystemInfo, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

File System objects direct replace methods

public static TReplaceResult[] ReplaceFileSystemInfos<TFileSystemItem, TReplaceResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, ReplaceOptions> replaceParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, FileSystemInfo, FileSystemInfo?, TReplaceResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TReplaceResult[] ReplaceFileSystemInfos<TFileSystemItem, TReplaceResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, ReplaceOptions> replaceParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, FileSystemInfo, FileSystemInfo?, TReplaceResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static ReplaceResult<FileSystemInfo>[] ReplaceFileSystemInfos(this IEnumerable<MarkedInfo<FileSystemInfo>> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, FileSystemTraversalMarker, ReplaceOptions> replaceParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static ReplaceResult<FileSystemInfo>[] ReplaceFileSystemInfos(this IEnumerable<MarkedInfo<FileSystemInfo>> fileSystemItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileSystemInfo, FileSystemTraversalMarker, ReplaceOptions> replaceParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static ReplaceResult<FileSystemInfo>[] ReplaceFileSystemInfos(this IEnumerable<FileSystemInfo> fileSystemInfos, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, ReplaceOptions> replaceParamsSelector, Func<FileSystemInfo, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static ReplaceResult<FileSystemInfo>[] ReplaceFileSystemInfos(this IEnumerable<FileSystemInfo> fileSystemInfos, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileSystemInfo, ReplaceOptions> replaceParamsSelector, Func<FileSystemInfo, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

DeleteFileSystemInfos methods - File System objects delete methods.

File System objects asynchronus delete methods

public static IAsyncEnumerable<TDeleteResult> DeleteFileSystemInfosAsync<TFileSystemItem, TDeleteResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, DeleteOptions> deleteParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TDeleteResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IAsyncEnumerable<InfoResult<FileSystemInfo>> DeleteFileSystemInfosAsync(this IEnumerable<MarkedInfo<FileSystemInfo>> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, FileSystemTraversalMarker, DeleteOptions> deleteParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IAsyncEnumerable<InfoResult<FileSystemInfo>> DeleteFileSystemInfosAsync(this IEnumerable<FileSystemInfo> fileSystemInfos, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, DeleteOptions> deleteParamsSelector, Func<FileSystemInfo, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

File System objects deferred delete methods

public static IEnumerable<TDeleteResult> DeleteFileSystemInfosDefer<TFileSystemItem, TDeleteResult>(this IEnumerable<TFileSystemItem> fileItems, FileSystemManipulationOptions manipulationOptions, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, DeleteOptions> deleteParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TDeleteResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TDeleteResult> DeleteFileSystemInfosDefer<TFileSystemItem, TDeleteResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, DeleteOptions> deleteParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TDeleteResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<InfoResult<FileSystemInfo>> DeleteFileSystemInfosDefer(this IEnumerable<MarkedInfo<FileSystemInfo>> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, FileSystemTraversalMarker, DeleteOptions> deleteParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<InfoResult<FileSystemInfo>> DeleteFileSystemInfosDefer(this IEnumerable<MarkedInfo<FileSystemInfo>> fileSystemItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileSystemInfo, FileSystemTraversalMarker, DeleteOptions> deleteParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<InfoResult<FileSystemInfo>> DeleteFileSystemInfosDefer(this IEnumerable<FileSystemInfo> fileSystemInfos, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, DeleteOptions> deleteParamsSelector, Func<FileSystemInfo, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<InfoResult<FileSystemInfo>> DeleteFileSystemInfosDefer(this IEnumerable<FileSystemInfo> fileSystemInfos, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileSystemInfo, DeleteOptions> deleteParamsSelector, Func<FileSystemInfo, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

File System objects direct delete methods

public static TDeleteResult[] DeleteFileSystemInfos<TDirectoryItem, TDeleteResult>(this IEnumerable<TDirectoryItem> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<TDirectoryItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TDirectoryItem, DeleteOptions> deleteParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TDeleteResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TDeleteResult[] DeleteFileSystemInfos<TFileSystemItem, TDeleteResult>(this IEnumerable<TFileSystemItem> fileSystemItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileSystemItem, MarkedInfo<FileSystemInfo>> markedInfoSelector, Func<TFileSystemItem, DeleteOptions> deleteParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TDeleteResult> resultSelector, Func<FileSystemInfo, FileSystemTraversalMarker, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static InfoResult<FileSystemInfo>[] DeleteFileSystemInfos(this IEnumerable<MarkedInfo<FileSystemInfo>> fileSystemItems, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, FileSystemTraversalMarker, DeleteOptions> deleteParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static InfoResult<FileSystemInfo>[] DeleteFileSystemInfos(this IEnumerable<MarkedInfo<FileSystemInfo>> fileSystemItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileSystemInfo, FileSystemTraversalMarker, DeleteOptions> deleteParamsSelector, Func<FileSystemInfo, FileSystemTraversalMarker, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static InfoResult<FileSystemInfo>[] DeleteFileSystemInfos(this IEnumerable<FileSystemInfo> fileSystemInfos, FileSystemManipulationOptions manipulationOptions, Func<FileSystemInfo, DeleteOptions> deleteParamsSelector, Func<FileSystemInfo, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static InfoResult<FileSystemInfo>[] DeleteFileSystemInfos(this IEnumerable<FileSystemInfo> fileSystemInfos, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileSystemInfo, DeleteOptions> deleteParamsSelector, Func<FileSystemInfo, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

ManipulateDirectories methods - Directories manipulation methods.

Directories manipulation deferred methods

public static IEnumerable<TManipulationResult> ManipulateDirectoriesDefer<TDirectoryItem, TManipulationParams, TManipulationInterim, TManipulationResult>(this IEnumerable<TDirectoryItem> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<TDirectoryItem, MarkedInfo<DirectoryInfo>> markedInfoSelector, Func<TDirectoryItem, TManipulationParams> manipulationParamsSelector, Func<DirectoryInfo, FileSystemTraversalMarker, TManipulationParams, TManipulationInterim?> directoryHandler, Func<DirectoryInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TManipulationInterim?, TManipulationResult> resultSelector, Func<DirectoryInfo, FileSystemTraversalMarker, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TManipulationResult> ManipulateDirectoriesDefer<TDirectoryItem, TManipulationParams, TManipulationResult>(this IEnumerable<TDirectoryItem> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<TDirectoryItem, MarkedInfo<DirectoryInfo>> markedInfoSelector, Func<TDirectoryItem, TManipulationParams> manipulationParamsSelector, Action<DirectoryInfo, FileSystemTraversalMarker, TManipulationParams> directoryHandler, Func<DirectoryInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TManipulationResult> resultSelector, Func<DirectoryInfo, FileSystemTraversalMarker, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

Directories manipulation direct methods

public static TManipulationResult[] ManipulateDirectories<TDirectoryItem, TManipulationOptions, TManipulationInterim, TManipulationResult>(this IEnumerable<TDirectoryItem> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<TDirectoryItem, MarkedInfo<DirectoryInfo>> markedInfoSelector, Func<TDirectoryItem, TManipulationOptions> manipulationParamsSelector, Func<DirectoryInfo, FileSystemTraversalMarker, TManipulationOptions, TManipulationInterim?> directoryHandler, Func<DirectoryInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TManipulationInterim?, TManipulationResult> resultSelector, Func<DirectoryInfo, FileSystemTraversalMarker, TManipulationOptions?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TManipulationResult[] ManipulateDirectories<TDirectoryItem, TManipulationOptions, TManipulationResult>(this IEnumerable<TDirectoryItem> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<TDirectoryItem, MarkedInfo<DirectoryInfo>> markedInfoSelector, Func<TDirectoryItem, TManipulationOptions> manipulationParamsSelector, Action<DirectoryInfo, FileSystemTraversalMarker, TManipulationOptions> directoryHandler, Func<DirectoryInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TManipulationResult> resultSelector, Func<DirectoryInfo, FileSystemTraversalMarker, TManipulationOptions?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

ReplicateDirectories methods - Directories replication methods.

Directories replication deferred methods

public static IEnumerable<TReplicationResult> ReplicateDirectoriesDefer<TDirectoryItem, TReplicationResult>(this IEnumerable<TDirectoryItem> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<TDirectoryItem, MarkedInfo<DirectoryInfo>> markedInfoSelector, Func<TDirectoryItem, ReplicateOptions> replicationParametersSelector, Func<DirectoryInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, DirectoryInfo?, TReplicationResult> resultSelector, Func<DirectoryInfo, FileSystemTraversalMarker, ReplicateOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TransferResult<DirectoryInfo>> ReplicateDirectoriesDefer(this IEnumerable<MarkedInfo<DirectoryInfo>> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<DirectoryInfo, FileSystemTraversalMarker, ReplicateOptions> replicationParametersSelector, Func<DirectoryInfo, FileSystemTraversalMarker, ReplicateOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TransferResult<DirectoryInfo>> ReplicateDirectoriesDefer(this IEnumerable<DirectoryInfo> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<DirectoryInfo, ReplicateOptions> replicationParametersSelector, Func<DirectoryInfo, ReplicateOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

Directories replication direct methods

public static TReplicationResult[] ReplicateDirectories<TDirectoryItem, TReplicationResult>(this IEnumerable<TDirectoryItem> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<TDirectoryItem, MarkedInfo<DirectoryInfo>> markedInfoSelector, Func<TDirectoryItem, ReplicateOptions> replicationParametersSelector, Func<DirectoryInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, DirectoryInfo?, TReplicationResult> resultSelector, Func<DirectoryInfo, FileSystemTraversalMarker, ReplicateOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TransferResult<DirectoryInfo>[] ReplicateDirectories(this IEnumerable<MarkedInfo<DirectoryInfo>> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<DirectoryInfo, FileSystemTraversalMarker, ReplicateOptions> replicationParametersSelector, Func<DirectoryInfo, FileSystemTraversalMarker, ReplicateOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TransferResult<DirectoryInfo>[] ReplicateDirectories(this IEnumerable<DirectoryInfo> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<DirectoryInfo, ReplicateOptions> replicationParametersSelector, Func<DirectoryInfo, ReplicateOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

CleanupDirectories methods - Directories cleanup methods.

Directories cleanup deferred methods

public static IEnumerable<TCleanupResult> CleanupDirectoriesDefer<TDirectoryItem, TCleanupResult>(this IEnumerable<TDirectoryItem> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<TDirectoryItem, MarkedInfo<DirectoryInfo>> markedInfoSelector, Func<DirectoryInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TCleanupResult> resultSelector, Func<DirectoryInfo, FileSystemTraversalMarker, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<InfoResult<DirectoryInfo>> CleanupDirectoriesDefer(this IEnumerable<MarkedInfo<DirectoryInfo>> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<DirectoryInfo, FileSystemTraversalMarker, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<InfoResult<DirectoryInfo>> CleanupDirectoriesDefer(this IEnumerable<DirectoryInfo> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<DirectoryInfo, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

Directories cleanup direct methods

public static TCleanupResult[] CleanupDirectories<TDirectoryItem, TCleanupResult>(this IEnumerable<TDirectoryItem> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<TDirectoryItem, MarkedInfo<DirectoryInfo>> markedInfoSelector, Func<DirectoryInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TCleanupResult> resultSelector, Func<DirectoryInfo, FileSystemTraversalMarker, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static InfoResult<DirectoryInfo>[] CleanupDirectories(this IEnumerable<MarkedInfo<DirectoryInfo>> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<DirectoryInfo, FileSystemTraversalMarker, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static InfoResult<DirectoryInfo>[] CleanupDirectories(this IEnumerable<DirectoryInfo> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<DirectoryInfo, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

MoveDirectories methods - Directories move methods.

Directories deferred move methods

public static IEnumerable<TTransferResult> MoveDirectoriesDefer<TDirectoryItem, TTransferResult>(this IEnumerable<TDirectoryItem> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<TDirectoryItem, MarkedInfo<DirectoryInfo>> markedInfoSelector, Func<TDirectoryItem, TransferOptions> moveParamsSelector, Func<DirectoryInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, DirectoryInfo, TTransferResult> resultSelector, Func<DirectoryInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TransferResult<DirectoryInfo>> MoveDirectoriesDefer(this IEnumerable<MarkedInfo<DirectoryInfo>> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<DirectoryInfo, FileSystemTraversalMarker, TransferOptions> moveParamsSelector, Func<DirectoryInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TransferResult<DirectoryInfo>> MoveDirectoriesDefer(this IEnumerable<DirectoryInfo> directoryInfos, FileSystemManipulationOptions manipulationOptions, Func<DirectoryInfo, TransferOptions> moveParamsSelector, Func<DirectoryInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

Directories direct move methods

public static TTransferResult[] MoveDirectories<TDirectoryItem, TTransferResult>(this IEnumerable<TDirectoryItem> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<TDirectoryItem, MarkedInfo<DirectoryInfo>> markedInfoSelector, Func<TDirectoryItem, TransferOptions> moveParamsSelector, Func<DirectoryInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, DirectoryInfo?, TTransferResult> resultSelector, Func<DirectoryInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TransferResult<DirectoryInfo>[] MoveDirectories(this IEnumerable<MarkedInfo<DirectoryInfo>> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<DirectoryInfo, FileSystemTraversalMarker, TransferOptions> moveParamsSelector, Func<DirectoryInfo, FileSystemTraversalMarker, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TransferResult<DirectoryInfo>[] MoveDirectories(this IEnumerable<DirectoryInfo> directoryInfos, FileSystemManipulationOptions manipulationOptions, Func<DirectoryInfo, TransferOptions> moveParamsSelector, Func<DirectoryInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

DeleteDirectories methods - Directories delete methods.

Directories deferred delete methods

public static IEnumerable<TDeleteResult> DeleteDirectoriesDefer<TDirectoryItem, TDeleteResult>(this IEnumerable<TDirectoryItem> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<TDirectoryItem, MarkedInfo<DirectoryInfo>> markedInfoSelector, Func<TDirectoryItem, DeleteOptions> deleteParamsSelector, Func<DirectoryInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TDeleteResult> resultSelector, Func<DirectoryInfo, FileSystemTraversalMarker, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<InfoResult<DirectoryInfo>> DeleteDirectoriesDefer(this IEnumerable<MarkedInfo<DirectoryInfo>> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<DirectoryInfo, FileSystemTraversalMarker, DeleteOptions> deleteParamsSelector, Func<DirectoryInfo, FileSystemTraversalMarker, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<InfoResult<DirectoryInfo>> DeleteDirectoriesDefer(this IEnumerable<DirectoryInfo> directoryInfos, FileSystemManipulationOptions manipulationOptions, Func<DirectoryInfo, DeleteOptions> deleteParamsSelector, Func<DirectoryInfo, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

Directories direct delete methods

public static TDeleteResult[] DeleteDirectories<TDirectoryItem, TDeleteResult>(this IEnumerable<TDirectoryItem> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<TDirectoryItem, MarkedInfo<DirectoryInfo>> markedInfoSelector, Func<TDirectoryItem, DeleteOptions> deleteParamsSelector, Func<DirectoryInfo, FileSystemTraversalMarker, FileSystemManipulationMarker, TDeleteResult> resultSelector, Func<DirectoryInfo, FileSystemTraversalMarker, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static InfoResult<DirectoryInfo>[] DeleteDirectories(this IEnumerable<MarkedInfo<DirectoryInfo>> directoryItems, FileSystemManipulationOptions manipulationOptions, Func<DirectoryInfo, FileSystemTraversalMarker, DeleteOptions> deleteParamsSelector, Func<DirectoryInfo, FileSystemTraversalMarker, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static InfoResult<DirectoryInfo>[] DeleteDirectories(this IEnumerable<DirectoryInfo> directoryInfos, FileSystemManipulationOptions manipulationOptions, Func<DirectoryInfo, DeleteOptions> deleteParamsSelector, Func<DirectoryInfo, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

ManipulateFiles methods - Files manipulation methods.

Files manipulation asynchronus methods

public static IAsyncEnumerable<TManipulationResult> ManipulateFilesAsync<TFileItem, TManipulationParams, TManipulationInterim, TManipulationResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, TManipulationParams> manipulationParamsSelector, Func<FileInfo, TManipulationParams, TManipulationInterim?> fileHandler, Func<FileInfo, FileSystemManipulationMarker, TManipulationInterim?, TManipulationResult> resultSelector, Func<FileInfo, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IAsyncEnumerable<TManipulationResult> ManipulateFilesAsync<TFileItem, TManipulationParams, TManipulationResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, TManipulationParams> manipulationParamsSelector, Action<FileInfo, TManipulationParams> fileHandler, Func<FileInfo, FileSystemManipulationMarker, TManipulationResult> resultSelector, Func<FileInfo, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

File System objects manipulation deferred methods

public static IEnumerable<TManipulationResult> ManipulateFilesDefer<TFileItem, TManipulationParams, TManipulationInterim, TManipulationResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, TManipulationParams> manipulationParamsSelector, Func<FileInfo, TManipulationParams, TManipulationInterim?> fileHandler, Func<FileInfo, FileSystemManipulationMarker, TManipulationInterim?, TManipulationResult> resultSelector, Func<FileInfo, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TManipulationResult> ManipulateFilesDefer<TFileItem, TManipulationParams, TManipulationInterim, TManipulationResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, TManipulationParams> manipulationParamsSelector, Func<FileInfo, TManipulationParams, TManipulationInterim?> fileHandler, Func<FileInfo, FileSystemManipulationMarker, TManipulationInterim?, TManipulationResult> resultSelector, Func<FileInfo, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TManipulationResult> ManipulateFilesDefer<TFileItem, TManipulationParams, TManipulationInterim, TManipulationResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, TManipulationParams> manipulationParamsSelector, Action<FileInfo, TManipulationParams> fileHandler, Func<FileInfo, FileSystemManipulationMarker, TManipulationResult> resultSelector, Func<FileInfo, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TManipulationResult> ManipulateFilesDefer<TFileItem, TManipulationParams, TManipulationInterim, TManipulationResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, TManipulationParams> manipulationParamsSelector, Action<FileInfo, TManipulationParams> fileHandler, Func<FileInfo, FileSystemManipulationMarker, TManipulationResult> resultSelector, Func<FileInfo, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

File System objects manipulation direct methods

public static TManipulationResult[] ManipulateFiles<TFileItem, TManipulationParams, TManipulationInterim, TManipulationResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, TManipulationParams> manipulationParamsSelector, Func<FileInfo, TManipulationParams, TManipulationInterim?> fileHandler, Func<FileInfo, FileSystemManipulationMarker, TManipulationInterim?, TManipulationResult> resultSelector, Func<FileInfo, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TManipulationResult[] ManipulateFiles<TFileItem, TManipulationParams, TManipulationInterim, TManipulationResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, TManipulationParams> manipulationParamsSelector, Func<FileInfo, TManipulationParams, TManipulationInterim?> fileHandler, Func<FileInfo, FileSystemManipulationMarker, TManipulationInterim?, TManipulationResult> resultSelector, Func<FileInfo, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TManipulationResult[] ManipulateFiles<TFileItem, TManipulationParams, TManipulationInterim, TManipulationResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, TManipulationParams> manipulationParamsSelector, Action<FileInfo, TManipulationParams> fileHandler, Func<FileInfo, FileSystemManipulationMarker, TManipulationResult> resultSelector, Func<FileInfo, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TManipulationResult[] ManipulateFiles<TFileItem, TManipulationParams, TManipulationInterim, TManipulationResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, TManipulationParams> manipulationParamsSelector, Action<FileInfo, TManipulationParams> fileHandler, Func<FileInfo, FileSystemManipulationMarker, TManipulationResult> resultSelector, Func<FileInfo, TManipulationParams?, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

CopyFiles methods - Files copy methods.

Files asynchronus copy methods

public static IAsyncEnumerable<TTransferResult> CopyFilesAsync<TFileItem, TTransferResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, TransferOptions> copyParamsSelector, Func<FileInfo, FileSystemManipulationMarker, FileInfo?, TTransferResult> resultSelector, Func<FileInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IAsyncEnumerable<TransferResult<FileInfo>> CopyFilesAsync(this IEnumerable<FileInfo> fileInfos, FileSystemManipulationOptions manipulationOptions, Func<FileInfo, TransferOptions> copyParamsSelector, Func<FileInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

Files deferred copy methods

public static IEnumerable<TTransferResult> CopyFilesDefer<TFileItem, TTransferResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, TransferOptions> copyParamsSelector, Func<FileInfo, FileSystemManipulationMarker, FileInfo?, TTransferResult> resultSelector, Func<FileInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TTransferResult> CopyFilesDefer<TFileItem, TTransferResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, TransferOptions> copyParamsSelector, Func<FileInfo, FileSystemManipulationMarker, FileInfo?, TTransferResult> resultSelector, Func<FileInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TransferResult<FileInfo>> CopyFilesDefer(this IEnumerable<FileInfo> fileInfos, FileSystemManipulationOptions manipulationOptions, Func<FileInfo, TransferOptions> copyParamsSelector, Func<FileInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TransferResult<FileInfo>> CopyFilesDefer(this IEnumerable<FileInfo> fileInfos, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileInfo, TransferOptions> copyParamsSelector, Func<FileInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

Files direct copy methods

public static TTransferResult[] CopyFiles<TFileItem, TTransferResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, TransferOptions> copyParamsSelector, Func<FileInfo, FileSystemManipulationMarker, FileInfo?, TTransferResult> resultSelector, Func<FileInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TTransferResult[] CopyFiles<TFileItem, TTransferResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, TransferOptions> copyParamsSelector, Func<FileInfo, FileSystemManipulationMarker, FileInfo?, TTransferResult> resultSelector, Func<FileInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TransferResult<FileInfo>[] CopyFiles(this IEnumerable<FileInfo> fileInfos, FileSystemManipulationOptions manipulationOptions, Func<FileInfo, TransferOptions> copyParamsSelector, Func<FileInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TransferResult<FileInfo>[] CopyFiles(this IEnumerable<FileInfo> fileInfos, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileInfo, TransferOptions> copyParamsSelector, Func<FileInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

MoveFiles methods - Files move methods.

Files asynchronus move methods

public static IAsyncEnumerable<TTransferResult> MoveFilesAsync<TFileItem, TTransferResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, TransferOptions> moveParamsSelector, Func<FileInfo, FileSystemManipulationMarker, FileInfo?, TTransferResult> resultSelector, Func<FileInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IAsyncEnumerable<TransferResult<FileInfo>> MoveFilesAsync(this IEnumerable<FileInfo> fileInfos, FileSystemManipulationOptions manipulationOptions, Func<FileInfo, TransferOptions> moveParamsSelector, Func<FileInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

Files deferred move methods

public static IEnumerable<TTransferResult> MoveFilesDefer<TFileItem, TTransferResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, TransferOptions> moveParamsSelector, Func<FileInfo, FileSystemManipulationMarker, FileInfo?, TTransferResult> resultSelector, Func<FileInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TTransferResult> MoveFilesDefer<TFileItem, TTransferResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, TransferOptions> moveParamsSelector, Func<FileInfo, FileSystemManipulationMarker, FileInfo?, TTransferResult> resultSelector, Func<FileInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TransferResult<FileInfo>> MoveFilesDefer(this IEnumerable<FileInfo> fileInfos, FileSystemManipulationOptions manipulationOptions, Func<FileInfo, TransferOptions> moveParamsSelector, Func<FileInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TransferResult<FileInfo>> MoveFilesDefer(this IEnumerable<FileInfo> fileInfos, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileInfo, TransferOptions> moveParamsSelector, Func<FileInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

Files direct move methods

public static TTransferResult[] MoveFiles<TFileItem, TTransferResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, TransferOptions> moveParamsSelector, Func<FileInfo, FileSystemManipulationMarker, FileInfo?, TTransferResult> resultSelector, Func<FileInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TTransferResult[] MoveFiles<TFileItem, TTransferResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, TransferOptions> moveParamsSelector, Func<FileInfo, FileSystemManipulationMarker, FileInfo?, TTransferResult> resultSelector, Func<FileInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TransferResult<FileInfo>[] MoveFiles(this IEnumerable<FileInfo> fileInfos, FileSystemManipulationOptions manipulationOptions, Func<FileInfo, TransferOptions> moveParamsSelector, Func<FileInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TransferResult<FileInfo>[] MoveFiles(this IEnumerable<FileInfo> fileInfos, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileInfo, TransferOptions> moveParamsSelector, Func<FileInfo, TransferOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

ReplaceFiles methods - Files replace methods.

Files asynchronus replace methods

public static IAsyncEnumerable<TReplaceResult> ReplaceFilesAsync<TFileItem, TReplaceResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, ReplaceOptions> replaceParamsSelector, Func<FileInfo, FileSystemManipulationMarker, FileInfo, FileInfo?, TReplaceResult> resultSelector, Func<FileInfo, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IAsyncEnumerable<ReplaceResult<FileInfo>> ReplaceFilesAsync(this IEnumerable<FileInfo> fileInfos, FileSystemManipulationOptions manipulationOptions, Func<FileInfo, ReplaceOptions> replaceParamsSelector, Func<FileInfo, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

Files deferred replace methods

public static IEnumerable<TReplaceResult> ReplaceFilesDefer<TFileItem, TReplaceResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, ReplaceOptions> replaceParamsSelector, Func<FileInfo, FileSystemManipulationMarker, FileInfo, FileInfo?, TReplaceResult> resultSelector, Func<FileInfo, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TReplaceResult> ReplaceFilesDefer<TFileItem, TReplaceResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, ReplaceOptions> replaceParamsSelector, Func<FileInfo, FileSystemManipulationMarker, FileInfo, FileInfo?, TReplaceResult> resultSelector, Func<FileInfo, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<ReplaceResult<FileInfo>> ReplaceFilesDefer(this IEnumerable<FileInfo> fileInfos, FileSystemManipulationOptions manipulationOptions, Func<FileInfo, ReplaceOptions> replaceParamsSelector, Func<FileInfo, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<ReplaceResult<FileInfo>> ReplaceFilesDefer(this IEnumerable<FileInfo> fileInfos, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileInfo, ReplaceOptions> replaceParamsSelector, Func<FileInfo, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

Files direct replace methods

public static TReplaceResult[] ReplaceFiles<TFileItem, TReplaceResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, ReplaceOptions> replaceParamsSelector, Func<FileInfo, FileSystemManipulationMarker, FileInfo, FileInfo?, TReplaceResult> resultSelector, Func<FileInfo, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TReplaceResult[] ReplaceFiles<TFileItem, TReplaceResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, ReplaceOptions> replaceParamsSelector, Func<FileInfo, FileSystemManipulationMarker, FileInfo, FileInfo?, TReplaceResult> resultSelector, Func<FileInfo, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static ReplaceResult<FileInfo>[] ReplaceFiles(this IEnumerable<FileInfo> fileInfos, FileSystemManipulationOptions manipulationOptions, Func<FileInfo, ReplaceOptions> replaceParamsSelector, Func<FileInfo, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static ReplaceResult<FileInfo>[] ReplaceFiles(this IEnumerable<FileInfo> fileInfos, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileInfo, ReplaceOptions> replaceParamsSelector, Func<FileInfo, ReplaceOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

DeleteFiles methods - Files delete methods.

Files asynchronus delete methods

public static IAsyncEnumerable<TDeleteResult> DeleteFilesAsync<TFileItem, TDeleteResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, DeleteOptions> deleteParamsSelector, Func<FileInfo, FileSystemManipulationMarker, TDeleteResult> resultSelector, Func<FileInfo, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IAsyncEnumerable<InfoResult<FileInfo>> DeleteFilesAsync(this IEnumerable<FileInfo> fileInfos, FileSystemManipulationOptions manipulationOptions, Func<FileInfo, DeleteOptions> deleteParamsSelector, Func<FileInfo, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

Files deferred delete methods

public static IEnumerable<TFileResult> DeleteFilesDefer<TFileItem, TFileResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, DeleteOptions> deleteParamsSelector, Func<FileInfo, FileSystemManipulationMarker, TFileResult> resultSelector, Func<FileInfo, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<TFileResult> DeleteFilesDefer<TFileItem, TFileResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, DeleteOptions> deleteParamsSelector, Func<FileInfo, FileSystemManipulationMarker, TFileResult> resultSelector, Func<FileInfo, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<InfoResult<FileInfo>> DeleteFilesDefer(this IEnumerable<FileInfo> fileInfos, FileSystemManipulationOptions manipulationOptions, Func<FileInfo, DeleteOptions> deleteParamsSelector, Func<FileInfo, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static IEnumerable<InfoResult<FileInfo>> DeleteFilesDefer(this IEnumerable<FileInfo> fileInfos, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileInfo, DeleteOptions> deleteParamsSelector, Func<FileInfo, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

Files direct delete methods

public static TFileResult[] DeleteFiles<TFileItem, TFileResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, DeleteOptions> deleteParamsSelector, Func<FileInfo, FileSystemManipulationMarker, TFileResult> resultSelector, Func<FileInfo, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static TFileResult[] DeleteFiles<TFileItem, TFileResult>(this IEnumerable<TFileItem> fileItems, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<TFileItem, FileInfo> fileInfoSelector, Func<TFileItem, DeleteOptions> deleteParamsSelector, Func<FileInfo, FileSystemManipulationMarker, TFileResult> resultSelector, Func<FileInfo, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static InfoResult<FileInfo>[] DeleteFiles(this IEnumerable<FileInfo> fileInfos, FileSystemManipulationOptions manipulationOptions, Func<FileInfo, DeleteOptions> deleteParamsSelector, Func<FileInfo, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

public static InfoResult<FileInfo>[] DeleteFiles(this IEnumerable<FileInfo> fileInfos, FileSystemManipulationOptions manipulationOptions, int maxConcurrents, Func<FileInfo, DeleteOptions> deleteParamsSelector, Func<FileInfo, DeleteOptions, Exception, bool>? errorHandler = null, CancellationToken cancellationToken = default);

Examples

See the class FileSystemExamples in PowerLib.Examples project in the repository PowerLib.v2.

Home
- PowerLib.System
  - General
  - Arrays
  - Collections
  - FileSystem
  - LINQ
  - Mathematics
  - Reflection
  - Resources
  - Validation

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FileSystem

FileSystem

Examples

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Home

PowerLib.System

General

Arrays

Collections

FileSystem

LINQ

Mathematics

Basic

Combinatorics

Geometry

Reflection

Resources

Validation

Clone this wiki locally