相关疑难解决方法(0)

我有这样的方法:

public static async Task SaveAllAsync()
{
    foreach (var kvp in configurationFileMap)
    {
        using (XmlWriter xmlWriter = XmlWriter.Create(kvp.Value, XML_WRITER_SETTINGS))
        {
            FieldInfo[] allPublicFields = 
                           kvp.Key.GetFields(BindingFlags.Public | BindingFlags.Static);
            await xmlWriter.WriteStartDocumentAsync();
            foreach (FieldInfo fi in allPublicFields)
            {
                await xmlWriter.WriteStartElementAsync("some", "text", "here");
            }
            await xmlWriter.WriteEndDocumentAsync();
        }
    }
}

但我正在努力追随当有人打电话时会发生什么SaveAllAsync().

我认为会发生的是:

1. 当有人第一次调用它时,SaveAllAsync()会将控制权返回给该行的调用者await xmlWriter.WriteStartDocumentAsync();
2. 然后......当他们等待SaveAllAsync()(或等待任务)时......会发生什么？将SaveAllAsync()仍然是第一的await坚持到它被调用？因为没有涉及线程,我猜是这样的......

所以我理解为什么从异步中返回void通常没有任何意义,但我遇到了一种我认为完全有效的情况.考虑以下人为的例子:

protected override void OnLoad(EventArgs e)
{
    if (CustomTask == null)
        // Do not await anything, let OnLoad return.
        PrimeCustomTask();
}
private TaskCompletionSource<int> CustomTask;

// I DO NOT care about the return value from this. So why is void bad?
private async void PrimeCustomTask()
{
    CustomTask = new TaskCompletionSource<int>();
    int result = 0;
    try
    {
        // Wait for button click to set the value, but do not block the UI.
        result = await CustomTask.Task;
    }
    catch
    {
        // Handle exceptions …

我已经看到了await关键字是如何实现的以及它创建的结果结构。我认为我对此有基本的了解。但是，是

public async Task DoWork()
{
    await this.Operation1Async();
    await this.Operation2Async();
    await this.Operation3Async();
}

“更好”（通常来说）或

public async Task DoWork()
{
    await this.Operation1Async();
    this.Operation2();
    this.Operation3();
}

第一种方法的问题在于，它正在Task为每个等待呼叫创建一个新的？哪个需要一个新线程？

鉴于第一个在第一个Task上创建了一个新项await，然后新项中处理了其中的所有内容Task？

编辑 好吧，也许我不太清楚，但是例如，如果我们有

while (await reader.ReadAsync())
{
    //...
}

await reader.NextResultAsync();

// ...

这不是在创建两个任务吗？ReadAsync在这个新创建的任务中，主线程中的第一个任务是第一个任务，然后是另一个任务NextResultAsync。我的问题是确实需要第二个任务，在主线程中创建的一个任务不够吗？所以

while (await reader.ReadAsync())
{
    //...
}

reader.NextResult();

// ...

我一直在玩 async 并且遇到了一些我以前没有注意到的行为，如果这是重复的，请告诉我，但是我的 google-fu 失败了，主要是因为我想不出体面的搜索条件：

给定一个简单的异步方法，它执行一些参数化工作：

async Task<String> Foo(int i)
{
    await Task.Delay(i);
    return i.ToString();
}

以及在不同上下文中调用它并捆绑结果的调用方法：

async Task<Object> Bar()
{
    var one =    Foo(3000);
    var two =    Foo(5000);
    var three =  Foo(3000);

    var x =
        new
        {
            One =   await one,
            Two =   await two,
            Three = await three,
        };      
        
    return x;
}

这在 5 秒内完成（在 Linqpad6、.NET Core 3.1 中）。所以我假设每个任务同时运行。

但是，如果我将其更改为在开始时执行等待，则它会在 11 秒内完成。所以我假设每个任务都是按顺序运行的。

async Task<Object> Bar()
{
    var one =   await Foo(3000);
    var two =   await Foo(5000);
    var three …