单App多任务提取BigTIFF瓦片异常，能否并行运行多控制台实例？

我需要通过并行处理加速BigTIFF文件的瓦片提取，使用TiffLibrary实现（该库是支持BigTIFF瓦片提取的少数库之一）。在单App内开启多任务提取时，所有任务返回相同的瓦片结果——尽管每个任务都拥有独立的解码器对象，但均调用同一Tifflibrary.dll，推测这是导致结果一致的原因，且认为此场景无解决方案。因此我开发了一个可生成单瓦片的控制台App，现咨询：能否开发一个「主」App同时运行多个该控制台App实例？

以下为单App多任务方案的示例代码：

全局变量 #

int SizeTileX = 2048, SizeTileY = 2048;
int OriWid, OriHei; // BigTIFF的宽/高
int nTasks = 3; // 并行任务数量
string Origin;  // 源Tiff文件路径

List<string> FileList = new List<string>();  // 瓦片文件名列表
List<Point> Posiz = new List<Point>();       // 瓦片在BigTIFF中的位置列表
List<Point> PointList = new List<Point>();   // 瓦片在拼接结果中的位置列表
List<byte[]> arrayList = new List<byte[]>(); // 存储解码后的结果
List<Task> tasks; // 存储任务的列表

任务创建代码 #

public void CreateTasks(int ini) // ini为起始索引
{
    tasks = new List<Task>();

    for (int i = 0; i < nTasks; i++)
    {
        byte[] bytes = new byte[SizeTileX * SizeTileY * 3];
        Task task = new Task(() => MakeTile( PointList.ElementAt(ini + i).X, PointList.ElementAt(ini + i).Y, bytes));
        
        tasks.Add(task); // 添加到任务列表
        arrayList.Add(bytes); // 添加到结果列表
    }
}

任务执行函数 #

public void MakeTile(int px, int py,byte[] bytes)
{
    TiffFileReader tiff;
    TiffImageFileDirectory ifd;
    TiffImageDecoder decoder;
    TiffMemoryPixelBuffer<TiffRgb24> pixelBuffer;
    TiffRgb24[] pixels;

    tiff = TiffFileReader.Open(Origin); // Origin为全局变量，即源Tiff文件路径
    ifd = tiff.ReadImageFileDirectory();
    decoder = tiff.CreateImageDecoder(ifd);

    pixels = new TiffRgb24[SizeTileX * SizeTileY];
    pixelBuffer = new TiffMemoryPixelBuffer<TiffRgb24>(pixels, SizeTileX, SizeTileY, writable: true);

    // 读取从(px, py)开始的子区域
    decoder.Decode(new TiffPoint(px, py), pixelBuffer); // 解码指定区域

    // 将解码结果转换为byte数组
    for (int i = 0, j; i < pixels.Length; i++) 
    {
            TiffRgb24 p = pixels.ElementAt(i);
            j = i * 3;
            bytes[j] = p.B;
            bytes[j + 1] =  p.R;
            bytes[j + 2] =  p.G;
    }
}

任务执行代码 #

public void Esegui()
{
        CreateTasks(0);

        foreach (Task t in tasks)
        {
            t.Start();
        }
        
        Task.WaitAll(tasks.ToArray());
        // 执行完成后，预期arrayList中有nTasks个byte数组
        // 实际上所有数组内容都相同
        
        foreach (Task task in tasks)
        {
            task.Dispose();
        }

        tasks.Clear();
        arrayList.Clear();
}

核心结论 #

完全可以开发主App同时运行多个单瓦片控制台App实例，这是可行且有效的方案。每个控制台实例是独立的操作系统进程，拥有独立的内存空间和TiffLibrary加载实例，从根本上避免了单App多任务时的状态共享问题。

先修正单App多任务的潜在问题 #

你当前的单App多任务代码存在循环变量捕获陷阱，这极可能是导致所有任务返回相同结果的直接原因，而非TiffLibrary.dll的问题：
在CreateTasks的循环中，lambda表达式捕获的是循环变量i的引用，而非当前迭代的值。当任务延迟执行时，循环已经结束，所有任务都会使用循环最后一次的i值，导致传入MakeTile的瓦片坐标完全相同。

只需在循环内复制变量即可修复：

public void CreateTasks(int ini)
{
    tasks = new List<Task>();

    for (int i = 0; i < nTasks; i++)
    {
        int currentIndex = ini + i; // 复制当前索引到局部变量
        byte[] bytes = new byte[SizeTileX * SizeTileY * 3];
        Task task = new Task(() => MakeTile(PointList.ElementAt(currentIndex).X, PointList.ElementAt(currentIndex).Y, bytes));
        
        tasks.Add(task);
        arrayList.Add(bytes);
    }
}

