Welke benaderingen en methoden worden gebruikt voor foutafhandeling in Kotlin-coroutines?

In Kotlin zijn er verschillende benaderingen voor het afhandelen van fouten in coroutines:

1. try-catch binnen de coroutine — de eenvoudigste manier om uitzonderingen af te handelen. Je kunt de code binnen launch of async in een try-catch blok plaatsen.

launch {
    try {
        // code die een uitzondering kan veroorzaken
    } catch (e: Exception) {
        // foutafhandeling
    }
}

2. CoroutineExceptionHandler — een speciale handler die in de coroutine-context kan worden doorgegeven. Het vangt onbehandelde uitzonderingen in door launch gestartte coroutines.

val handler = CoroutineExceptionHandler { _, exception ->
    println("Gevangen $exception")
}

GlobalScope.launch(handler) {
    throw RuntimeException("Fout")
}

3. Foutafhandeling in async/await — bij gebruik van async worden uitzonderingen niet meteen gegooid, maar bij het aanroepen van await(). Daarom moet await() in een try-catch worden geplaatst.

val deferred = async {
    // code
    throw Exception("Fout")
}

try {
    deferred.await()
} catch (e: Exception) {
    // afhandeling
}

4. SupervisorJob en SupervisorScope — maken het mogelijk om fouten in kind-coroutines te isoleren, zodat een fout niet de hele scope van de ouder annuleert.

De keuze van de methode hangt dus af van de context en het type coroutine (launch of async).