C#实现高性能文件批量处理器的示例代码

/// <summary>
/// 文件批处理核心类（线程安全设计）
/// </summary>
public class filebatchprocessor
{
    private readonly int _maxthreads = environment.processorcount * 2;
    private readonly concurrentqueue<string> _filequeue = new();
    private readonly cancellationtokensource _cts = new();
    
    // 支持md5/sha256双算法校验
    private readonly hashalgorithm _hashprovider;
    
    public filebatchprocessor(hashtype hashtype = hashtype.sha256) 
    {
        _hashprovider = hashtype == hashtype.md5 ? 
            md5.create() : sha256.create();
    }
}

/// <summary>
/// 启动多线程处理队列
/// </summary>
public void startprocessing(action<filetask> processaction)
{
    var paralleloptions = new paralleloptions {
        maxdegreeofparallelism = _maxthreads,
        cancellationtoken = _cts.token
    };
 
    parallel.foreach(_filequeue.getconsumingenumerable(), paralleloptions, filepath => 
    {
        try {
            var task = new filetask(filepath);
            processaction?.invoke(task);
            generatefilehash(task); // 生成哈希校验码
        }
        catch (ioexception ex) {
            logerror($"文件操作失败: {ex.message}");
        }
    });
}

/// <summary>
/// 获取匹配正则的文件列表（参考网页5）
/// </summary>
public ienumerable<string> getfilteredfiles(string directory, string regexpattern)
{
    var regex = new regex(regexpattern, regexoptions.ignorecase);
    
    return directory.enumeratefiles(directory, "*.*", searchoption.alldirectories)
        .where(file => regex.ismatch(path.getfilename(file)))
        .orderby(f => f);
}

/// <summary>
/// 执行文件重命名操作（支持原子操作）
/// </summary>
public void saferenamefile(string sourcepath, string newname)
{
    string targetpath = path.combine(path.getdirectoryname(sourcepath), newname);
    
    // 使用file.move的原子特性
    if (file.exists(targetpath)) file.delete(targetpath);
    file.move(sourcepath, targetpath);
    
    console.writeline($"重命名完成: {path.getfilename(sourcepath)} => {newname}");
}
 
/// <summary>
/// 使用magick.net进行图像格式转换
/// </summary>
public void convertimageformat(string inputpath, magickformat outputformat)
{
    using var image = new magickimage(inputpath);
    image.format = outputformat;
    image.write(path.changeextension(inputpath, outputformat.tostring().tolower()));
}

using system.collections.concurrent;
using system.security.cryptography;
using system.text.regularexpressions;
using imagemagick;
 
namespace fileprocessor
{
    /// <summary>
    /// 文件处理模式枚举
    /// </summary>
    public enum processmode
    {
        rename,
        convertformat,
        both
    }
 
    /// <summary>
    /// 文件批量处理器核心类（线程安全）
    /// 技术亮点：
    /// 1. 多线程流水线处理
    /// 2. 正则表达式文件过滤
    /// 3. 文件哈希校验
    /// 4. 原子性文件操作
    /// </summary>
    public class filebatchprocessor : idisposable
    {
        #region 属性与字段
        private readonly concurrentqueue<string> _filequeue = new();
        private readonly hashalgorithm _hashprovider;
        private bool _disposed;
        
        /// <summary>
        /// 最大并发线程数（默认cpu核心数×2）
        /// </summary>
        public int maxdegreeofparallelism { get; set; } = environment.processorcount * 2;
 
        /// <summary>
        /// 文件格式转换目标格式（默认转jpeg）
        /// </summary>
        public magickformat targetformat { get; set; } = magickformat.jpeg;
 
        /// <summary>
        /// 文件名正则过滤模式
        /// </summary>
        public string? filenamepattern { get; set; }
        #endregion
 
        #region 构造函数
        public filebatchprocessor(hashtype hashtype = hashtype.sha256)
        {
            _hashprovider = hashtype switch
            {
                hashtype.md5 => md5.create(),
                _ => sha256.create()
            };
        }
        #endregion
 
        #region 核心方法
        /// <summary>
        /// 添加文件到处理队列（支持正则过滤）
        /// </summary>
        /// <param name="directory">目标目录</param>
        /// <param name="searchoption">搜索模式</param>
        public void enqueuefiles(string directory, 
            searchoption searchoption = searchoption.alldirectories)
        {
            var regex = !string.isnullorempty(filenamepattern) 
                ? new regex(filenamepattern, regexoptions.ignorecase) 
                : null;
 
            foreach (var file in directory.enumeratefiles(directory, "*.*", searchoption))
            {
                if (regex == null || regex.ismatch(path.getfilename(file)))
                {
                    _filequeue.enqueue(file);
                }
            }
        }
 
