C#高性能异步执行多任务（读取文件夹）的最优方案咨询

咱们先拆解下你遇到的核心问题：批量读取文件夹大小和文件数量后进程变慢，本质上是无限制并发导致的资源过载——文件系统本身有并发上限，线程池也扛不住无限多的任务，反而会让等待时间变长。下面给你几个经过生产环境验证的最优实现方案：

方案一：用Parallel.ForEach+并发控制（推荐，简单高效） #

对于IO密集型的文件操作，Parallel.ForEach结合ParallelOptions控制并发数是最省心的方式，它会自动管理线程池资源，避免过载。

// 注意把Main改成async（C#7.1及以上支持）
static async Task Main(string[] args)
{
    try
    {
        DbManager dbManager = new DbManager();
        DataTable _dtDirectoriesToWork = dbManager.SelectDir...; // 你的数据库查询逻辑

        // 控制并发数：建议设为CPU核心数*2，或者根据你的存储性能测试调整
        var parallelOpts = new ParallelOptions
        {
            MaxDegreeOfParallelism = Environment.ProcessorCount * 2
        };

        // 并行遍历所有文件夹
        Parallel.ForEach(_dtDirectoriesToWork.AsEnumerable(), parallelOpts, row =>
        {
            string dirPath = row["DirectoryPath"].ToString();
            if (!Directory.Exists(dirPath)) return;

            // 获取文件夹统计信息
            var (fileCount, totalSize) = GetDirectoryStats(dirPath);

            // 注意：如果DbManager不是线程安全的，一定要加锁！
            lock (dbManager)
            {
                dbManager.UpdateDirectoryStats(dirPath, fileCount, totalSize);
            }
        });
    }
    catch (Exception ex)
    {
        Console.WriteLine($"处理出错：{ex.Message}");
    }
}

// 同步获取文件夹统计（文件IO的异步API本质也是线程池处理，同步+并行控制更稳定）
private static (int FileCount, long TotalSize) GetDirectoryStats(string dirPath)
{
    int fileCount = 0;
    long totalSize = 0;

    try
    {
        // 遍历所有文件，记得处理权限问题
        foreach (var file in Directory.EnumerateFiles(dirPath, "*.*", SearchOption.AllDirectories))
        {
            try
            {
                var fileInfo = new FileInfo(file);
                fileCount++;
                totalSize += fileInfo.Length;
            }
            catch (UnauthorizedAccessException)
            {
                // 跳过无权限的文件，继续处理其他
                continue;
            }
        }
    }
    catch (UnauthorizedAccessException)
    {
        // 整个文件夹无权限，直接返回空统计
    }

    return (fileCount, totalSize);
}

方案二：异步任务+SemaphoreSlim（适合需要纯异步场景） #

如果你业务逻辑必须用异步/await模式，那用SemaphoreSlim来限制同时运行的异步任务数量，避免线程池被耗尽：

static async Task Main(string[] args)
{
    try
    {
        DbManager dbManager = new DbManager();
        DataTable _dtDirectoriesToWork = dbManager.SelectDir...;

        // 限制同时运行的任务数，比如10个（根据实际情况调整）
        var semaphore = new SemaphoreSlim(10);
        var taskList = new List<Task>();

        foreach (var row in _dtDirectoriesToWork.AsEnumerable())
        {
            await semaphore.WaitAsync();
            string dirPath = row["DirectoryPath"].ToString();

            taskList.Add(Task.Run(async () =>
            {
                try
                {
                    if (Directory.Exists(dirPath))
                    {
                        var (fileCount, totalSize) = await GetDirectoryStatsAsync(dirPath);
                        // 同样注意数据库操作的线程安全
                        lock (dbManager)
                        {
                            dbManager.UpdateDirectoryStats(dirPath, fileCount, totalSize);
                        }
                    }
                }
                finally
                {
                    // 不管成功失败，都要释放信号量
                    semaphore.Release();
                }
            }));
        }

        // 等待所有任务完成
        await Task.WhenAll(taskList);
    }
    catch (Exception ex)
    {
        Console.WriteLine($"处理出错：{ex.Message}");
    }
}

// 异步版本的统计方法（注意：FileInfo.Length没有异步API，这里实际还是同步读取，只是用了async包装）
private static async Task<(int FileCount, long TotalSize)> GetDirectoryStatsAsync(string dirPath)
{
    // 逻辑和同步版本基本一致，只是加了async标记
    int fileCount = 0;
    long totalSize = 0;

    try
    {
        var files = Directory.EnumerateFiles(dirPath, "*.*", SearchOption.AllDirectories);
        foreach (var file in files)
        {
            try
            {
                var fileInfo = new FileInfo(file);
                fileCount++;
                totalSize += fileInfo.Length;
            }
            catch (UnauthorizedAccessException)
            {
                continue;
            }
        }
    }
    catch (UnauthorizedAccessException)
    {
        // 处理无权限文件夹
    }

    return (fileCount, totalSize);
}

几个关键优化点（必看！） #

• 严格控制并发数：这是解决进程变慢的核心！文件系统无法承受无限并发，过多任务会导致IO等待队列变长，效率反而下降。建议通过测试找到最优值（比如机械硬盘设5-10，固态硬盘设10-20，网络共享文件夹设3-5）。
• 线程安全不可忽视：绝大多数数据库操作类（包括你的DbManager）都不是线程安全的，要么加锁，要么为每个任务创建单独的DbManager实例，不然会出现数据库连接冲突或数据错乱。
• 异常处理要周全：必须捕获UnauthorizedAccessException（无权限）、PathTooLongException（路径过长）这类文件操作常见异常，不然一个异常就会导致整个批量任务崩溃。
• 别盲目追求异步：文件IO的异步API很多时候是基于线程池的，对于简单的文件大小统计，同步+并行控制反而比纯异步更高效，因为减少了异步状态机的开销。

额外小建议 #

• 如果文件夹数量特别多（比如上万级），可以考虑分批处理，比如每次处理200个，处理完一批再取下一批，避免内存占用过高。
• 用Stopwatch测试不同并发数下的性能，找到最适合你系统的数值——毕竟不同存储设备的性能差异很大。
• 如果是处理网络共享文件夹，并发数要再调低，因为网络IO的延迟比本地存储高很多，过多并发会导致拥堵。

内容的提问来源于stack exchange，提问作者AnSharp