Sample code for C# implementing high-performance file batch processors

/// <summary>
/// File batch processing core class (thread-safe design)/// </summary>
public class FileBatchProcessor
{
    private readonly int _maxThreads =  * 2;
    private readonly ConcurrentQueue<string> _fileQueue = new();
    private readonly CancellationTokenSource _cts = new();
    
    // Support MD5/SHA256 dual algorithm verification    private readonly HashAlgorithm _hashProvider;
    
    public FileBatchProcessor(HashType hashType = HashType.SHA256) 
    {
        _hashProvider = hashType == HashType.MD5 ? 
            () : ();
    }
}

/// <summary>
/// Start multithreaded processing queue/// </summary>
public void StartProcessing(Action<FileTask> processAction)
{
    var parallelOptions = new ParallelOptions {
        MaxDegreeOfParallelism = _maxThreads,
        CancellationToken = _cts.Token
    };
 
    (_fileQueue.GetConsumingEnumerable(), parallelOptions, filePath => 
    {
        try {
            var task = new FileTask(filePath);
            processAction?.Invoke(task);
            GenerateFileHash(task); // Generate hash verification code        }
        catch (IOException ex) {
            LogError($"File operation failed: {}");
        }
    });
}

/// <summary>
/// Get the list of files matching the regularity (refer to web page 5)/// </summary>
public IEnumerable<string> GetFilteredFiles(string directory, string regexPattern)
{
    var regex = new Regex(regexPattern, );
    
    return (directory, "*.*", )
        .Where(file => ((file)))
        .OrderBy(f => f);
}

/// <summary>
/// Perform file renaming operation (supports atomic operation)/// </summary>
public void SafeRenameFile(string sourcePath, string newName)
{
    string targetPath = ((sourcePath), newName);
    
    // Atomic properties used    if ((targetPath)) (targetPath);
    (sourcePath, targetPath);
    
    ($"Rename complete: {(sourcePath)} => {newName}");
}
 
/// <summary>
/// Use to convert image format/// </summary>
public void ConvertImageFormat(string inputPath, MagickFormat outputFormat)
{
    using var image = new MagickImage(inputPath);
     = outputFormat;
    ((inputPath, ().ToLower()));
}

using ;
using ;
using ;
using ImageMagick;
 
namespace FileProcessor
{
    /// <summary>
    /// File processing mode enumeration    /// </summary>
    public enum ProcessMode
    {
        Rename,
        ConvertFormat,
        Both
    }
 
    /// <summary>
    /// File batch processor core class (thread safety)    /// Technical Highlights:    /// 1. Multi-threaded pipeline processing    /// 2. Regular expression file filtering    /// 3. File hash verification    /// 4. Atomic file operation    /// </summary>
    public class FileBatchProcessor : IDisposable
    {
        #region properties and fields        private readonly ConcurrentQueue<string> _fileQueue = new();
        private readonly HashAlgorithm _hashProvider;
        private bool _disposed;
        
        /// <summary>
        /// Maximum number of concurrent threads (default number of CPU cores × 2)        /// </summary>
        public int MaxDegreeOfParallelism { get; set; } =  * 2;
 
        /// <summary>
        /// Convert the target format of the file format (default to JPEG)        /// </summary>
        public MagickFormat TargetFormat { get; set; } = ;
 
        /// <summary>
        /// Regular filtering mode of file name        /// </summary>
        public string? FileNamePattern { get; set; }
        #endregion
 
        #region constructor        public FileBatchProcessor(HashType hashType = HashType.SHA256)
        {
            _hashProvider = hashType switch
            {
                HashType.MD5 => (),
                _ => ()
            };
        }
        #endregion
 
        #region core method        /// <summary>
        /// Add files to the processing queue (regular filtering is supported)        /// </summary>
        /// <param name="directory">Target Directory</param>        /// <param name="searchOption">Search Mode</param>        public void EnqueueFiles(string directory, 
            SearchOption searchOption = )
        {
            var regex = !(FileNamePattern) 
                ? new Regex(FileNamePattern, ) 
                : null;
 
            foreach (var file in (directory, "*.*", searchOption))
            {
                if (regex == null || ((file)))
                {
                    _fileQueue.Enqueue(file);
                }
            }
        }
 
        /// &lt;summary&gt;
        /// Start the batch processing process        /// &lt;/summary&gt;
        /// <param name="renamePattern">New file name mode (supports {name}, {ext} placeholders)</param>        /// <param name="mode">processing mode</param>        public void ProcessFiles(string renamePattern, ProcessMode mode)
        {
            (_fileQueue, new ParallelOptions
            {
                MaxDegreeOfParallelism = MaxDegreeOfParallelism
            }, file =&gt;
            {
                try
                {
                    var task = new FileProcessTask(file);
                    
                    // Perform renaming                    if (mode is  or )
                    {
                        var newName = BuildNewFileName(file, renamePattern);
                        SafeRenameFile(task, newName);
                    }
 
                    // Perform format conversion                    if (mode is  or )
                    {
                        ConvertFileFormat(task);
                    }
 
                    // Generate file hash                    GenerateFileHash(task);
                    LogResult(task);
                }
                catch (Exception ex)
                {
                    LogError($"Processing failed: {file} - {}");
                }
            });
        }
        #endregion
 
        #region Business logic method        /// &lt;summary&gt;
        /// Build a new file name (supports dynamic templates)        /// &lt;/summary&gt;
        private string BuildNewFileName(string originalPath, string pattern)
        {
            string dir = (originalPath)!;
            string name = (originalPath);
            string ext = (originalPath);
            
            return (dir, 
                pattern
                    .Replace("{name}", name)
                    .Replace("{ext}", ext)
                    .Replace("{timestamp}", $"{:yyyyMMddHHmmss}")
                );
        }
 
        /// &lt;summary&gt;
        /// Safely rename files (atomic operations)        /// &lt;/summary&gt;
        private void SafeRenameFile(FileProcessTask task, string newPath)
        {
            if ((newPath)) (newPath);
            (, newPath);
             = newPath;
        }
 
        /// &lt;summary&gt;
        /// Convert file format (used)        /// &lt;/summary&gt;
        private void ConvertFileFormat(FileProcessTask task)
        {
            using var image = new MagickImage();
             = TargetFormat;
            string newPath = (, 
                ().ToLower());
            (newPath);
            
            if (newPath != ) 
            {
                ();
                 = newPath;
            }
        }
 
        /// &lt;summary&gt;
        /// Generate file hash value        /// &lt;/summary&gt;
        private void GenerateFileHash(FileProcessTask task)
        {
            using var stream = ();
            byte[] hashBytes = _hashProvider.ComputeHash(stream);
             = (hashBytes).Replace("-", "");
        }
        #endregion
 
        #region helper method        private void LogResult(FileProcessTask task)
        {
            ($"""
                ======== Processing is completed ========
                Original file: {()}
                New path: {()}
                File hashing: {}
                Processing time: {:yyyy-MM-dd HH:mm:ss}
                """);
        }
 
        private void LogError(string message)
        {
             = ;
            ($"[ERROR] {:HH:mm:ss} {message}");
            ();
        }
        #endregion
 
        #region Free resources        public void Dispose()
        {
            if (_disposed) return;
            _hashProvider.Dispose();
            _disposed = true;
            (this);
        }
        #endregion
    }
 
    /// &lt;summary&gt;
    /// File processing task object    /// &lt;/summary&gt;
    public class FileProcessTask
    {
        public string OriginalPath { get; }
        public string? NewPath { get; set; }
        public string FileHash { get; set; } = ;
 
        public string CurrentPath =&gt; NewPath ?? OriginalPath;
 
        public FileProcessTask(string path) =&gt; OriginalPath = path;
    }
 
    public enum HashType { MD5, SHA256 }
}

using var processor = new FileBatchProcessor(HashType.SHA256) 
{
    FileNamePattern = @"\.(jpg|png)$", // Filter image files    TargetFormat =    // Set the conversion format};

// Load all matching files in the D disk Images directory(@"D:\Images");

// Perform renaming + format conversion(
    renamePattern: "converted_{name}_{timestamp}.webp",
    mode: 
);