当另一种方法执行操作时异步/等待

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的顺序进行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

（已编辑）可以向集合添加任务，而不是向动作集合添加功能。

//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;
}

Answer 3

看来您正在尝试重新实现任务并行库。 特别是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约束的特例）时，才应使用线程。