Flutter Mobile Development · Lezione

Gestione degli errori nelle operazioni asincrone

Implementi solide strategie di gestione degli errori per le operazioni asincrone, così che la Sua app gestisca correttamente errori di rete ed eccezioni.

Lezione 3 di 411 passaggi

Gestione degli errori nelle operazioni asincrone è una lezione Flutter Mobile Development gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Flutter Mobile Development, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Flutter Mobile Development include 4 lezioni in totale.

Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.

Handling Unpredictable Async Errors

Asynchronous operations, like fetching data from the internet or reading files, are inherently unpredictable. They might succeed, fail, or even time out.

Robust error handling is crucial to prevent your app from crashing and to provide a smooth user experience. It allows you to gracefully manage these failures.

`try-catch` for Async Operations

The familiar try-catch block in Dart is your primary tool for handling exceptions in asynchronous code. When an await expression throws an error, it can be caught by an enclosing try-catch block.

try: Contains the code that might throw an exception.
catch: Catches and handles the exception if one occurs.
on: (Optional) Catches specific types of exceptions.

Catching a Simulated Error

Let's see try-catch in action. This example simulates a network error by throwing an Exception within an async function. Notice how catch handles it.

import 'dart:async';

Future<String> fetchData() async {
  await Future.delayed(Duration(seconds: 1));
  // Simulate a network error
  throw Exception("Failed to fetch data!");
  return "Data received"; // This line won't be reached
}

void main() async {
  print("Starting data fetch...");
  try {
    String data = await fetchData();
    print("Success: $data");
  } catch (e) {
    print("Error caught: $e");
  } finally {
    print("Fetch attempt complete.");
  }
}

Handling Specific Exception Types

Sometimes, you want to handle different types of errors in different ways. The on keyword allows you to catch specific exception types, making your error handling more precise.

For example, you might handle a SocketException (network issue) differently from a generic Exception.

Targeted Error Handling

Here, we define two types of errors: a custom NetworkException and a generic Exception. The on clause lets us provide specific handling for each.

import 'dart:async';

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

Future<void> performNetworkCall(bool shouldFailNetwork) async {
  await Future.delayed(Duration(milliseconds: 500));
  if (shouldFailNetwork) {
    throw NetworkException("No internet connection!");
  } else {
    throw Exception("An unknown error occurred.");
  }
}

void main() async {
  print("Attempt 1: Simulate network failure");
  try {
    await performNetworkCall(true);
  } on NetworkException catch (e) {
    print("Caught specific network error: ${e.message}");
  } catch (e) {
    print("Caught generic error: $e");
  }

  print("\nAttempt 2: Simulate unknown error");
  try {
    await performNetworkCall(false);
  } on NetworkException catch (e) {
    print("Caught specific network error: ${e.message}");
  } catch (e) {
    print("Caught generic error: $e");
  }
}

Ensuring Cleanup with `finally`

The finally block is an optional part of a try-catch statement. Code inside this block will always execute, regardless of whether an exception was thrown or caught.

It's perfect for cleanup operations, like closing a file stream or dismissing a loading indicator, ensuring resources are properly managed.

Alternative: `Future.catchError`

While try-catch works well with async/await, you can also handle errors directly on a Future object using its .catchError() method. This is often used when chaining Futures or when not using await immediately.

It takes a function that will be called if the Future completes with an error.

Handling Errors with `catchError`

Here's how .catchError() can be used. Notice that the error is handled as part of the Future's completion chain, without needing an async function or await for the error handling itself.

import 'dart:async';

Future<String> getUserData() {
  return Future.delayed(Duration(seconds: 1)).then((_) {
    throw Exception("User data not found!");
    return "User data"; // Unreachable
  });
}

void main() {
  print("Fetching user data...");
  getUserData().then((data) {
    print("Success: $data");
  }).catchError((error) {
    print("Error with .catchError(): $error");
  }).whenComplete(() {
    print("User data fetch completed.");
  });
}

Good Practices for Error Handling

Effective error handling makes your app robust and user-friendly:

Log errors: Use a logging framework to record errors for debugging.
Provide feedback: Inform the user about what went wrong (e.g., "Network unavailable").
Retry mechanism: For transient network issues, consider offering a retry option.
Avoid empty catch blocks: Always handle or re-throw errors, don't just swallow them.

Async Error Handling Check

Consider the following Dart code snippet. Which statements about its error handling are true?

import 'dart:async';

Future<String> riskyOperation() async {
  await Future.delayed(Duration(milliseconds: 100));
  if (DateTime.now().second % 2 == 0) {
    throw FormatException("Invalid data format!");
  }
  return "Data processed.";
}

void main() async {
  try {
    String result = await riskyOperation();
    print("Result: $result");
  } on FormatException catch (e) {
    print("Specific error: ${e.message}");
  } catch (e) {
    print("Generic error: $e");
  } finally {
    print("Operation finished.");
  }
}

Rispondi nella lezione interattiva

Recap: Mastering Async Errors

In this lesson, we explored how to handle errors in asynchronous Dart and Flutter applications. You learned:

The importance of robust error handling.
Using try-catch with async/await.
Catching specific exceptions with on.
Ensuring cleanup with finally.
An alternative: Future.catchError().
Best practices for building resilient apps.

Proper error handling is key to creating stable and user-friendly mobile experiences!

Gratis per iniziare

Impara Dart con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 22
Lezioni: 88

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Gestione degli errori nelle operazioni asincrone» è gratuita?

Sì — il testo completo di «Gestione degli errori nelle operazioni asincrone» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Flutter Mobile Development, passa a CoddyKit PRO. Il corso Flutter Mobile Development include 4 lezioni in totale.

Cosa imparerò in «Gestione degli errori nelle operazioni asincrone»?

Implementi solide strategie di gestione degli errori per le operazioni asincrone, così che la Sua app gestisca correttamente errori di rete ed eccezioni. Eserciti Flutter Mobile Development con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Flutter Mobile Development?

Non è richiesta alcuna esperienza precedente. Flutter Mobile Development su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Gestione degli errori nelle operazioni asincrone»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Flutter Mobile Development?

Sì. Ogni lezione Flutter Mobile Development include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Future e async/await
Richieste HTTP e JSON
Gestione degli errori nelle operazioni asincrone
Stream e dati reattivi

← Torna a Flutter Mobile Development