Static Initialization

Static Initialization

About

• Run-once Logic: Complex setup
• Lazy Evaluation: Deferred until first use
• Error Handling: Safe initialization
• Alternatives: Top-level functions

Main Topics

1. Lazy Initialization

   • Definition: Deferred execution
   • Example:

     class Config {
       static late final String _apiKey = _loadKey();
     }

2. Complex Setup

   • Definition: Multi-step initialization
   • Example:

     static final Map<String, String> _translations = {
       'greeting': _loadTranslation('greeting'),
       'farewell': _loadTranslation('farewell'),
     };

3. Error Handling

   • Definition: Safe initialization
   • Example:

     static final HttpClient _client = () {
       try {
         return HttpClient()..timeout = const Duration(seconds: 30);
       } catch (e) {
         return _fallbackClient();
       }
     }();

4. Dart’s Approach

   • Definition: No static blocks

   • Example:

     // Alternative patterns:
     static late final _config = _initConfig();
     
     static Config _initConfig() {
       // Complex logic
     }

5. When to Initialize

   • Definition: Timing considerations

   • Example:

     // Eager:
     static final _cache = _buildCache();
     
     // Lazy:
     static late final _cache = _buildCache();

How to Use

• Heavy Setup: Defer with late
• Error-Prone: Wrap in try-catch
• Dependencies: Initialize in order
• Testing: Reset state if needed

How It Works

1. Eager: When class is loaded
2. Lazy: On first access
3. Threading: Single execution
4. Errors: Fail on first access

Example:

class Database {
  static late final _connection = _connect();

  static Future<Connection> _connect() async {
    final conn = await Connection.open();
    await conn.authenticate();
    return conn;
  }
}

Conclusion

While Dart doesn’t have static blocks like some languages, static initialization can still be achieved through lazy variables and helper methods. This approach provides flexibility for complex setup while maintaining Dart’s simplicity and supporting error handling patterns.