Async in Klassenmethoden

Teil des Abschnitts Objektorientierte Programmierung der Dart-Journey von Coddy — Lektion 80 von 110.

Da Sie nun wissen, wie man die asynchrone Initialisierung mit Factory-Methoden handhabt, schauen wir uns an, wie man reguläre Instanzmethoden asynchron macht. Dies ist unkompliziert – fügen Sie einfach async zu jeder beliebigen Methode hinzu und lassen Sie sie ein Future zurückgeben.

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');
}

Asynchrone Methoden können auf Instanzvariablen zugreifen und diese ändern, genau wie reguläre Methoden. Der Hauptunterschied besteht darin, dass Aufrufer das Ergebnis mit await abwarten müssen. Methoden, die Future<void> zurückgeben, geben keinen Wert zurück, müssen aber dennoch abgewartet werden, wenn Sie sicherstellen möchten, dass sie abgeschlossen sind, bevor Sie fortfahren.

Sie können auch mehrere asynchrone Aufrufe innerhalb einer Methode kombinieren oder andere asynchrone Methoden aus derselben Klasse aufrufen:

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

Dieses Muster ist essenziell für Klassen, die mit externen Ressourcen interagieren – APIs, Datenbanken oder jede Operation, die Zeit in Anspruch nimmt.

Aufgabe

Einfach

Lassen Sie uns einen Aktienportfolio-Tracker erstellen, der Aktienkurse verwaltet und Portfoliowerte mithilfe von asynchronen Methoden berechnet! Sie werden eine Klasse erstellen, die das Abrufen von Echtzeit-Aktiendaten simuliert und mehrere asynchrone Operationen kombiniert, um Berichte zu erstellen.

Sie werden Ihren Code in zwei Dateien organisieren:

portfolio.dart: Erstellen Sie eine Klasse StockPortfolio, die Aktien und deren Mengen verfolgt. Ihre Klasse sollte Folgendes enthalten:
- Eine private Map<String, int> namens _holdings, die Aktiensymbole und die Anzahl der im Besitz befindlichen Aktien speichert
- Einen Konstruktor, der _holdings als leere Map initialisiert
- Eine Methode addStock(String symbol, int quantity), die einen Aktienbestand hinzufügt oder aktualisiert (nicht asynchron)
- Eine asynchrone Methode fetchPrice(String symbol), die ein Future<double> zurückgibt. Simulieren Sie eine Verzögerung von 50 Millisekunden und geben Sie dann einen Preis zurück, der wie folgt berechnet wird: die Länge des Symbols multipliziert mit 25.5
- Eine asynchrone Methode getStockValue(String symbol), die ein Future<double> zurückgibt. Diese sollte fetchPrice für das Symbol abwarten, mit der gehaltenen Menge multiplizieren und den Gesamtwert zurückgeben. Wenn das Symbol nicht in den Beständen ist, geben Sie 0.0 zurück
- Eine asynchrone Methode getTotalValue(), die ein Future<double> zurückgibt. Diese sollte den kombinierten Wert aller Bestände berechnen, indem sie getStockValue für jede Aktie abwartet und die Ergebnisse summiert
- Eine asynchrone Methode generateReport(), die ein Future<String> zurückgibt. Diese sollte einen Bericht erstellen, der den Wert jeder Aktie und die Gesamtsumme anzeigt. Formatieren Sie jede Zeile als [symbol]: $[value] (Wert mit 1 Dezimalstelle), gefolgt von einer letzten Zeile Total: $[totalValue] (ebenfalls 1 Dezimalstelle)
main.dart: Importieren Sie Ihre Portfolio-Datei und demonstrieren Sie, wie asynchrone Methoden innerhalb einer Klasse zusammenarbeiten:
- Erstellen Sie eine Instanz von StockPortfolio
- Fügen Sie diese Bestände hinzu: AAPL mit 10 Aktien, GOOGL mit 5 Aktien, MSFT mit 8 Aktien
- Geben Sie Fetching portfolio data... aus
- Warten Sie auf das Ergebnis von generateReport() und geben Sie es aus

Beachten Sie, wie generateReport() andere asynchrone Methoden innerhalb derselben Klasse aufruft und wie jede Methode auf den anderen aufbaut. Verwenden Sie toStringAsFixed(1), um Dezimalwerte zu formatieren!

Erwartete Ausgabe:

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

Spickzettel

Um Instanzmethoden asynchron zu machen, fügen Sie das Schlüsselwort async hinzu und geben Sie ein Future zurück:

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');
  }
}

Asynchrone Methoden können auf Instanzvariablen zugreifen und diese ändern. Aufrufer müssen auf das Ergebnis mit await warten. Methoden, die Future<void> zurückgeben, liefern keinen Wert, müssen aber dennoch mit await aufgerufen werden, um den Abschluss sicherzustellen.

Asynchrone Methoden können andere asynchrone Methoden innerhalb derselben Klasse aufrufen:

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

Dieses Muster ist essenziell für Klassen, die mit externen Ressourcen wie APIs oder Datenbanken interagieren.

Probier es selbst

import 'portfolio.dart';

void main() async {
  // TODO: Erstelle eine StockPortfolio-Instanz

  // TODO: Bestände hinzufügen:
  // - AAPL mit 10 Aktien
  // - GOOGL mit 5 Aktien
  // - MSFT mit 8 Aktien

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

  // TODO: Das Ergebnis von generateReport() abwarten und ausgeben
}