L'asynchrone dans les méthodes de classe

Fait partie de la section Programmation Orientée Objet du Journey Dart de Coddy — leçon 80 sur 110.

Maintenant que vous savez comment gérer l'initialisation asynchrone avec des méthodes factory, voyons comment rendre les méthodes d'instance régulières asynchrones. C'est simple : il suffit d'ajouter async à n'importe quelle méthode et de lui faire retourner un Future.

class WeatherService {
  String _location;
  
  WeatherService(this._location);
  
  Future<String> fetchTemperature() async {
    await Future.delayed(Duration(seconds: 1));
    return '22°C in $_location';
  }
  
  Future<void> updateLocation(String newLocation) async {
    await Future.delayed(Duration(milliseconds: 500));
    _location = newLocation;
    print('Location updated to $_location');
  }
}

Future<void> main() async {
  var service = WeatherService('London');
  var temp = await service.fetchTemperature();
  print(temp);
  
  await service.updateLocation('Paris');
}

Les méthodes asynchrones peuvent accéder aux variables d'instance et les modifier tout comme les méthodes régulières. La différence clé est que les appelants doivent await le résultat. Les méthodes retournant Future<void> ne retournent pas de valeur mais doivent tout de même être attendues si vous voulez vous assurer qu'elles se terminent avant de continuer.

Vous pouvez également combiner plusieurs appels asynchrones au sein d'une méthode, ou appeler d'autres méthodes asynchrones de la même classe :

Future<String> getFullReport() async {
  var temp = await fetchTemperature();
  var humidity = await fetchHumidity();
  return '$temp, Humidity: $humidity';
}

Ce modèle est essentiel pour les classes qui interagissent avec des ressources externes - API, bases de données ou toute opération qui prend du temps.

Défi

Facile

Construisons un gestionnaire de portefeuille boursier qui gère les cours des actions et calcule la valeur du portefeuille à l'aide de méthodes asynchrones ! Vous allez créer une classe qui simule la récupération de données boursières en temps réel et combine plusieurs opérations asynchrones pour générer des rapports.

Vous organiserez votre code en deux fichiers :

portfolio.dart : Créez une classe StockPortfolio qui suit les actions et leurs quantités. Votre classe doit comporter :
- Une Map<String, int> privée nommée _holdings qui stocke les symboles boursiers et le nombre d'actions détenues
- Un constructeur qui initialise _holdings comme une map vide
- Une méthode addStock(String symbol, int quantity) qui ajoute ou met à jour une détention d'actions (non asynchrone)
- Une méthode asynchrone fetchPrice(String symbol) qui retourne un Future<double>. Simulez un délai de 50 millisecondes, puis retournez un prix calculé comme suit : la longueur du symbole multipliée par 25.5
- Une méthode asynchrone getStockValue(String symbol) qui retourne un Future<double>. Celle-ci doit attendre (await) fetchPrice pour le symbole, multiplier par la quantité détenue, et retourner la valeur totale. Si le symbole n'est pas dans les détentions, retournez 0.0
- Une méthode asynchrone getTotalValue() qui retourne un Future<double>. Celle-ci doit calculer la valeur combinée de toutes les détentions en attendant getStockValue pour chaque action et en additionnant les résultats
- Une méthode asynchrone generateReport() qui retourne un Future<String>. Celle-ci doit construire un rapport montrant la valeur de chaque action et le total. Formatez chaque ligne comme [symbol]: $[value] (valeur avec 1 décimale), suivie d'une ligne finale Total: $[totalValue] (également avec 1 décimale)
main.dart : Importez votre fichier de portefeuille et démontrez comment les méthodes asynchrones fonctionnent ensemble au sein d'une classe :
- Créez une instance de StockPortfolio
- Ajoutez ces détentions : AAPL avec 10 actions, GOOGL avec 5 actions, MSFT avec 8 actions
- Affichez Fetching portfolio data...
- Attendez (await) et affichez le résultat de generateReport()

Remarquez comment generateReport() appelle d'autres méthodes asynchrones au sein de la même classe, et comment chaque méthode s'appuie sur les autres. Utilisez toStringAsFixed(1) pour formater les valeurs décimales !

Sortie attendue :

Fetching portfolio data...
AAPL: $1020.0
GOOGL: $637.5
MSFT: $816.0
Total: $2473.5

Aide-mémoire

Pour rendre les méthodes d'instance asynchrones, ajoutez le mot-clé async et retournez un Future :

class WeatherService {
  String _location;
  
  WeatherService(this._location);
  
  Future<String> fetchTemperature() async {
    await Future.delayed(Duration(seconds: 1));
    return '22°C in $_location';
  }
  
  Future<void> updateLocation(String newLocation) async {
    await Future.delayed(Duration(milliseconds: 500));
    _location = newLocation;
    print('Location updated to $_location');
  }
}

Les méthodes asynchrones peuvent accéder aux variables d'instance et les modifier. Les appelants doivent utiliser await pour obtenir le résultat. Les méthodes retournant Future<void> ne renvoient pas de valeur mais doivent tout de même être attendues avec await pour garantir leur exécution complète.

Les méthodes asynchrones peuvent appeler d'autres méthodes asynchrones au sein de la même classe :

Future<String> getFullReport() async {
  var temp = await fetchTemperature();
  var humidity = await fetchHumidity();
  return '$temp, Humidity: $humidity';
}

Ce modèle est essentiel pour les classes qui interagissent avec des ressources externes telles que des API ou des bases de données.

Essayez vous-même

import 'portfolio.dart';

void main() async {
  // TODO: Créer une instance de StockPortfolio

  // TODO: Ajouter des positions :
  // - AAPL avec 10 actions
  // - GOOGL avec 5 actions
  // - MSFT avec 8 actions

  // TODO: Afficher "Fetching portfolio data..."

  // TODO: Attendre et afficher le résultat de generateReport()
}