问题[async-await]

同志们好！

有三个变量

let person1, person2, person3;

并且还有对/people/1, people/2, people/3的三个请求，我们将它们的最终结果分别赋值给上面的一个变量

fetch('https://swapi.dev/api/people/1', {
  method: 'GET',
})
  .then((res) => {
    return res.json();
  })
  .then((res) => {
    console.log(res);
    person1 = res;
  });

接下来，您需要将三个新变量传递给 goFurther 函数

function goFurther(person1, person2, person3) {
  console.log(person1, person2, person3);
}

如果没有 setTimeout，我无法弄清楚如何处理此任务。

我正在尝试使用 Promise 或 async, await 来解决这个问题 - 但我就是想不通。

请帮助这个具体的例子！解决方案的类比将帮助我理解很多。我也不知道如何在这里应用回调方案。

每个人都知道没有异步构造函数，好吧，至少现在还没有。该怎么办？

构造函数中已经有一个类似的问题异步代码，尽管它下面有许多无条件有用的注释，但该问题的解决方案仅针对工业规模提供 -正确和复杂。

我坐下来困惑于如何最简单安全地初始化一个直到初始化对象内部状态的异步操作结束才能使用的对象。

不符合上述条件的最明显的正面解决方案：

public class MyClass
{
    private int _data;

    public async Task InitAsync()
    {
        await Task.Delay(100);
        data = 42;
    }

    public int GetData()
    {
        if (_data != 42)
            throw new Exception("Объект не инициализирован, запустите InitAsync(), и дождитесь его завершения");
        return _data;
    }
}

即在调用worker方法时，检查对象是否初始化正确，否则抛出异常。

var instance = new MyClass();
await instance.InitAsync();
int result = instance.GetData();

InitAsync()该解决方案是有效的，但如果开发人员忘记调用或由于其他原因未调用此方法，或者在初始化方法中发生异常，则容易出现开发错误。一般来说，有机会获得非工作副本，这很糟糕。

有没有一种简单的方法来实施一致的解决方案？没有工厂、大量接口和其他东西。

有一个任务，简单如耙子。三个操作 - 两个同步，它们之间的一个异步。异步任务必须连续第二个执行，而不是最后一个。计算的最终结果应该等于 1。如何使用async/await语法来实现这一点，而不使用全局 Promise 对象。下面是一个示例解决方案，但不正确。

为什么我需要这个，这个奇怪的代码是什么，它有什么意义，等等。这些问题都没有了。我花了几天时间解决这个问题，我联系的每个人都无法解决它。只是为了这个任务，我在这个网站上注册了，所以这对我来说很重要。

const summarize = (num1, num2) => num1 + num2;
const divide = (num1, num2) => num1/num2;

let x = 2;
let y = 6;
let z = 10;

const calcAsync = async () => {
  x = summarize(x, x);                           // (1шаг) 2 + 2 = 4
  x = await setTimeout(() => summarize(x, y), 1);// (2шаг) ??? должно получится 4 + 6 = 10
  x = divide(x, z);                              // (3шаг) ??? должно получится 10/10 = 1
}

calcAsync();

从同步上下文转移到异步上下文的最佳方法是什么？如果父方法不知道如何等待任何东西，但你想异步运行一些东西，那么最好的使用方法是什么？似乎他们写道 async void 是一种不好的做法，因为它没有控制任务，启动它 - 并且不清楚接下来会发生什么。但是从同步方法启动任务时结果不一样吗？他没有等她，发射——然后忘记了。

一般来说，任务是从同步方法中启动一个异步方法，如何最正确地做到这一点？

class Hello
{         
    static void Main(string[] args)
    {
        SomeVoidMethod();
        SomeTaskMethod();
    }

    async void SomeVoidMethod()
    {

    }

    async Task SomeTaskMethod()
    {
        return Task.CompletedTask;
    }
}

究竟什么应该称为异步方法？应该使用什么标准来调用异步方法？其他术语似乎很清楚，但让我们重复一下，以便我们可以进一步使用它来尝试定义异步方法的概念。

回忆相关概念

有一个异步方法调用（AMI）的概念——

在等待被调用代码完成时调用站点未被阻塞。相反，当回复到达时，调用线程会收到通知。

此外，调用这个词可以更改为调用或执行。

