How to Handle Exceptions In Dart?

9 minutes read

In Dart, exceptions can be used to handle and manage exceptional situations that may occur during the execution of a program. Exceptions are objects that are thrown and can be caught and handled by surrounding code.


To handle exceptions in Dart, you can use a combination of the try, catch, and finally blocks.

  1. try block: The code inside the try block is monitored for any exceptions. If an exception occurs within this block, it will immediately stop executing and proceed to the catch block.
  2. catch block: This block catches and handles the exceptions thrown within the try block. You can specify the type of exception or use the general catch block to catch any type of exception. You can also define multiple catch blocks with different exception types to handle different exceptions differently.
  3. finally block: This block is executed regardless of whether an exception occurred or not. It is used to perform any cleanup operations or finalize resources. The code inside the finally block will always be executed, even if a return statement is encountered in the try or catch block.


Here's an example of how to handle exceptions in Dart:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
void main() {
  try {
    // Code that may throw an exception
    var result = 10 ~/ 0; // Division by zero exception
    print('Result: $result');
  } catch (e) {
    // Catching and handling the exception
    print('Exception caught: $e');
  } finally {
    // Cleanup or finalization code
    print('Finally block executed');
  }
}


In the above example, dividing 10 by 0 will throw a division by zero exception. The exception is caught in the catch block, which then prints the error message. Finally, the finally block is executed, printing the cleanup message.


By using these exception handling mechanisms, you can gracefully handle and recover from exceptions, making your programs more robust and error-tolerant.

Best Dart Books to Read in 2024

1
Flutter and Dart Cookbook: Developing Full-Stack Applications for the Cloud

Rating is 5 out of 5

Flutter and Dart Cookbook: Developing Full-Stack Applications for the Cloud

2
Flutter Cookbook: Over 100 proven techniques and solutions for app development with Flutter 2.2 and Dart

Rating is 4.9 out of 5

Flutter Cookbook: Over 100 proven techniques and solutions for app development with Flutter 2.2 and Dart

3
Quick Start Guide to Dart Programming: Create High-Performance Applications for the Web and Mobile

Rating is 4.8 out of 5

Quick Start Guide to Dart Programming: Create High-Performance Applications for the Web and Mobile

4
Dart: Up and Running: A New, Tool-Friendly Language for Structured Web Apps

Rating is 4.7 out of 5

Dart: Up and Running: A New, Tool-Friendly Language for Structured Web Apps

5
The Dart Programming Language

Rating is 4.6 out of 5

The Dart Programming Language

6
Mastering Dart: A Comprehensive Guide to Learn Dart Programming

Rating is 4.5 out of 5

Mastering Dart: A Comprehensive Guide to Learn Dart Programming

7
Flutter Cookbook: 100+ step-by-step recipes for building cross-platform, professional-grade apps with Flutter 3.10.x and Dart 3.x, 2nd Edition

Rating is 4.4 out of 5

Flutter Cookbook: 100+ step-by-step recipes for building cross-platform, professional-grade apps with Flutter 3.10.x and Dart 3.x, 2nd Edition

8
Flutter for Beginners: An introductory guide to building cross-platform mobile applications with Flutter 2.5 and Dart, 2nd Edition

Rating is 4.3 out of 5

Flutter for Beginners: An introductory guide to building cross-platform mobile applications with Flutter 2.5 and Dart, 2nd Edition


How to handle file-related exceptions in Dart?

In Dart, you can handle file-related exceptions using try-catch blocks. Here's how you can do it:

  1. Import the dart:io package at the top of your file.
1
import 'dart:io';


  1. Wrap the code that accesses the file in a try-catch block. The catch block will catch any exceptions thrown by file operations.
1
2
3
4
5
try {
  // File-related code here
} catch (e) {
  // Handle the exception here
}


  1. Specify the specific exception types you want to catch in the catch block. This helps in handling the exceptions more precisely. For file-related exceptions, you can catch FileSystemException or FileException (for Web applications).
1
2
3
4
5
6
7
8
9
try {
  // File-related code here
} on FileSystemException catch (e) {
  // Handle FileSystemException
} on FileException catch (e) {
  // Handle FileException
} catch (e) {
  // Handle other exceptions
}


  1. Within the catch block, you can handle the exception accordingly. You can log the error, display an error message, or perform any other desired action.
1
2
3
4
5
6
7
8
9
try {
  // File-related code here
} on FileSystemException catch (e) {
  print('File system exception occurred: ${e.message}');
} on FileException catch (e) {
  print('File exception occurred: ${e.message}');
} catch (e) {
  print('Generic exception occurred: $e');
}


Note: Make sure to import the necessary packages and classes before using file-related operations in Dart.


What is the difference between a catch statement and a rethrow statement in Dart?

In Dart, a catch statement is used in exception handling to catch and handle exceptions. It is typically used within a try-catch block. When an exception occurs within the try block, the catch block is executed, allowing you to handle the exception by performing specific tasks or displaying error messages.


On the other hand, a rethrow statement is used to rethrow an exception that was caught within a catch block. It allows you to propagate the exception to an outer catch block or rethrows it to the caller of the current function. This can be useful when you want to handle certain exceptions locally but still propagate others for higher-level exception handling. Rethrowing an exception preserves its original stack trace, so you can trace its origin and diagnose the issue more effectively.


What is the role of the StackTrace object in exception handling in Dart?

The StackTrace object in Dart is used to represent a stack trace, which is a representation of the call stack at a particular point in time. In exception handling, the StackTrace object provides information about the sequence of method calls that led to the exception being thrown.


When an exception occurs, Dart captures the current call stack and includes it in the exception object. This allows developers to inspect the sequence of method invocations and understand the flow of execution leading to the exception.


The StackTrace object can be accessed using the 'stackTrace' property of an Exception object. It provides methods and properties to access information about the call stack, such as the number of frames, the name of the functions in each frame, and the line numbers of the corresponding source code.


Developers can use the StackTrace object to log or display detailed information about the exception, aiding in debugging and troubleshooting. It helps in identifying the location and cause of exceptions, as well as understanding the context in which they occurred.

Facebook Twitter LinkedIn Whatsapp Pocket

Related Posts:

To send emails via Gmail from Dart, you can use the mailer package. Here are the steps to achieve this:Set up your Dart project by creating a new Dart file and importing the necessary packages. import 'package:mailer/mailer.dart'; import 'package:m...
Dart DevTools is a powerful tool for debugging Dart applications. It provides a comprehensive set of features to help you understand and analyze the behavior of your code during runtime. Here's an overview of how to use Dart DevTools for debugging:Installa...
To read user input in Dart, you can use the standard input/output methods provided by the dart:io library. Here's how you can do it:Import the dart:io library: import 'dart:io'; Create an instance of the stdin object from the io library: var input ...