异步/等待，而另一个方法执行操作

Question

我想实现一个流程，当在我的班级中调用异步方法时，他们将注册到调度程序列表并等待。然后另一个线程运行并执行调度程序列表中的方法，当每个动作完成时，等待将完成，我将返回计算的值。

到目前为止，这是我的代码：

private List<Func<ClassA, ClassB, ResponseBase>> _actionsDict;
public ExecutingScheduler()
{
    _actionsDict = new List<Func<ClassA, ClassB, ResponseBase>>();
    Task.Factory.StartNew(ExecuteNextTask);
}

private void ExecuteNextTask()
{
    while (_actionsDict.Count > 0)
    {
        // Get first while removing it
        var next = _actionsDict[0];
        _actionsDict.RemoveAt(0);

        // Next line has an error now, how do I call it with the original params as I added it to the list
        next();

        Task.Delay(2000);
    }
}

public async Task<ResponseBase> StartStreamAsync(ClassA classA, ClassB classB)
{
    _actionsDict.Add((unit, guid) => StartStream(classA, classB));

    // I don't want the first each time, I want to await the same instance as I added
    var response = await Task.Run(() => _actionsDict[0](classA, classB)); 
    return response;
}

public async Task<ResponseBase> PrepareStreamAsync(ClassA classA, ClassB classB)
{
    _actionsDict.Add((unit, guid) => PrepareStream(classA, classB));

    // I don't want the first each time, I want to await the same instance as I added
    var response = await Task.Run(() => _actionsDict[0](classA, classB)); 
    return response;
}

所以有两个问题： 1) 如何正确添加到操作列表中，以便以后可以使用参数一个接一个地调用列表中的函数？

2) 如何正确地将执行器方法的返回值传递给原始请求的调用者？

随意提出不同的方法

Answer 1

我不太明白你的问题。但我假设您需要一个具有两个 async 方法的类，它们可以按照 actionDict 中的顺序执行操作。

不管怎样，代码如下：（新版本）

    List<Task<ResponseBase>> _actionsDict = new List<Task<ResponseBase>>();
    Timer _timer = new Timer(1000);

    public ExecutingScheduler()
    {
        _timer.Elapsed += (s, e) => {
            while (_actionsDict.Count > 0) {
                var a = _actionsDict[0];
                _actionsDict.RemoveAt(0);

                a.Start();
                a.Wait();
            }
        };
        _timer.Start();
    }

    public Task<ResponseBase> StartStreamAsync(ClassA classA, ClassB classB)
    {
        return QueueResponse(() => StartStream(classA, classB));
    }

    public Task<ResponseBase> PrepareStreamAsync(ClassA classA, ClassB classB)
    {
        return QueueResponse(() => PrepareStream(classA, classB));
    }

    public Task<ResponseBase> QueueResponse(Func<ResponseBase> action)
    {
        var t = new Task<ResponseBase>(action);
        _actionsDict.Add(t);

        return Task.Run(() => t.Result);
    }

Answer 2

您似乎正在尝试重新实现任务并行库。特别是TaskScheduler 和Task.WhenAll。

试试这个。

var queries = new [] 
              { 
                  new { ClassA =..., ClassB = ...},
                  new { ClassA =..., ClassB = ...},
                  new { ClassA =..., ClassB = ...},
              };
var tasks = queries.Select(item => Task.Run(() => PrepareStream(item.ClassA, item.ClassB);
var results = await Task.WhenAll(tasks);

但是，像PrepareStream 这样的名字我怀疑你真的不想使用线程。

只有在 CPU 受限或有特殊 (UI) 线程（这是 CPU 受限的特殊情况）时才应使用线程。

Answer 3

（已编辑） 您可以将任务添加到集合中，而不是将函数添加到操作集合中。

//Better use thread-safe ConcurrentQueue
private ConcurrentQueue<Task<ResponseBase>> _actions;

public ExecutingScheduler()
{
    _actions = new ConcurrentQueue<Task<ResponseBase>>();
    Task.Factory.StartNew(ExecuteNextTask);
}

private void ExecuteNextTask()
{
    while (true)
    {
        // Get first while removing it
        Task<ResponseBase> next;
        var containsElement = _actions.TryDequeue(out next);
        if (containsElement)
        {
            next.Start();
            next.Wait();
        }
        Task.Delay(2000);
    }
}

public async Task<ResponseBase> StartStreamAsync(ClassA classA, ClassB classB)
{
    var task = new Task<ResponseBase>(() => StartStream(classA, classB));

    //Add task to queue
    _actions.Enqueue(task);

    var result = await task;

    return result;
}

public async Task<ResponseBase> PrepareStreamAsync(ClassA classA, ClassB classB)
{
    var task = new Task<ResponseBase>(() => PrepareStream(classA, classB));

    //Add task to queue
    _actions.Enqueue(task);

    var result = await task;
    return result;
}