在不立即运行任务的情况下获取异步代码任务的优雅方式

Question

我有以下代码可以执行我想要的操作，但我不得不求助于在异步代码中间使用.GetAwaiter().GetResult()来获取它。 我想知道是否有一种优雅的方法可以在不诉诸此类黑客的情况下实现这一目标。

这是我拥有的代码的简化版本。

public async Task<string[]> GetValues(int[] keys)
{
    List<int> keysNotYetActivelyRequested = null;
    // don't start the task at this point because the
    // keysNotYetActivelyRequested is not yet populated
    var taskToCreateWithoutStarting = new Task<Dictionary<int, string>>(
        () => GetValuesFromApi(keysNotYetActivelyRequested.ToArray())
        .GetAwaiter().GetResult() /*not the best idea*/);
    (var allTasksToAwait, keysNotYetActivelyRequested) = GetAllTasksToAwait(
        keys, taskToCreateWithoutStarting);

    if (keysNotYetActivelyRequested.Any())
    {
        // keysNotYetActivelyRequested will be empty when all keys
        // are already part of another active request
        taskToCreateWithoutStarting.Start(TaskScheduler.Current);
    }
    var allResults = await Task.WhenAll(allTasksToAwait);
    var theReturn = new string[keys.Length];
    for (int i = 0; i < keys.Length; i++)
    {
        foreach (var result in allResults)
        {
            if (result.TryGetValue(keys[i], out var value))
            {
                theReturn[i] = value;
            }
        }
    }
    if (keysNotYetActivelyRequested.Any())
    {
        taskToCreateWithoutStarting.Dispose();
    }
    return theReturn;
}

// all active requests indexed by the key, used to avoid generating
// multiple requests for the same key
private Dictionary<int, Task<Dictionary<int, string>>> _activeRequests = new();
private (HashSet<Task<Dictionary<int, string>>> allTasksToAwait,
    List<int> keysNotYetActivelyRequested) GetAllTasksToAwait(
    int[] keys, Task<Dictionary<int, string>> taskToCreateWithoutStarting)
{
    var keysNotYetActivelyRequested = new List<int>();
    // a HashSet because each task will have multiple keys hence _activeRequests
    // will have the same task multiple times
    var allTasksToAwait = new HashSet<Task<Dictionary<int, string>>>();

    // add cleanup to the task to remove the requested keys from _activeRequests
    // once it completes
    var taskWithCleanup = taskToCreateWithoutStarting.ContinueWith(_ =>
    {
        lock (_activeRequests)
        {
            foreach (var key in keysNotYetActivelyRequested)
            {
                _activeRequests.Remove(key);
            }
        }
    });
    lock (_activeRequests)
    {
        foreach (var key in keys)
        {
            // use CollectionsMarshal to avoid a lookup for the same key twice
            ref var refToTask = ref CollectionsMarshal.GetValueRefOrAddDefault(
                _activeRequests, key, out var exists);
            if (exists)
            {
                allTasksToAwait.Add(refToTask);
            }
            else
            {
                refToTask = taskToCreateWithoutStarting;
                allTasksToAwait.Add(taskToCreateWithoutStarting);
                keysNotYetActivelyRequested.Add(key);
            }
        }
    }
    return (allTasksToAwait, keysNotYetActivelyRequested);
}

// not the actual code
private async Task<Dictionary<int, string>> GetValuesFromApi(int[] keys)
{
    // request duration dependent on the number of keys
    await Task.Delay(keys.Length);
    return keys.ToDictionary(k => k, k => k.ToString());
}

以及一个测试方法：

[Test]
public void TestGetValues()
{
    var random = new Random();
    var allTasks = new Task[10];
    for (int i = 0; i < 10; i++)
    {
        var arrayofRandomInts = Enumerable.Repeat(random, random.Next(1, 100))
            .Select(r => r.Next(1, 100)).ToArray();
        allTasks[i] = GetValues(arrayofRandomInts);
    }
    Assert.DoesNotThrowAsync(() => Task.WhenAll(allTasks));
    Assert.That(_activeRequests.Count, Is.EqualTo(0));
}

Answer 1

代替：

Task<Something> coldTask = new(() => GetAsync().GetAwaiter().GetResult());

你可以这样做：

Task<Task<Something>> coldTaskTask = new(() => GetAsync());
Task<Something> proxyTask = coldTaskTask.Unwrap();

嵌套任务coldTaskTask是您稍后将Start （或RunSynchronously ）的任务。

展开的任务proxyTask是一个代理，它代表GetAsync方法的调用，以及该方法生成的Task<Something>的完成。

Answer 2

您永远不应该使用任务构造函数。

如果要引用一些代码稍后执行，请使用委托。 就像您使用同步代码一样。 异步代码的委托类型略有不同，但它们仍然只是委托。

Func<Task<Dictionary<int, string>>> getValuesAsync = () => GetValuesFromApi(keysNotYetActivelyRequested.ToArray());

...

var result = await getValuesAsync();

此外，我强烈建议将ContinueWith替换为await 。

所有链接都指向我的博客。