如果修复后仍然存在结果一致的问题，再采用多进程方案。

主App运行多控制台实例的实现方案 #

主App核心逻辑 #

主App通过Process类启动多个控制台进程，每个进程传递独立的瓦片参数（源文件路径、瓦片起始坐标、输出路径等）：

using System.Diagnostics;
using System.Collections.Generic;

// 存储瓦片参数的辅助类
public class TileTaskParam
{
    public string SourceFilePath { get; set; }
    public int TileStartX { get; set; }
    public int TileStartY { get; set; }
    public string OutputFilePath { get; set; }
}

public class TileMasterApp
{
    public void RunTileTasks(List<TileTaskParam> taskParams, string consoleAppPath)
    {
        List<Process> runningProcesses = new List<Process>();

        foreach (var param in taskParams)
        {
            // 构造命令行参数
            string args = $"--source \"{param.SourceFilePath}\" --x {param.TileStartX} --y {param.TileStartY} --output \"{param.OutputFilePath}\"";
            
            ProcessStartInfo startInfo = new ProcessStartInfo
            {
                FileName = consoleAppPath,
                Arguments = args,
                UseShellExecute = false,
                CreateNoWindow = true, // 可选：不显示控制台窗口
                RedirectStandardOutput = true, // 可选：捕获控制台输出
                RedirectStandardError = true // 可选：捕获错误信息
            };

            Process process = Process.Start(startInfo);
            runningProcesses.Add(process);
        }

        // 等待所有任务完成
        foreach (var process in runningProcesses)
        {
            process.WaitForExit();
            // 可选：处理输出或错误
            string output = process.StandardOutput.ReadToEnd();
            string error = process.StandardError.ReadToEnd();
            process.Dispose();
        }
    }
}

单瓦片控制台App参数处理 #

控制台App通过命令行接收参数，完成单个瓦片的提取与保存：

using System;
using System.CommandLine; // 可使用System.CommandLine简化参数解析，也可手动解析

class TileExtractorConsole
{
    static void Main(string[] args)
    {
        // 定义命令行参数
        var sourceOption = new Option<string>("--source", "源BigTIFF文件路径");
        var xOption = new Option<int>("--x", "瓦片起始X坐标");
        var yOption = new Option<int>("--y", "瓦片起始Y坐标");
        var outputOption = new Option<string>("--output", "瓦片输出文件路径");

        var rootCommand = new RootCommand("提取单个BigTIFF瓦片");
        rootCommand.AddOption(sourceOption);
        rootCommand.AddOption(xOption);
        rootCommand.AddOption(yOption);
        rootCommand.AddOption(outputOption);

        rootCommand.SetHandler(ExtractAndSaveTile, sourceOption, xOption, yOption, outputOption);
        rootCommand.Invoke(args);
    }

    static void ExtractAndSaveTile(string sourcePath, int startX, int startY, string outputPath)
    {
        const int TileWidth = 2048;
        const int TileHeight = 2048;

        using var tiffReader = TiffFileReader.Open(sourcePath);
        var imageDir = tiffReader.ReadImageFileDirectory();
        using var decoder = tiffReader.CreateImageDecoder(imageDir);

        var pixelBuffer = new TiffMemoryPixelBuffer<TiffRgb24>(TileWidth, TileHeight, writable: true);
        decoder.Decode(new TiffPoint(startX, startY), pixelBuffer);

        // 将像素数据保存到文件（示例：此处需替换为实际的保存逻辑，如保存为PNG/TIFF）
        // 示例代码：使用System.Drawing.Common保存为PNG
        /*
        using var bitmap = new Bitmap(TileWidth, TileHeight);
        var bitmapData = bitmap.LockBits(new Rectangle(0,0,TileWidth,TileHeight), ImageLockMode.WriteOnly, PixelFormat.Format24bppRgb);
        // 复制pixelBuffer中的数据到bitmapData
        // ...
        bitmap.UnlockBits(bitmapData);
        bitmap.Save(outputPath, ImageFormat.Png);
        */
    }
}

多进程方案的优势 #

• 彻底隔离：每个进程拥有独立的内存空间和TiffLibrary实例，不存在状态共享问题
• 性能充分利用：系统会自动调度多个进程使用多核CPU
• 容错性高：单个进程崩溃不会影响其他瓦片提取任务

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