Asynchronous Programming in Dart

Mastering Asynchronous Programming in Dart| A Comprehensive Guide

Introduction:
 Asynchronous programming is crucial for writing responsive and efficient applications, especially when dealing with tasks such as fetching data from the internet, reading/writing files, or executing long-running computations. In this tutorial, you’ll dive deep into asynchronous programming in Dart, learning about Futures, async/await syntax, Streams, and more.

Asynchronous programming in Dart, similar to other languages like JavaScript, Python, and C#, is crucial for writing responsive and efficient applications, especially when dealing with tasks such as fetching data from the internet, reading/writing files, or executing long-running computations.

The mechanisms for handling asynchronous operations in Dart:

Futures:

Futures represent a single value or error that will be available at some time in the future. They are typically used for one-time asynchronous operations.

You can use the Future class to work with futures.

Here’s an example:

Future<String> fetchData() {
return Future.delayed(Duration(seconds: 2), () {
return 'Data fetched successfully!';
});
}

void main() {
print('Fetching data...');
fetchData().then((data) {
print(data);
});
print('Operation complete.');
}

async/await:

Dart’s async/await syntax provides a more readable way to work with asynchronous code. It allows you to write asynchronous code in a synchronous style. The async keyword is used to mark a function as asynchronous, and the await keyword is used to pause the execution of the function until the awaited operation completes.

Here’s how you can rewrite the previous example using async/await:

Future<String> fetchData() async {
await Future.delayed(Duration(seconds: 2));
return 'Data fetched successfully!';
}
void main() async {
print('Fetching data...');
var data = await fetchData();
print(data);
print('Operation complete.');
}

Streams:

Streams are sequences of asynchronous events. They allow you to handle a sequence of values over time. Dart provides the Stream class for working with streams.

Here’s a basic example:

import 'dart:async';

Stream<int> countStream(int max) async* {
for (int i = 1; i <= max; i++) {
yield i;
await Future.delayed(Duration(seconds: 1));
}
}

void main() async {
await for (var value in countStream(5)) {
print(value);
}
}

These are the fundamental mechanisms for asynchronous programming in Dart. Understanding and effectively utilizing these concepts will help you write efficient and responsive Dart applications.

Futures: complete example with explanation

Let’s go through a complete example of using Futures in Dart, along with explanations:

import 'dart:async';

// Simulates fetching data asynchronously from a server
Future<String> fetchData() {
return Future.delayed(Duration(seconds: 2), () {
// Simulating a successful data fetch
return 'Data fetched successfully!';
});
}

void main() {
print('Fetching data...');

// Initiating the asynchronous operation
Future<String> futureData = fetchData();

// Attaching a callback to handle the result when it's available
futureData.then((data) {
// This callback will be executed when the Future completes successfully
print('Data received: $data');
}).catchError((error) {
// This callback will be executed if an error occurs during the Future execution
print('Error fetching data: $error');
}).whenComplete(() {
// This callback will be executed when the Future completes, regardless of success or failure
print('Fetching data operation complete.');
});

print('Fetching data operation initiated...');
}

Explanation:

• We start by defining a function fetchData() which returns a Future<String>. This function simulates fetching data asynchronously from a server. Inside the Future.delayed() constructor, we specify a delay of 2 seconds before resolving the Future with the success message ‘Data fetched successfully!’.
• In the main() function, we print a message indicating that we are initiating the data fetch operation.
• We call the fetchData() function, which returns a Future<String>. We store this Future in a variable futureData.
• We attach a .then() callback to the futureData Future. This callback will be executed when the Future completes successfully. Inside this callback, we print the received data.
• We attach a .catchError() callback to the futureData Future. This callback will be executed if an error occurs during the execution of the Future. Inside this callback, we print the error message.
• We attach a .whenComplete() callback to the futureData Future. This callback will be executed when the Future completes, regardless of whether it was successful or not. Inside this callback, we print a message indicating that the fetch operation is complete.
• Finally, we print a message indicating that the fetch operation has been initiated.

When you run this Dart code, you’ll see the following output:

Fetching data operation initiated…
Fetching data…
Data received: Data fetched successfully!
Fetching data operation complete.

This shows the flow of asynchronous programming with Futures in Dart, where the rest of the program can continue executing while waiting for the asynchronous operation to complete.

Streams:complete example with explanation

Let’s walk through a complete example of using Streams in Dart, along with explanations:

import 'dart:async';

// Define a stream that emits a sequence of integers
Stream<int> countStream(int max) async* {
for (int i = 1; i <= max; i++) {
// Yielding each integer in the sequence
yield i;

// Introducing a delay to simulate asynchronous behavior
await Future.delayed(Duration(seconds: 1));
}
}

