What Will I Learn?
- You will learn about Await and Async
- You will learn about the Future Object and what Futures are
- You will learn about Streams; both Broadcast and Single Subscription
- You will learn how to use Await For
- You will learn about Listeners
- You will learn about Sinks
- IDEA intellij, Visual Studio Code with the Dart/Flutter Plugins, Android Studio or Xcode
- The Dart SDK on the latest developer build for Dart 2 support.
- An Android or iOS Emulator or device for testing
OS Support for Dart:
- Windows 7 SP1 or later (64-bit)
- macOS (64-bit)
- Linux (64-bit)
- Some knowledge of basic programming
- Some understanding asynchronous programming
- A fair understanding of development and Imperative or Object Oriented Programming
Resources for Flutter and this Project:
- Dart Website: https://www.dartlang.org/
- Dart Awesome GitHub Repository: https://github.com/yissachar/awesome-dart
- Dartpad Tool: https://dartpad.dartlang.org/
- Dart SDK repository: https://github.com/dart-lang/sdk
Dart Logo: https://www.dartlang.org/
Outline and Overview
In this first Dart Video Tutorial, we take a look at how Dart handles asynchronous programming. Dart uses Futures to allow the user to return a piece of data in an asynchronous manner. Dart also uses Streams to allow the user to process collections of data in an asynchronous way. We also look at the
async keywords, as well as the
yield generator keywords, the
await for loop and stream listeners. We touch on the
then method and some basic IO functions in Dart; including
Being Asynchronous with One Thread
At its core, a Future is just an object that provides the means for returning a piece of data at some unspecified point during execution. When executing a function that returns a Future, a Future object is created and then the work is queued by this object. When the value becomes available, it is then pushed into the Future object and the Future object is considered completed. You can unwrap the Future from the data by using the
await keyword or by using the
then method with a callback function as shown above.
Making Asynchronous Execution feel more Synchronous
then method allows us to unwrap a Future from the associated data however, it makes no guarantee on when this will happen. Instead, the time of execution is based on when the data is pushed into the future and when the future is marked as completed. As a result of this; the order of execution of the code can become unorganized. This is why the
await keywords were introduced to the Dart programming language.
Originally, if you wanted to interface with Futures inside of Dart, you had to directly interact with the Future API. While this is still possible and very useful, often times it is not needed. In these cases, you can use the
async keyword to make it so that specified function will always return a Future type. This means that even functions which would not return a value or would be marked
void also return an empty
future. Notice how the
main function is marked with
async to allow us to use the
await keyword inside of it's body.
Streaming Data into your Program
The second major data type that is provided by Dart for Asynchronous programming is the Stream. Streams provide a method of dealing with asynchronous collections/sequences of data. This data can be user generated events and from APIs not directly connected to our code. In Dart, there are two main types of Streams, the single subscription stream and the broadcast stream. You are use a generator to create a stream with the
yield keyword and you can process streams using listeners and the
await for operator.
In the example above, we have two main streams being used. We have a
IOSink which is the endpoint of a stream that is pushing data from the main function to the file that we are writing in. This is what allows us to write strings and other data into the file that we are targeting. We also have a
stream that is being fed from the file to the program through the
openRead() method. We use this stream to process the data that is contained inside of the file so that we can print it out to the console.
The source code for this project can be found here