有一个异步的概念，但在编程中它似乎几乎可以与 AMI ( 1 ) 互换使用——

执行一个操作而不等待这个处理完成，执行的结果可以稍后处理。

他们经常举一个例子，用一个烧开的水壶来解释它是什么。

让我们寻找一个异步方法的定义，暂时忘记我们是如何想象它的，以便客观。

1. 来源一 - async 关键字的文档-

使用 async 修饰符指定方法、lambda 表达式或匿名方法是异步的。如果在方法或表达式上使用此修饰符，它被称为异步方法。

可以翻译为：如果在方法或表达式中使用此修饰符，则称为异步方法。很明显，并非每个使用异步的方法都必须包含 AMI 或与现实中的异步相关的东西。

2. 另一方面，有这样一个来源2：

异步方法是我们调用以启动冗长操作的方法。该方法应该执行启动操作所需的操作并“非常快速地”返回，以便没有处理延迟。

如果您的线程告诉该方法它需要完成工作，并且该方法说“好的，我会这样做，完成后我会打电话给您”，则该方法是异步的

这向我们暗示，在异步方法的定义中应该有一些关于 AMI 的内容，我们在上面回忆过。

3. 甚至在旧 Dock 中的同一个 microsoftware 中（在 async 关键字出现之前），您也可以找到该术语的以下用法（3）：

如果异步方法遇到未处理的异常，...

所以看起来这样的概念甚至在 async 关键字之前就已经存在，但也许随着它的出现，新的含义出现了纯粹与语言的语法有关。

4. ...

不幸的是，研究这些来源需要很长时间，所以我有机会补充那些将回答这个问题的人。

试图从来源中找到定义。

根据所研究的来源，我想到了定义异步方法的哪些选项：

1. 这是声明时带有 async 关键字的方法。例子：

async void SimpleAsync() {}

2. 它是一种可用于非阻塞调用的方法。例子：

async void DelayAsync() { Task.Delay(1); } //Task.Delay асинхронный, так его можно использовать для AMI. Прям тут и используют.  
async void Delay2Async() { await Task.Delay(1); } //Task.Delay асинхронный, так его можно использовать для AMI. Прям тут и используют.
async Task Delay3Async() { await Task.Delay(1); } //Task.Delay асинхронный, так его можно использовать для AMI. Прям тут и используют. 


async void DelayExternalAsync() { DelayAsync(); Delay2Async(); } //DelayAsync и Delay2Async асинхронные, так их можно использовать для AMI. Прям тут и используют.
async void DelayExternalAwaitAsync() { await Delay3Async(); } //Delay3Async асинхронный, так его можно использовать для AMI. Прям тут и используют.
//DelayExternalAsync и DelayExternalAwaitAsync асинхронные, так их можно использовать для AMI. Хотя тут их не используют для этого.

async Task<int> JustEmptyAsync() { return await Task.FromResult(1); } // JustEmptyAsync не асинхронный, так его не можно использовать для AMI в других местах, так как внутри ничего асинхронного.

3. 它是一种发生非阻塞调用的方法。例子中，几乎所有方法都是异步的，但Task.Delay不是，因为它本身并没有AMI，至少看现有代码（也许不是这样，但我们暂时可以做这样的假设。虽然还有一个问题——有没有可以非阻塞调用的方法，但本身不包含AMI？如果有，那么这里我想用这个方法作为例子，否则这个选项好像是相当于第二个）：

async void DelayAsync() { Task.Delay(1); } //DelayAsync асинхронный, так как в нем есть AMI 
async void Delay2Async() { await Task.Delay(1); } //Delay2Async асинхронный, так как в нем есть AMI 
async Task Delay3Async() { await Task.Delay(1); } //Delay3Async асинхронный, так как в нем есть AMI 


async void DelayExternalAsync() { DelayAsync(); } //DelayExternalAsync асинхронный, так как в нем есть AMI 
async void DelayExternalAwaitAsync() { await Delay3Async(); } //DelayExternalAwaitAsync асинхронный, так как в нем есть AMI 

4. 其他选项...

我们强调最初的问题，并用我们在研究资料时学到的东西来补充它

这个概念的起源是什么？它现在有什么意义？还是像许多其他众所周知但没有明确定义的术语一样 - 谁知道他想怎么做？随着时间的推移，是否有多个定义？