**Course Title:** Mastering Dart: From Fundamentals to Flutter Development **Section Title:** Functions and Error Handling **Topic:** Create Dart programs utilizing functions, error handling, and explore asynchronous programming with Futures. **Introduction** In the previous topics, we've covered the basics of Dart, control structures, functions, and error handling. In this lab, we'll delve deeper into the world of functions, error handling, and asynchronous programming using Futures. We'll be creating Dart programs that utilize these concepts to perform real-world tasks, making you proficient in using them to build robust and efficient applications. ### Warm-Up Exercise Before we dive into the lab, let's quickly review functions and error handling with a warm-up exercise: ```dart void main() { // Function to divide two numbers int divide(int a, int b) { if (b == 0) { throw Exception('Cannot divide by zero!'); } else { return a ~/ b; } } try { int result = divide(10, 2); print('Result: $result'); } on Exception catch (e) { print('Error: $e'); } } ``` Run the above code in your Dart editor, try changing the divisor to 0, and see the error handling in action. ### Using Futures A Future represents the result of an asynchronous operation. Here's an example of how to create and use a Future: ```dart import 'dart:async'; void main() async { Future.delayed(Duration(seconds: 2), () => print('Async Operation Completed')); print('Main function continues...'); await Future.delayed(Duration(seconds: 1), () => print('Awaited futures block main function execution')); print('After await'); } ``` In this example: * We import the `dart:async` library to use the `Future` class. * We use `Future.delayed()` to create a Future that prints a message after 2 seconds. * We call another `Future.delayed()` function with `await` and see it blocking the execution of the main function. **Lab Assignment** 1. Create a new Dart file and write a function that asynchronously simulates a long-running task using `Future.delayed()`. 2. Use a try-catch block to handle any potential errors. 3. Use the `await` keyword to wait for the Future to complete and then continue with the code execution. Example: ```dart import 'dart:async'; void main() async { try { await simulateLongRunningTask(); print('Task completed!'); } catch (e) { print('Error: $e'); } } Future<void> simulateLongRunningTask() async { return Future.delayed(Duration(seconds: 2), () { print('Task in progress...'); // Simulate an error if (DateTime.now().second % 2 == 0) { throw Exception('Simulated error!'); } }); } ``` **Challenge** 1. Modify the `simulateLongRunningTask()` function to use `Future.then()` instead of `await`. 2. Handle the potential error in the `then()` callback instead of using a try-catch block. Example: ```dart import 'dart:async'; void main() { simulateLongRunningTask().then((_) { print('Task completed!'); }).catchError((e) { print('Error: $e'); }); } Future<void> simulateLongRunningTask() { return Future.delayed(Duration(seconds: 2), () { print('Task in progress...'); // Simulate an error if (DateTime.now().second % 2 == 0) { throw Exception('Simulated error!'); } }); } ``` ### Key Takeaways 1. You've gained hands-on experience with using Futures to perform asynchronous operations. 2. You've explored error handling techniques using try-catch blocks and `.catchError()`. 3. You've proficiently utilized the `await` keyword to wait for Futures to complete and then continue with code execution. **Next Steps:** In the next topic, we'll dive into Object-Oriented Programming in Dart, where we'll cover classes and objects. If you have any questions or need assistance, please don't hesitate to leave a comment or ask for help.