Programação Assíncrona

Future

Future representa um valor que estará disponível no futuro:

Future<String> buscarDados() {
  return Future.delayed(Duration(seconds: 2), () {
    return "Dados carregados";
  });
}

// Usando then
buscarDados().then((dados) {
  print(dados);
});

// Usando catchError para tratar erros
Future<int> dividir(int a, int b) {
  return Future.value(a ~/ b);
}

dividir(10, 0).then((resultado) {
  print(resultado);
}).catchError((erro) {
  print("Erro: $erro");
});

async / await

async e await tornam o código assíncrono mais legível:

Future<String> buscarUsuario() async {
  await Future.delayed(Duration(seconds: 1));
  return "João";
}

Future<void> processar() async {
  print("Iniciando...");
  String usuario = await buscarUsuario();
  print("Usuário: $usuario");
  print("Finalizando...");
}

processar();

Tratamento de erros com async/await

Future<int> dividir(int a, int b) async {
  if (b == 0) {
    throw ArgumentError("Divisão por zero");
  }
  return a ~/ b;
}

Future<void> calcular() async {
  try {
    int resultado = await dividir(10, 0);
    print(resultado);
  } catch (e) {
    print("Erro: $e");
  }
}

Delay

Future.delayed cria um delay:

Future<void> aguardar() async {
  print("Aguardando 2 segundos...");
  await Future.delayed(Duration(seconds: 2));
  print("Pronto!");
}

Stream

Stream representa uma sequência de eventos assíncronos:

Stream<int> contar() async* {
  for (int i = 1; i <= 5; i++) {
    await Future.delayed(Duration(seconds: 1));
    yield i;
  }
}

void ouvir() async {
  await for (int numero in contar()) {
    print(numero);
  }
}

Exercícios

1. Future básico: Crie uma função assíncrona buscarNome que simule uma busca de dados (use Future.delayed com 2 segundos) e retorne um nome. Use .then() para processar o resultado.

2. async/await: Crie uma função assíncrona que busque o nome de um usuário e depois busque o email desse usuário (simule com delays). Use async/await para tornar o código mais legível.

3. Tratamento de erros: Crie uma função assíncrona que pode falhar. Use try-catch para tratar erros em operações assíncronas.

4. Múltiplos Futures: Crie duas funções assíncronas que retornam números. Use Future.wait() para executá-las em paralelo e somar os resultados.

5. Stream: Crie um Stream que emita números de 1 a 10 com intervalo de 1 segundo entre cada número. Use await for para consumir o Stream e imprimir os números.

Soluções

Ver solução do exercício 1

Future<String> buscarNome() {
  return Future.delayed(Duration(seconds: 2), () {
    return "João Silva";
  });
}

void main() {
  print("Buscando nome...");
  buscarNome().then((nome) {
    print("Nome encontrado: $nome");
  });
  print("Código continua executando...");
}

Ver solução do exercício 2

Future<String> buscarNome() async {
  await Future.delayed(Duration(seconds: 1));
  return "João Silva";
}

Future<String> buscarEmail(String nome) async {
  await Future.delayed(Duration(seconds: 1));
  return "$nome@email.com";
}

Future<void> processarUsuario() async {
  print("Buscando nome...");
  String nome = await buscarNome();
  print("Nome: $nome");
  
  print("Buscando email...");
  String email = await buscarEmail(nome);
  print("Email: $email");
}

void main() async {
  await processarUsuario();
  print("Processamento concluído");
}

Ver solução do exercício 3

Future<int> dividirAssincrono(int a, int b) async {
  await Future.delayed(Duration(seconds: 1));
  if (b == 0) {
    throw ArgumentError("Divisão por zero");
  }
  return a ~/ b;
}

Future<void> calcular() async {
  try {
    int resultado = await dividirAssincrono(10, 2);
    print("Resultado: $resultado");
    
    int resultado2 = await dividirAssincrono(10, 0);
    print("Resultado: $resultado2");
  } catch (e) {
    print("Erro: $e");
  }
}

void main() async {
  await calcular();
}

Ver solução do exercício 4

Future<int> buscarNumero1() async {
  await Future.delayed(Duration(seconds: 2));
  return 10;
}

Future<int> buscarNumero2() async {
  await Future.delayed(Duration(seconds: 1));
  return 20;
}

Future<void> somarNumeros() async {
  print("Buscando números em paralelo...");
  
  List<int> resultados = await Future.wait([
    buscarNumero1(),
    buscarNumero2(),
  ]);
  
  int soma = resultados[0] + resultados[1];
  print("Soma: $soma");
}

void main() async {
  await somarNumeros();
}

Ver solução do exercício 5

Stream<int> contarAteDez() async* {
  for (int i = 1; i <= 10; i++) {
    await Future.delayed(Duration(seconds: 1));
    yield i;
  }
}

Future<void> consumirStream() async {
  print("Iniciando contagem...");
  await for (int numero in contarAteDez()) {
    print("Número: $numero");
  }
  print("Contagem concluída");
}

void main() async {
  await consumirStream();
}