是否可以异步添加到 c# 中的列表？ [复制]

Question

我正在 C# 中同步创建一个列表，但速度很慢。列表中大约有 50 个项目，添加每个项目最多可能需要 20 秒。添加项目的方法可以是异步的，所以我想知道是否可以使用 async/await 以某种方式添加所有项目。

这是一个将 2 个项目同步添加到列表的简单示例。我将如何异步执行？甚至可能吗？如果您尝试同时添加到列表中，您会遇到“冲突”吗？

using System.Threading;
using System.Collections.Generic;

class Program
{

    static void Main(string[] args)
    {
        List<int> lst = null;
        lst=GetList();
    }
    

    static List<int> GetList()
    {
        List<int> lst = new List<int>();

        //add to list
        lst.Add(Task1()); 
        lst.Add(Task2()); 

        //return list
        return lst;
    }

    static int Task1()
    {
        Thread.Sleep(10000);
        return 1; 
    }

    static int Task2()
    {
        Thread.Sleep(10000);
        return 2; 
    }

}

Compufreak 的答案正是我想要的。我有一个相关的问题，虽然我不确定这是否是我应该问的方式。我将 Compufreak 的代码稍微修改为一种对我来说更有意义的方式，我想知道代码的工作方式是否有任何实际差异。我从 Task1 和 Task2 中取出 async/await 并创建了一个 Task 并将 Task1 和 Task2 作为参数传入。

using System;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Linq;

class Program
{

    static async Task Main(string[] args)
    {
        List<int> lst = null;
        DateTime StartTime = DateTime.Now;
        lst = await GetList();
        DateTime EndTime = DateTime.Now;
        Console.WriteLine("ran tasks in " + (EndTime - StartTime).TotalSeconds + " seconds");
        Console.ReadLine();
    }


    static async Task<List<int>> GetList()
    {
        var tasks = new List<Task<int>>();

        //add task to list of tasks
        tasks.Add(new Task<int>(Task1));
        tasks.Add(new Task<int>(Task2));
        
        //start tasks
        foreach(Task<int> t in tasks)
        {
            t.Start();
        }

        //await results
        int[] results = await Task.WhenAll(tasks);

        //return list
        return results.ToList();
    }

    static int Task1()
    {
        Thread.Sleep(10000);
        return 1;
    }

    static int Task2()
    {
        Thread.Sleep(10000);
        return 2;
    }

}

Answer 1

不，您不能异步添加到列表中。

您需要在此处更改您的模式 - 如果您有许多长时间运行的任务并希望异步运行它们，您应该分别启动这些任务并随后收集/转换结果：

static async Task Main(string[] args)
{
    List<int> lst = null;
    DateTime StartTime = DateTime.Now;
    lst = await GetList();
    DateTime EndTime = DateTime.Now;
    Console.WriteLine("ran tasks in " + (EndTime - StartTime).TotalSeconds + " seconds");
 }


  static async Task<List<int>> GetList()
  {
      var tasks = new List<Task<int>>();
      tasks.Add(Task1());
      tasks.Add(Task2());
      int[] results = await Task.WhenAll(tasks);
      //return list
      return results.ToList();
  }

 static async Task<int> Task1()
 {
     await Task.Delay(10000);
     return 1;
 }

 static async Task<int> Task2()
 {
     await Task.Delay(10000);
     return 2;
 }

这将输出：

在 10,0727812 秒内运行任务

Here is a slightly modified fiddle to try it out online。我减少了延迟并在那里添加了一个额外的输出。

或者，您可以使用共享并发包在任务中添加结果（将结果添加到单独线程中的列表可能会导致奇怪的问题，例如空条目），但我认为在您的用例中没有充分的理由。

P.S.：您的函数的核心必须是异步的，否则您需要使用 Parallel.ForEach 之类的东西。如果可能，通常应该首选异步，因为它更有效地使用您的资源。

Answer 2

保持线程安全的关键是使用像 Progress 这样的 IProgress 实现并将该实例传递给您的任务。这样，所有线程都向管理器线程报告实际添加，但工作是在单独的线程上执行的。

开始任务之前

Progress prog = new Progress(p=>lst.Add(p));

任务功能

int Tast1(IProgess prog)
{
   int status = 0;
   Sleep(1000);
   prog.Report(1)
   status = 1;
   return status;
}