C# TaskFactory，在任务结束时启动新任务

我已经找到了许多使用任务工厂的方法，但是我找不到任何关于启动更多任务、观察一个任务何时结束以及启动另一个任务的方法

我总是希望有10项任务可以完成

我想要这样的东西

int nTotalTasks=10;
int nCurrentTask=0;

Task<bool>[] tasks=new Task<bool>[nThreadsNum];

for (int i=0; i<1000; i++)
{
  string param1="test";
  string param2="test";

  if (nCurrentTask<10) // if there are less than 10 tasks then start another one
    tasks[nCurrentThread++] = Task.Factory.StartNew<bool>(() =>
    {
       MyClass cls = new MyClass();
       bool bRet = cls.Method1(param1, param2, i); // takes up to 2 minutes to finish
       return bRet;
    });

  // How can I stop the for loop until a new task is finished and start a new one?
}

intntotatatasks=10；
int nCurrentTask=0；
Task[]tasks=新任务[nThreadsNum]；
对于（inti=0；i这应该是您所需要的全部，而不是完成，但是您所需要做的只是等待第一个完成，然后运行第二个

Task.WaitAny(task to wait on);

Task.Factory.StartNew()

请查看以下方法：

等待提供的任何任务对象完成执行

文档中的示例：

var t1 = Task.Factory.StartNew(() => DoOperation1());
var t2 = Task.Factory.StartNew(() => DoOperation2());

Task.WaitAny(t1, t2)

你见过这个类吗？它允许你有多个线程并行运行，你可以等待一个任务的结果来执行另一个任务。请参阅更多信息。
我将使用微软的反应式框架（NuGet“Rx Main”）和TPL的组合来实现这一点。它变得非常简单

代码如下：

int nTotalTasks=10;
string param1="test";
string param2="test";

IDisposable subscription =
    Observable
        .Range(0, 1000)
        .Select(i => Observable.FromAsync(() => Task.Factory.StartNew<bool>(() =>
        {
            MyClass cls = new MyClass();
            bool bRet = cls.Method1(param1, param2, i); // takes up to 2 minutes to finish
            return bRet;
        })))
        .Merge(nTotalTasks)
        .ToArray()
        .Subscribe((bool[] results) =>
        {
            /* Do something with the results. */
        });

答案取决于要调度的任务是CPU绑定的还是I/O绑定的

对于CPU密集型工作，我将使用
Parallel.For（）
API通过
MaxDegreeOfParallelism
属性
ParallelOptions

对于I/O绑定的工作，并发执行任务的数量可能远远大于可用CPU的数量，因此策略是尽可能依赖异步方法，从而减少等待完成的线程总数

如何停止for循环，直到新任务完成并开始新任务
新的

可以使用wait来限制循环：

    static void Main(string[] args)
    {
        var task = DoWorkAsync();
        task.Wait();

        // handle  results
        // task.Result;

        Console.WriteLine("Done.");
    }

    async static Task<bool> DoWorkAsync()
    {
        const int NUMBER_OF_SLOTS = 10;

        string param1="test";
        string param2="test";

        var results = new bool[NUMBER_OF_SLOTS]; 

        AsyncWorkScheduler ws = new AsyncWorkScheduler(NUMBER_OF_SLOTS);
        for (int i = 0; i < 1000; ++i)
        {
            await ws.ScheduleAsync((slotNumber) => DoWorkAsync(i, slotNumber, param1, param2, results));
        }

        ws.Complete();
        await ws.Completion;
    }

    async static Task DoWorkAsync(int index, int slotNumber, string param1, string param2, bool[] results)
    {
      results[slotNumber] = results[slotNumber} && await Task.Factory.StartNew<bool>(() =>
      {
          MyClass cls = new MyClass();
          bool bRet = cls.Method1(param1, param2, i); // takes up to 2 minutes to finish
          return bRet;
      }));

    }

