Async em Métodos de Classe

Parte da seção Programação Orientada a Objetos do Journey de Dart da Coddy — lição 80 de 110.

Agora que você sabe como lidar com a inicialização assíncrona com métodos factory, vamos ver como tornar métodos de instância regulares assíncronos. Isso é simples - basta adicionar async a qualquer método e fazer com que ele retorne um 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');
}

Métodos assíncronos podem acessar e modificar variáveis de instância assim como métodos regulares. A principal diferença é que os chamadores devem usar await para o resultado. Métodos que retornam Future<void> não retornam um valor, mas ainda precisam ser aguardados se você quiser garantir que eles sejam concluídos antes de continuar.

Você também pode combinar múltiplas chamadas assíncronas dentro de um método, ou chamar outros métodos assíncronos da mesma classe:

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

Este padrão é essencial para classes que interagem com recursos externos - APIs, bancos de dados ou qualquer operação que leve tempo.

Desafio

Fácil

Vamos construir um rastreador de carteira de ações que gerencia preços de ações e calcula os valores do portfólio usando métodos assíncronos! Você criará uma classe que simula a busca de dados de ações em tempo real e combina múltiplas operações assíncronas para gerar relatórios.

Você organizará seu código em dois arquivos:

portfolio.dart: Crie uma classe StockPortfolio que rastreia ações e suas quantidades. Sua classe deve ter:
- Um Map<String, int> privado chamado _holdings que armazena os símbolos das ações e o número de cotas possuídas
- Um construtor que inicializa _holdings como um mapa vazio
- Um método addStock(String symbol, int quantity) que adiciona ou atualiza uma posse de ação (não assíncrono)
- Um método assíncrono fetchPrice(String symbol) que retorna um Future<double>. Simule um atraso de 50 milissegundos e, em seguida, retorne um preço calculado como: o comprimento do símbolo multiplicado por 25.5
- Um método assíncrono getStockValue(String symbol) que retorna um Future<double>. Isso deve aguardar (await) fetchPrice para o símbolo, multiplicar pela quantidade possuída e retornar o valor total. Se o símbolo não estiver em holdings, retorne 0.0
- Um método assíncrono getTotalValue() que retorna um Future<double>. Isso deve calcular o valor combinado de todas as posses aguardando getStockValue para cada ação e somando os resultados
- Um método assíncrono generateReport() que retorna um Future<String>. Isso deve construir um relatório mostrando o valor de cada ação e o total. Formate cada linha como [symbol]: $[value] (valor com 1 casa decimal), seguido por uma linha final Total: $[totalValue] (também com 1 casa decimal)
main.dart: Importe seu arquivo de portfólio e demonstre como os métodos assíncronos funcionam juntos dentro de uma classe:
- Crie uma instância de StockPortfolio
- Adicione estas posses: AAPL com 10 cotas, GOOGL com 5 cotas, MSFT com 8 cotas
- Imprima Fetching portfolio data...
- Aguarde (await) e imprima o resultado de generateReport()

Observe como generateReport() chama outros métodos assíncronos dentro da mesma classe e como cada método se baseia nos outros. Use toStringAsFixed(1) para formatar valores decimais!

Saída esperada:

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

Folha de consulta

Para tornar os métodos de instância assíncronos, adicione a palavra-chave async e retorne um 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');
  }
}

Métodos assíncronos podem acessar e modificar variáveis de instância. Os chamadores devem usar await para obter o resultado. Métodos que retornam Future<void> não retornam um valor, mas ainda precisam ser aguardados com await para garantir a conclusão.

Métodos assíncronos podem chamar outros métodos assíncronos dentro da mesma classe:

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

Este padrão é essencial para classes que interagem com recursos externos, como APIs ou bancos de dados.

Experimente você mesmo

import 'portfolio.dart';

void main() async {
  // TODO: Criar uma instância de StockPortfolio

  // TODO: Adicionar ativos:
  // - AAPL com 10 ações
  // - GOOGL com 5 ações
  // - MSFT com 8 ações

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

  // TODO: Aguardar (await) e imprimir o resultado de generateReport()
}