void main() async {
// Create a stream controller to manage the stream
StreamController<int> controller = StreamController();

// Create a subscription to listen to the stream
StreamSubscription<int> subscription =
countStream(5).listen((int value) {
print('Received: $value');
});

// Cancel the subscription after 6 seconds
Future.delayed(Duration(seconds: 6), () {
subscription.cancel();
print('Subscription cancelled.');
});

print('Listening to the stream...');

// Wait for 7 seconds to allow the stream to complete
await Future.delayed(Duration(seconds: 7));

// Close the stream controller
controller.close();
}

Explanation:

• We define a function countStream(int max) that returns a Stream<int>. This stream will emit a sequence of integers from 1 to max. Inside this function, we use the async* syntax to mark it as asynchronous and to enable the use of yield for generating values asynchronously.
• Within the countStream function, we use a for loop to iterate from 1 to max, and for each iteration, we yield the current integer in the sequence. We also introduce a delay of 1 second between each emission using await Future.delayed() to simulate asynchronous behavior.
• In the main() function, we create a StreamController<int> named controller to manage the stream. A StreamController is used to create, add data to, and close a stream.
• We create a subscription to listen to the stream using the listen() method on the stream returned by countStream(5). Inside the listener, we print each received value.
• We schedule a cancellation of the subscription after 6 seconds using Future.delayed(). This is done to demonstrate how to cancel a subscription to a stream.
• We print a message indicating that we’re listening to the stream.
• We use await Future.delayed() to wait for 7 seconds to allow the stream to complete before closing the stream controller.
• Finally, we close the stream controller using controller.close().

When you run this Dart code, you’ll see the following output:

Listening to the stream…
Received: 1
Received: 2
Received: 3
Subscription cancelled.
This shows how to create, manage, listen to, and cancel subscriptions to streams in Dart.

async/await: complete example with explanation

Let’s explore a complete example of using async/await in Dart, along with explanations:

import 'dart:async';

// Simulates fetching data asynchronously from a server
Future<String> fetchData() async {
// Simulate a delay of 2 seconds before fetching data
await Future.delayed(Duration(seconds: 2));

// Simulate a successful data fetch
return 'Data fetched successfully!';
}

void main() async {
print('Fetching data...');

try {
// Initiating the asynchronous operation using await
String data = await fetchData();

// This line will execute once the fetchData function is complete
print('Data received: $data');
} catch (error) {
// Handling errors if the fetchData function fails
print('Error fetching data: $error');
}

print('Fetching data operation complete.');
}

Explanation:

• We define a function fetchData() that returns a Future<String>. This function simulates fetching data asynchronously from a server. Inside the function, we mark it as asynchronous with the async keyword. We use await to pause execution until the Future.delayed() function completes, simulating a delay of 2 seconds. After the delay, we return a success message.
• In the main() function, we print a message indicating that we are initiating the data fetch operation.
• We use a try-catch block to handle any errors that may occur during the asynchronous operation.
• Inside the try block, we initiate the asynchronous operation using await fetchData(). This await keyword pauses the execution of the main() function until the fetchData() function completes. Once the data is fetched successfully, the execution continues, and the retrieved data is stored in the variable data.
• We print a message indicating that the data has been received along with the fetched data.
• If an error occurs during the execution of the fetchData() function, the control flows to the catch block where we handle the error by printing an error message.
• Finally, we print a message indicating that the fetch operation is complete.

When you run this Dart code, you’ll see the following output:

Fetching data…
Data received: Data fetched successfully!
Fetching data operation complete.
This demonstrates how async/await can be used to write asynchronous code in a synchronous style, making it easier to understand and manage asynchronous operations in Dart.

An application about :Asynchronous Programming in Dart

• Here’s a simple console application that demonstrates asynchronous programming in Dart.
• This application will simulate fetching data from an API asynchronously using Futures.

import 'dart:async';

class {
final int id;
final String name;

(this.id, this.name);

@override
String toString() {
return '{id: $id, name: $name}';
}
}

// Simulates fetching data asynchronously from an API
Future<List<>> fetchs() async {
// Simulate an API call delay of 3 seconds
await Future.delayed(Duration(seconds: 3));

// Simulate data received from API
List<Map<String, dynamic>> Data = [
{'id': 1, 'name': 'John Doe'},
{'id': 2, 'name': 'Jane Smith'},
{'id': 3, 'name': 'Alice Johnson'}
];

// Transform data into objects
List<> s = Data.map((data) => (data['id'], data['name'])).toList();

return s;
}

void main() async {
print('Fetching data...');

try {
// Initiate the asynchronous operation to fetch s
List<> s = await fetchs();

// Print fetched data
print('Fetched s:');
s.forEach(print);
} catch (error) {
// Handle errors if the fetchs function fails
print('Error fetching data: $error');
}

print(' data fetching complete.');
}

Explanation:

