C# 如何正确编写具有多个等待的健壮异步代码

对于下面的代码，为了使代码更健壮，建议采用什么方法重写此代码

我正试图更好地理解await async

如果您注意到下面的代码，我正在等待两个方法，以便将一个结果添加到allSheets

我可以做些什么来提高下面代码的性能。我需要这些方法调用同时运行，而不是一个接一个地运行，接受并行排列的方法调用；显然，第一个方法必须返回一个结果才能调用等待结果的方法

async static Task<List<Bitmap>> BuildSheetsAsync(Guid userID, IElevation elevation, bool includeLabels)
            {
         var processedParts = await new PartsProcessor.PartProcessor().ProcessParts(userID, elevation, false);
            processedParts.Elevation = elevation;

          List<Bitmap> allSheets = new List<Bitmap>();
        //materials list
        allSheets.Add(await (await MaterialsList.Manager.GetMaterialListAsync(processedParts)).GetDrawingAsync());

        //optimized parts
        allSheets.Add(await (await Optimization.Manager.GetOptimizedPartsAsync(processedParts)).GetDrawingAsync());

        //cut sheet
        processedParts = await new PartsProcessor.PartProcessor().ProcessParts(userID, elevation, true);
        processedParts.Elevation = elevation;
        allSheets.Add(await CutSheet.Manager.GetCutSheet(processedParts).GetDrawingAsync());
    }

异步静态任务BuildSheetsAsync（Guid用户ID、IElevation提升、bool includeLabels）
{
var processedParts=wait new parts处理器.PartProcessor（）.ProcessParts（userID，elevation，false）；
加工零件。标高=标高；
List allSheets=新列表（）；
//材料清单
Add（await（await MaterialsList.Manager.GetMaterialListAsync（processedParts））.GetDrawingAsync（））；
//优化零件
Add（await（await Optimization.Manager.GetOptimizedPartsAsync（processedParts））.GetDrawingAsync（））；
//裁片
processedParts=等待新零件Processor.PartProcessor（）.ProcessParts（用户标识，高程，true）；
加工零件。标高=标高；
allSheets.Add（等待CutSheet.Manager.GetCutSheet（processedParts.GetDrawingAsync（））；
}

---

补充问题

对于下面这样的标签，它返回一个列表。我怎样才能让它工作呢？我在将LBL添加到allSheets.AddRange时遇到错误

//labels
        if (includeLabels)
        {
            var lbls = GetGetLabelsDrawingAsync(processedParts);

            allSheets.AddRange(await Task.WhenAll(materialsList, optimizedParts, cutSheet, lbls));
        }
        else
        {
            allSheets.AddRange(await Task.WhenAll(materialsList, optimizedParts, cutSheet));
        }
        return allSheets;
    }
    static async Task<List<Bitmap>> GetGetLabelsDrawingAsync(ProcessedParts processedParts)
    {
        var list = await AlumCloudPlans.Manager.GetLabelsAsync(processedParts);
        return await list.GetSheets(new SheetInfo(3, 10, 240, 90, 780, 980));
    }

//标签
如果（包括标签）
{
var lbls=GetLabelsDrawingAsync（已处理部件）；
allSheets.AddRange（等待任务.whalll（材料列表、优化部分、切割表、LBL））；
}
其他的
{
allSheets.AddRange（等待任务.WhenAll（材质列表、优化部分、剪切表））；
}
返回所有表格；
}
静态异步任务GetGetLabelsDrawingAsync（ProcessedParts ProcessedParts）
{
var list=await AlumCloudPlans.Manager.getlabelasync（processedParts）；
返回等待列表。GetSheets（新的SheetInfo（3、10、240、90、780、980））；
}

您只需启动多个

任务，然后使用
任务。所有
时：

var materials = GetMaterialDrawingAsync(processedParts);
var optimized = GetOptimizedDrawingAsync(processedParts);
var cut = GetCutDrawingAsync(processedParts);
allSheets.AddRange(await Task.WhenAll(materials, optimized, cut));

注意简化的
async
方法以删除串行
wait
s（稍微简化代码）：

静态异步任务GetMaterialDrawingAsync（ProcessedParts ProcessedParts）
{
var list=await MaterialsList.Manager.GetMaterialListAsync（processedParts）；
返回等待列表。GetDrawingAsync（）；
}
您只需启动多个
任务，然后使用
任务。所有
时：

var materials = GetMaterialDrawingAsync(processedParts);
var optimized = GetOptimizedDrawingAsync(processedParts);
var cut = GetCutDrawingAsync(processedParts);
allSheets.AddRange(await Task.WhenAll(materials, optimized, cut));

注意简化的
async
方法以删除串行
wait
s（稍微简化代码）：

静态异步任务GetMaterialDrawingAsync（ProcessedParts ProcessedParts）
{
var list=await MaterialsList.Manager.GetMaterialListAsync（processedParts）；
返回等待列表。GetDrawingAsync（）；
}
我是
等待的noob，所以我不明白。。添加到集合时为什么要等待
。这些方法中的每一种都会构建位图，而且某些处理过程是非常密集的。我的意思是，添加到集合中不应该那么慢，我在
wait
上是个傻瓜，所以我不明白。。添加到集合时为什么要等待
。这些方法中的每一种都会构建位图，并且某些处理是非常密集的。我的意思是，添加到集合不应该那么慢，因为他将同一个对象传递给所有这些任务，我当然希望他不会用它做任何线程不安全的事情。@TrevorElliott:
async
不一定意味着多线程。但是，如果他正在使用
Task.Run
或在没有上下文的情况下（即在线程池上）执行此任务，则是，他需要考虑线程安全性。如果他想并行处理多个位图，假设他正在生成多个线程。@ LexStRein：<代码>任务。当所有使用<代码>任务时，运行< /代码>可以用于简单的并行操作，但一般来说，我同意TPL（<代码>并行< /代码> /PLIQ）更好地用于并行处理。在这种情况下，op已经有了可以期待的方法，所以
whalll
是将它们结合起来的最简单的方法。@Stephenleary的博客实际上非常适合学习C#中的异步编程，因为他将同一个对象传递给所有这些任务，我当然希望他不会用它做任何线程不安全的事情。@TrevorElliott:
async
不一定意味着多线程。但是，如果他正在使用
Task.Run
或在没有上下文的情况下（即在线程池上）执行此任务，则是，他需要考虑线程安全性。如果他想并行处理多个位图，假设他正在生成多个线程。@ LexStRein：<代码>任务。当所有使用<代码>任务时，运行< /代码>可以用于简单的并行操作，但一般来说，我同意TPL（<代码>并行< /代码> /PLIQ）更好地用于并行处理。在这种情况下，op已经有了一些值得期待的方法，因此
whalll
是将它们结合起来的最简单的方法。@StephenCleary的博客实际上非常适合学习C语言中的异步编程#