Custom Exceptions In Dart

Custom exceptions in Dart allow developers to create their own exception types to handle specific error scenarios in their applications. By defining custom exceptions, developers can provide more context-sensitive error messages and improve the overall error handling process within their codebase.

What are Custom Exceptions in Dart?

In Dart, exceptions are objects that represent errors that occur during the execution of a program. While Dart provides built-in exception types like FormatException and RangeError, developers can create their own custom exception types by extending the Exception class or any of its subclasses. This customization enables developers to handle errors in a more granular and specific manner, leading to more robust and maintainable code.

History/Background

Custom exceptions have been a fundamental feature of Dart since its early versions. They were introduced to empower developers to define their own exception types tailored to their application's needs. By allowing the creation of custom exceptions, Dart enables developers to structure their error handling mechanisms effectively.

Syntax

To create a custom exception in Dart, you need to define a new class that extends Exception or any of its subclasses. Here's the syntax template:

class CustomException implements Exception {
  final String message;

  CustomException(this.message);

  @override
  String toString() => 'CustomException: $message';
}

In this syntax:

• ✅ CustomException is the custom exception class name.
• ✅ message is a field that stores the error message associated with the exception.
• ✅ The constructor initializes the message field.
• ✅ The toString method provides a string representation of the exception.

Key Features

• ✅ Custom exceptions allow developers to define their own exception types.
• ✅ Developers can include additional data or context in custom exceptions to provide more information about the error.
• ✅ Custom exceptions can be used to differentiate between different error scenarios within an application.

Example 1: Basic Usage

Example
Copy
class CustomException implements Exception {
  final String message;

  CustomException(this.message);

  @override
  String toString() => 'CustomException: $message';
}

void withdrawMoney(int amount) {
  if (amount <= 0) {
    throw CustomException('Invalid amount: $amount');
  }
}

void main() {
  try {
    withdrawMoney(-100);
  } catch (e) {
    print(e);
  }
}
Try it Yourself

Output:

CustomException: Invalid amount: -100

In this example, we define a custom exception CustomException and use it to handle an error scenario where a negative amount is passed to the withdrawMoney function.

Example 2: Practical Application

class AgeException implements Exception {
  final String message;

  AgeException(this.message);

  @override
  String toString() => 'AgeException: $message';
}

void checkAge(int age) {
  if (age < 0 || age > 120) {
    throw AgeException('Invalid age: $age');
  }
}

void main() {
  try {
    checkAge(150);
  } catch (e) {
    print(e);
  }
}

Output:

AgeException: Invalid age: 150

In this example, we create a custom exception AgeException to handle invalid age values in an application.

Common Mistakes to Avoid

1. Not Using Custom Exception Classes

Problem: Beginners often throw generic exceptions instead of creating specific custom exceptions for their application needs.

// BAD - Don't do this
void validateAge(int age) {
  if (age < 0) {
    throw Exception("Age cannot be negative");
  }
}

Solution:

// GOOD - Do this instead
class InvalidAgeException implements Exception {
  String cause;
  InvalidAgeException(this.cause);
}

void validateAge(int age) {
  if (age < 0) {
    throw InvalidAgeException("Age cannot be negative");
  }
}

Why: Using generic exceptions makes it difficult to understand the context of the error. Custom exceptions provide clarity and make error handling more efficient.

2. Overusing Exception Hierarchy

Problem: Some beginners create an overly complex hierarchy of exceptions, making the code harder to understand and maintain.

// BAD - Don't do this
class MyAppException implements Exception {}
class NetworkException extends MyAppException {}
class DatabaseException extends MyAppException {}
class UserNotFoundException extends DatabaseException {}

Solution:

// GOOD - Do this instead
class AppException implements Exception {}
class NetworkException extends AppException {}
class DatabaseException extends AppException {}

Why: While it's important to categorize exceptions, overcomplicating the hierarchy can lead to confusion. Aim for a simpler structure that still allows for efficient handling.

3. Failing to Catch Specific Exceptions

Problem: Beginners often catch all exceptions rather than specifying which ones to catch, leading to hidden bugs.

// BAD - Don't do this
try {
  // Some risky operation
} catch (e) {
  print("An error occurred: $e");
}

Solution:

// GOOD - Do this instead
try {
  // Some risky operation
} on InvalidAgeException catch (e) {
  print("Invalid age: ${e.cause}");
} on NetworkException catch (e) {
  print("Network error: ${e.toString()}");
}

Why: Catching all exceptions makes debugging difficult as it obscures the actual issue. Always aim to catch specific exceptions to handle them appropriately.

4. Not Providing Useful Error Messages

Problem: Beginners often throw exceptions without meaningful messages, making it hard for developers to debug issues.

// BAD - Don't do this
class InvalidInputException implements Exception {}

Solution:

// GOOD - Do this instead
class InvalidInputException implements Exception {
  final String message;
  InvalidInputException(this.message);
  
  @override
  String toString() => "InvalidInputException: $message";
}

Why: Providing descriptive error messages helps developers understand the nature of the error quickly. It also assists in logging and debugging efforts.

5. Ignoring Exception Handling in Asynchronous Code

Problem: Beginners often overlook exception handling in async functions, leading to unhandled exceptions that crash the application.

// BAD - Don't do this
Future<void> fetchData() async {
  final response = await http.get('https://example.com/data');
  if (response.statusCode != 200) {
    throw Exception('Failed to load data');
  }
}

Solution:

// GOOD - Do this instead
Future<void> fetchData() async {
  try {
    final response = await http.get('https://example.com/data');
    if (response.statusCode != 200) {
      throw InvalidInputException('Failed to load data');
    }
  } on Exception catch (e) {
    print('Error occurred: ${e.toString()}');
  }
}

Why: Async operations can fail without proper handling, leading to crashes. Always use try-catch blocks to manage exceptions in asynchronous code.

Best Practices

1. Define Clear Custom Exception Classes

Creating clear and specific custom exception classes improves code readability and maintainability.

2. Implement `toString` Method

Override the toString method in your custom exceptions to provide detailed error messages.

class CustomException implements Exception {
  final String message;
  CustomException(this.message);
  
  @override
  String toString() => "CustomException: $message";
}

3. Use Stack Traces

When catching exceptions, log or capture the stack trace to diagnose issues effectively.

4. Document Your Exceptions

Document how and when to use your custom exceptions in comments or documentation.

5. Avoid Overusing Exception Handling for Control Flow

Use exceptions for exceptional conditions, not for normal control flow.

6. Test Exception Handling

Write unit tests to verify that your exceptions are being thrown and caught correctly.

Key Points