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 tu sais gérer l’initialisation asynchrone avec des méthodes de fabrique, voyons comment rendre asynchrones des méthodes d’instance ordinaires. C’est simple : ajoute simplement async à n’importe quelle méthode et fais-lui renvoyer 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 ordinaires. La principale différence est que les appelants doivent utiliser await pour obtenir le résultat. Les méthodes qui renvoient Future<void> ne renvoient aucune valeur, mais doivent tout de même être attendues si tu veux t’assurer qu’elles se terminent avant de poursuivre.

Tu peux également combiner plusieurs appels asynchrones dans 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 : des API, des bases de données ou toute opération qui prend du temps.

Défi

Facile

Créons un outil de suivi de portefeuille d’actions qui gère les cours des actions et calcule la valeur du portefeuille à l’aide de méthodes asynchrones ! Tu vas 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.

Tu vas organiser ton code dans deux fichiers :

portfolio.dart : crée une classe StockPortfolio qui suit les actions et leurs quantités. Ta classe doit contenir :
- Une Map<String, int> privée appelée _holdings qui stocke les symboles des actions et le nombre de parts détenues
- Un constructeur qui initialise _holdings avec une map vide
- Une méthode addStock(String symbol, int quantity) qui ajoute ou met à jour une position (non asynchrone)
- Une méthode asynchrone fetchPrice(String symbol) qui renvoie un Future<double>. Simule un délai de 50 millisecondes, puis renvoie un cours calculé ainsi : la longueur du symbole multipliée par 25.5
- Une méthode asynchrone getStockValue(String symbol) qui renvoie un Future<double>. Elle doit attendre le résultat de fetchPrice pour le symbole, le multiplier par la quantité détenue et renvoyer la valeur totale. Si le symbole ne figure pas dans les positions, renvoie 0.0
- Une méthode asynchrone getTotalValue() qui renvoie un Future<double>. Elle doit calculer la valeur combinée de toutes les positions en attendant le résultat de getStockValue pour chaque action et en additionnant les résultats
- Une méthode asynchrone generateReport() qui renvoie un Future<String>. Elle doit générer un rapport indiquant la valeur de chaque action et la valeur totale. Formate chaque ligne ainsi : [symbol]: $[value] (valeur avec 1 décimale), puis ajoute une dernière ligne Total: $[totalValue] (également avec 1 décimale)
main.dart : importe ton fichier de portefeuille et montre comment les méthodes asynchrones fonctionnent ensemble au sein d’une classe :
- Crée une instance de StockPortfolio
- Ajoute ces positions : AAPL avec 10 parts, GOOGL avec 5 parts, MSFT avec 8 parts
- Affiche Fetching portfolio data...
- Attends le résultat de generateReport(), puis affiche-le

Remarque que generateReport() appelle d’autres méthodes asynchrones de la même classe, et que chaque méthode s’appuie sur les autres. Utilise toStringAsFixed(1) pour formater les valeurs décimales !

Résultat attendu :

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

Essayez vous-même

import 'portfolio.dart';

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

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

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

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