DARTにおける将来:非同期,待ち,そして使用するとき

Asynchronous programming refers to a block of code that runs in parallel with other blocks of code. As a result, we can do several things at the same time.

Dart gives us two ways to implement asynchronous logic:

then works on the concept of callbacks. The callback is exactly what it says it is. Calling back (executing) a block of code sometime later.

Let's say we are fetching a list of recipes. This returns a Future .

• After the Future is completed (we've fetched the recipes), we want to display a message to the user.
• During this fetching, we don't want to stick there but continue to execute our next block of code.

Let's look at the following code. For simplicity, we'll use print statements.

Let's implement our second use case again.

Output:

start fetching recipes
recipes fetched
after fetching recipes
a random computation

This time, we've not used any callbacks explicitly like the then block. Instead, we've added async in line 1 and await in line 4.

• async keyword tells dart that this function might use asynchronous logic. So void main has the async keyword.
• await keyword tells dart that the following statement will return a Future . The Future should be completed and then the code below will be executed.

Let's look at some more examples.

As seen above, we can have multiple implementations for the same logic. Let's look at some code samples and try to simplify them.

void main() async {
  await Future.delayed(Duration(seconds: 1), () {
    print('inside delayed');
  }).then((_) {
    print('inside then');
  });

  print('after delayed');
}

The then block is redundant here. Since we're awaiting the Future , the then callback can be implemented like a normal code of block.

Simplified:

void main() async {
  await Future.delayed(Duration(seconds: 1), () {
    print('inside delayed');
  });

  print('inside then');

  print('after delayed');
}

void main() {
  Future.delayed(Duration(seconds: 1), () {
    print('inside delayed 1');
  }).then((_) {
    print('inside then 1');

    Future.delayed(Duration(seconds: 1), () {
      print('inside delayed 2');
    }).then((_) {
      print('inside then 2');
    });
  });

  print('after delayed');
}

There is a nesting of then blocks here. We can use async , await syntax inside a then block also.

Simplified:

void main() {
  Future.delayed(Duration(seconds: 1), () {
    print('inside delayed 1');
  }).then((_) async {
    print('inside then 1');

    await Future.delayed(Duration(seconds: 1), () {
      print('inside delayed 2');
    });

    print('inside then 2');
  });

  print('after delayed');
}

I hope the examples helped in understanding the various syntaxes.

And that's it for asynchronous programming in dart using Future .

• We can use then syntax or async-await syntax or both to implement asynchronous logic.
• Any syntax can be used to achieve our desired result. But we should also focus on code-readability.