• We define a class to represent data. Each has an ID and a name.
• We define a function fetchs() that returns a Future<List<>>. Inside this function, we simulate fetching data from an API asynchronously. We use the async keyword to mark the function as asynchronous. We use await to pause execution while simulating an API call delay of 3 seconds. Then, we simulate receiving data from the API, transform it into a list of objects, and return it.
• In the main() function, we print a message indicating that we are fetching data.
• We use a try-catch block to handle any errors that may occur during the asynchronous operation.
• Inside the try block, we initiate the asynchronous operation to fetch s using await fetchs(). This pauses the execution of the main() function until the fetchs() function completes. Once the data is fetched successfully, the execution continues, and the fetched data is stored in the s variable.
• We print a message indicating that the data has been fetched and then print each fetched ‘s data using forEach.
• If an error occurs during the execution of the fetchs() function, the control flows to the catch block where we handle the error by printing an error message.
• Finally, we print a message indicating that the data fetching is complete.

When you run this Dart code, you’ll see the following output:

Fetching data…
Fetched s:
{id: 1, name: John Doe}
{id: 2, name: Jane Smith}
{id: 3, name: Alice Johnson}
data fetching complete.
This shows how to use asynchronous programming in Dart to fetch data from an API and handle errors gracefully.

Quiz about Asynchronous Programming in Dart

Here’s a quiz about Asynchronous Programming in Dart with explanations for each question:

1-What is the purpose of asynchronous programming in Dart?

a) To execute multiple tasks simultaneously
b) To improve the responsiveness of applications by allowing tasks to run concurrently
c) To simplify code structure
d) To optimize memory usage
Explanation: b) To improve the responsiveness of applications by allowing tasks to run concurrently. Asynchronous programming in Dart allows tasks to execute independently, enabling applications to remain responsive while performing time-consuming operations like network requests or file I/O.

2-Which keyword is used to mark a function as asynchronous in Dart?

a) async
b) sync
c) await
d) future
Explanation: a) async. The async keyword is used before the function’s return type to mark it as asynchronous. This allows the function to use the await keyword to pause execution and wait for asynchronous operations to complete.

3-What does the await keyword do in Dart?

a) It halts the execution of the current function until the specified Future completes.
b) It creates a new asynchronous task.
c) It converts synchronous code to asynchronous code.
d) It waits for a specific duration before continuing execution.
Explanation: a) It halts the execution of the current function until the specified Future completes. The await keyword is used to pause the execution of an asynchronous function until the result of a Future is available. This allows you to write asynchronous code in a synchronous style.

4-Which Dart class is used to represent a single value or error that will be available at some time in the future?

a) Stream
b) Future
c) Completer
d) FutureBuilder
Explanation: b) Future. A Future in Dart represents a single value or error that will be available at some time in the future. It’s commonly used for one-time asynchronous operations.

5-What does the then() method do when used with Futures in Dart?

a) It adds an error handler to a Future.
b) It chains a callback to be executed when the Future completes successfully.
c) It waits for multiple Futures to complete simultaneously.
d) It converts a Future into a Stream.
Explanation: b) It chains a callback to be executed when the Future completes successfully. The then() method is used to attach a callback that will be invoked when the Future completes successfully. This allows you to perform actions or handle the result of the Future.

6-Which Dart keyword is used to catch errors thrown by Futures?

a) try
b) catch
c) onError
d) catchError
Explanation: b) catch. The catch keyword is used in a try-catch block to catch errors thrown by Futures. This allows you to handle errors gracefully and prevent them from crashing your application.

7-What is the purpose of using Streams in Dart?

a) To represent a single value or error that will be available at some time in the future.
b) To handle asynchronous sequences of data.
c) To execute multiple tasks simultaneously.
d) To simplify code structure.
Explanation: b) To handle asynchronous sequences of data. Streams in Dart represent a sequence of asynchronous events over time. They are used to handle and process streams of data, such as data from network sockets or input events.

8-Which keyword is used to mark a function as a stream generator in Dart?

a) async
b) yield
c) await
d) then
Explanation: b) yield. The yield keyword is used in a function marked with the async* modifier to define a stream generator in Dart. It allows you to emit values asynchronously, producing a stream of values over time.

9-What does the listen() method do when used with Streams in Dart?

a) It attaches a callback to handle errors emitted by the stream.
b) It listens for new events emitted by the stream and invokes the provided callback for each event.
c) It transforms the stream into a Future.
d) It converts a Future into a Stream.
Explanation: b) It listens for new events emitted by the stream and invokes the provided callback for each event. The listen() method is used to subscribe to a stream and receive values emitted by the stream. It allows you to process each event asynchronously as it occurs.

10-Which Dart class is used to manage and control the production of stream events?

a) StreamSink
b) StreamController
c) StreamBuilder
d) StreamSubscription
Explanation: b) StreamController. The StreamController class in Dart is used to manage and control the production of stream events. It allows you to create and manipulate streams, as well as add data to the stream or close the stream when it’s no longer needed.