你看过
WaitAny（）了吗
方法或尝试等待
任务。结果
任务是IO绑定的还是CPU绑定的？我如何知道哪个任务已完成？因为我需要知道已完成任务的返回值task@MarioM-与不使用
WaitAny
调用时相同。
Task.Result
@MarioM
WaitAny（）
返回tasksNo输入数组中的索引，非常有趣。
    static void Main(string[] args)
    {
        var task = DoWorkAsync();
        task.Wait();

        // handle  results
        // task.Result;

        Console.WriteLine("Done.");
    }

    async static Task<bool> DoWorkAsync()
    {
        const int NUMBER_OF_SLOTS = 10;

        string param1="test";
        string param2="test";

        var results = new bool[NUMBER_OF_SLOTS]; 

        AsyncWorkScheduler ws = new AsyncWorkScheduler(NUMBER_OF_SLOTS);
        for (int i = 0; i < 1000; ++i)
        {
            await ws.ScheduleAsync((slotNumber) => DoWorkAsync(i, slotNumber, param1, param2, results));
        }

        ws.Complete();
        await ws.Completion;
    }

    async static Task DoWorkAsync(int index, int slotNumber, string param1, string param2, bool[] results)
    {
      results[slotNumber] = results[slotNumber} && await Task.Factory.StartNew<bool>(() =>
      {
          MyClass cls = new MyClass();
          bool bRet = cls.Method1(param1, param2, i); // takes up to 2 minutes to finish
          return bRet;
      }));

    }

class AsyncWorkScheduler
{
    public AsyncWorkScheduler(int numberOfSlots)
    {
        m_slots = new Task[numberOfSlots];
        m_availableSlots = new BufferBlock<int>();
        m_errors = new List<Exception>();
        m_tcs = new TaskCompletionSource<bool>();
        m_completionPending = 0;

        // Initial state: all slots are available
        for(int i = 0; i < m_slots.Length; ++i)
        {
            m_slots[i] = Task.FromResult(false);
            m_availableSlots.Post(i);
        }
    }

    public async Task ScheduleAsync(Func<int, Task> action)
    {
        if (Volatile.Read(ref m_completionPending) != 0)
        {
            throw new InvalidOperationException("Unable to schedule new items.");
        }

        // Acquire a slot 
        int slotNumber = await m_availableSlots.ReceiveAsync().ConfigureAwait(false);

        // Schedule a new task for a given slot
        var task = action(slotNumber);

        // Store a continuation on the task to handle completion events
        m_slots[slotNumber] = task.ContinueWith(t => HandleCompletedTask(t, slotNumber), TaskContinuationOptions.ExecuteSynchronously);
    }


    public async void Complete()
    {
        if (Interlocked.CompareExchange(ref m_completionPending, 1, 0) != 0)
        {
            return;
        }

        // Signal the queue's completion
        m_availableSlots.Complete();

        await Task.WhenAll(m_slots).ConfigureAwait(false);

        // Set completion
        if (m_errors.Count != 0)
        {
            m_tcs.TrySetException(m_errors);
        }
        else
        {
            m_tcs.TrySetResult(true);
        }

    }

    public Task Completion
    {
        get
        {
            return m_tcs.Task;
        }
    }



    void SetFailed(Exception error)
    {
        lock(m_errors)
        {
            m_errors.Add(error);
        }

    }

    void HandleCompletedTask(Task task, int slotNumber)
    {
       if (task.IsFaulted || task.IsCanceled)
       {
           SetFailed(task.Exception);
           return;
       }

       if (Volatile.Read(ref m_completionPending) == 1)
       {
           return;
       }


        // Release a slot
        m_availableSlots.Post(slotNumber);
    }

    int m_completionPending;
    List<Exception> m_errors;
    BufferBlock<int> m_availableSlots;
    TaskCompletionSource<bool> m_tcs;
    Task[] m_slots;

}