🛡️ Lesson 6: Error Handling

⏱ 30-40 min 📊 Intermediate 📖 In-depth tutorial 🔗 Official Source

Why Error Handling Matters

🧠 Without error handling, any failure crashes your entire application

Users lose data, trust evaporates, and debugging becomes a nightmare. Proper error handling keeps your app running even when things go wrong, and provides clear feedback about what happened.

❌ Without Handling

// User types invalid number
int age = int.parse('twenty');
// 💥 APP CRASHES — FormatException
// User sees nothing but a crash

😰 Data lost, user frustrated, app appears broken

✅ With Handling

try {
  int age = int.parse(input);
} catch (e) {
  print('Please enter a valid number');
}
// ✅ App stays alive, user sees helpful message

😍 App survives, user gets helpful guidance, trust maintained

Errors vs Exceptions — The Critical Distinction

🧠 Dart distinguishes between two types of problems:

Understanding which is which determines whether you should fix your code or handle the failure gracefully.

🔴 Errors (Programmer Mistakes)

These indicate bugs that should not be caught. They mean your code is wrong and needs to be fixed.

TypeError — calling a method on null
AssertionError — assert condition fails
RangeError — index out of bounds
NoSuchMethodError — calling undefined method

Rule: DON'T catch errors. Fix the bug instead.

🟡 Exceptions (Expected Failures)

These are recoverable situations that should be caught and handled. They're not bugs—they're expected possibilities.

FormatException — invalid data format
IOException — file or network failure
TimeoutException — operation timed out
HttpException — bad HTTP response

Rule: ALWAYS catch and handle exceptions.

🎮 Classify These Scenarios

🔢 Calling .length on null

var x; print(x.length);

📝 Parsing invalid JSON

json.decode('not json');

🌐 Network timeout

http.get() after 30 seconds

📋 Accessing list index -1

list[-1];

Try/Catch/Finally — The Safety Net

🧠 The try/catch/finally structure catches exceptions and keeps your app alive

Think of it as a safety net under a trapeze artist. The try block is the performance, catch catches the fall, and finally cleans up regardless of what happened.

Complete Pattern with Line-by-Line Explanation

try {
  // Code that might throw an exception
  final file = File('data.txt');
  final contents = await file.readAsString();
  print('File loaded: \$contents');
  
} on FileSystemException catch (e) {
  // Catches specific file-related exceptions
  print('Could not read file: \${e.message}');
  
} on FormatException catch (e) {
  // Catches data format problems
  print('File contained invalid data: \$e');
  
} catch (e, stackTrace) {
  // Catches ALL other exceptions
  print('Unexpected error: \$e');
  print('Stack trace: \$stackTrace');
  
} finally {
  // ALWAYS runs — perfect for cleanup
  print('Cleanup: closing resources');
}

📝 Structure Breakdown

1 try wraps risky code

2-4 Normal execution — runs if no errors

6-8 on FileSystemException catches specific type

10-12 on FormatException catches another type

14-17 catch (e, stackTrace) catches everything else

16 stackTrace shows where error occurred

19-21 finally always runs, even after return

🎯 Click Each Block to Learn Its Purpose:

try { — Code that might fail. Dart attempts to execute everything inside.

} on SpecificException catch (e) { — Catch a specific exception type. Use when you know what might go wrong.

} catch (e, stackTrace) { — Catch everything else. Always include as a safety net. stackTrace helps debugging.

} finally { — Cleanup code. Runs whether there was an error or not. Close files, connections, etc.

✏️ Try It: Handle Different Error Types

Output will appear here...

Creating Custom Exceptions

🧠 When built-in exceptions aren't descriptive enough, create your own

Custom exceptions make your code more readable and help consumers understand exactly what went wrong. Implement Exception and override toString() for clear error messages.

🏗️ Build Your Exception

Exception Name:

Properties (name:type, comma-separated):

Implements:

📄 Generated Code

class ValidationException implements Exception {
  final String message;
  final String field;
  final dynamic value;
  
  ValidationException({
    required this.message,
    required this.field,
    this.value,
  });
  
  @override
  String toString() {
    return 'ValidationException: \$message (field: \$field)';
  }
}

Using Your Custom Exception

// Throwing your custom exception
void validateEmail(String email) {
  if (!email.contains('@')) {
    throw ValidationException(
      message: 'Invalid email format',
      field: 'email',
      value: email,
    );
  }
}

// Catching it specifically
try {
  validateEmail('not-an-email');
} on ValidationException catch (e) {
  print('Validation failed: \$e');
  // Validation failed: ValidationException: Invalid email format (field: email)
}

Throw vs Rethrow — Propagating Errors

🧠 Throw creates a new exception. Rethrow preserves the original.

Use throw to raise a new exception with a fresh stack trace. Use rethrow (without arguments) inside a catch block to preserve the original stack trace—crucial for debugging.

📚 Call Stack

main() — starts the app

→ processOrder()

→ validatePayment()

→ 💥 EXCEPTION HERE

📖 Explanation

Click a button to see the difference...

🔼 throw (New Exception)

try {
  riskyOperation();
} catch (e) {
  // Creates NEW exception — loses original trace!
  throw Exception('Something went wrong');
}

⚠️ Stack trace starts from here, original location lost!

🔄 rethrow (Preserve Original)

try {
  riskyOperation();
} catch (e) {
  print('Logging error before rethrowing');
  rethrow; // Preserves original stack trace!
}

✅ Stack trace preserved — shows exactly where error originated!

Real-World Error Handling Patterns

🧠 These are the patterns you'll use in production code

📁 Safe File Reading

Handle missing files gracefully

Click to test...

🌐 Network with Retry

Retry failed requests with backoff

Click to test...

📊 Safe JSON Parsing

Handle malformed data

Click to test...

📝 User Input Validation

Validate and provide feedback

Click to test...

📌 Best Practices Summary:
• Catch specific exceptions first (on FormatException), then general (catch)
• Always include finally for resource cleanup (files, network connections)
• Never swallow exceptions silently — at minimum, log them
• Use rethrow when you need to log but can't fully handle the error
• Create custom exceptions for domain-specific errors

🎯 Error Handling Quiz

Score: 0/5 | Hints: 3

Loading question...

🚀

Practice Projects

Apply what you've learned by building these hands-on projects.

📦 Project 1 📦 Project 2