        /// <summary>
        /// 启动批量处理流程
        /// </summary>
        /// <param name="renamepattern">新文件名模式（支持{name}、{ext}占位符）</param>
        /// <param name="mode">处理模式</param>
        public void processfiles(string renamepattern, processmode mode)
        {
            parallel.foreach(_filequeue, new paralleloptions
            {
                maxdegreeofparallelism = maxdegreeofparallelism
            }, file =>
            {
                try
                {
                    var task = new fileprocesstask(file);
                    
                    // 执行重命名
                    if (mode is processmode.rename or processmode.both)
                    {
                        var newname = buildnewfilename(file, renamepattern);
                        saferenamefile(task, newname);
                    }
 
                    // 执行格式转换
                    if (mode is processmode.convertformat or processmode.both)
                    {
                        convertfileformat(task);
                    }
 
                    // 生成文件哈希
                    generatefilehash(task);
                    logresult(task);
                }
                catch (exception ex)
                {
                    logerror($"处理失败: {file} - {ex.message}");
                }
            });
        }
        #endregion
 
        #region 业务逻辑方法
        /// <summary>
        /// 构建新文件名（支持动态模板）
        /// </summary>
        private string buildnewfilename(string originalpath, string pattern)
        {
            string dir = path.getdirectoryname(originalpath)!;
            string name = path.getfilenamewithoutextension(originalpath);
            string ext = path.getextension(originalpath);
            
            return path.combine(dir, 
                pattern
                    .replace("{name}", name)
                    .replace("{ext}", ext)
                    .replace("{timestamp}", $"{datetime.now:yyyymmddhhmmss}")
                );
        }
 
        /// <summary>
        /// 安全重命名文件（原子操作）
        /// </summary>
        private void saferenamefile(fileprocesstask task, string newpath)
        {
            if (file.exists(newpath)) file.delete(newpath);
            file.move(task.originalpath, newpath);
            task.newpath = newpath;
        }
 
        /// <summary>
        /// 转换文件格式（使用magick.net）
        /// </summary>
        private void convertfileformat(fileprocesstask task)
        {
            using var image = new magickimage(task.currentpath);
            image.format = targetformat;
            string newpath = path.changeextension(task.currentpath, 
                targetformat.tostring().tolower());
            image.write(newpath);
            
            if (newpath != task.currentpath) 
            {
                file.delete(task.currentpath);
                task.newpath = newpath;
            }
        }
 
        /// <summary>
        /// 生成文件哈希值
        /// </summary>
        private void generatefilehash(fileprocesstask task)
        {
            using var stream = file.openread(task.currentpath);
            byte[] hashbytes = _hashprovider.computehash(stream);
            task.filehash = bitconverter.tostring(hashbytes).replace("-", "");
        }
        #endregion
 
        #region 辅助方法
        private void logresult(fileprocesstask task)
        {
            console.writeline($"""
                ======== 处理完成 ========
                原文件: {path.getfilename(task.originalpath)}
                新路径: {path.getfilename(task.newpath)}
                文件哈希: {task.filehash}
                处理时间: {datetime.now:yyyy-mm-dd hh:mm:ss}
                """);
        }
 
        private void logerror(string message)
        {
            console.foregroundcolor = consolecolor.red;
            console.writeline($"[error] {datetime.now:hh:mm:ss} {message}");
            console.resetcolor();
        }
        #endregion
 
        #region 释放资源
        public void dispose()
        {
            if (_disposed) return;
            _hashprovider.dispose();
            _disposed = true;
            gc.suppressfinalize(this);
        }
        #endregion
    }
 
    /// <summary>
    /// 文件处理任务对象
    /// </summary>
    public class fileprocesstask
    {
        public string originalpath { get; }
        public string? newpath { get; set; }
        public string filehash { get; set; } = string.empty;
 
        public string currentpath => newpath ?? originalpath;
 
        public fileprocesstask(string path) => originalpath = path;
    }
 
    public enum hashtype { md5, sha256 }
}

using var processor = new filebatchprocessor(hashtype.sha256) 
{
    filenamepattern = @"\.(jpg|png)$", // 筛选图片文件
    targetformat = magickformat.webp   // 设置转换格式
};

// 加载d盘images目录下所有匹配文件
processor.enqueuefiles(@"d:\images");

// 执行重命名+格式转换
processor.processfiles(
    renamepattern: "converted_{name}_{timestamp}.webp",
    mode: processmode.both
);