> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Dart Try-Finally
The `try-finally` statement is a control flow construct that guarantees the execution of a designated block of code (`finally`), irrespective of whether an exception is thrown, caught, or left unhandled within the associated `try` block. It provides a deterministic execution path for state finalization.
```dart theme={"dark"}
try {
// Protected code block
} finally {
// Unconditional execution block
}
```
## Execution Mechanics
The Dart runtime enforces strict rules regarding the evaluation order and control flow transfer within a `try-finally` structure:
1. **Standard Execution:** If the `try` block completes normally (meaning it reaches the end of the block without completing abruptly via a throw or control transfer), control flow immediately transfers to the `finally` block. This applies regardless of whether the block's execution is synchronous or asynchronous.
2. **Exception Propagation:** If an exception is thrown within the `try` block and is not caught by an intervening `on` or `catch` clause, the `try` block terminates immediately. The `finally` block then executes. Once the `finally` block completes, the unhandled exception resumes propagating up the call stack.
3. **Control Flow Interception:** If the `try` or `catch` block encounters a control transfer statement (`return`, `break`, `continue`, `throw`, or `rethrow`), the `finally` block intercepts the transfer. The `finally` block executes completely before the control transfer is finalized.
## Syntax with Catch Clauses
While `try` and `finally` can exist exclusively together, `finally` is often positioned as the terminal clause in a broader exception-handling chain. The `finally` block will always execute after all `try`, `on`, and `catch` blocks have resolved.
```dart theme={"dark"}
try {
// Protected code block
} on FormatException {
// Type-specific exception handler
} catch (e, stackTrace) {
// General exception handler
} finally {
// Unconditional execution block
}
```
## Return Value Evaluation
When a `return` statement is invoked inside a `try` block, the expression being returned is evaluated *before* the `finally` block executes, but the actual return to the caller is deferred until *after* the `finally` block completes.
```dart theme={"dark"}
int evaluateFlow() {
try {
return 1; // Expression '1' is evaluated, but control flow is suspended
} finally {
print('Executes prior to the caller receiving the return value');
}
}
```
If the `finally` block itself contains a control transfer statement (such as `return` or `throw`), it overrides any pending control transfer from the `try` or `catch` blocks.
Tired of Poor Dart Skills? Fix That With Deep Grasping!
Learn More
