0
votes

Comment puis-je réessayer un avenir dans Dart / Flutter?

J'ai une méthode qui effectue un traitement asynchrone et je souhaite qu'elle réessaye X fois. Comment puis-je y parvenir dans Dart / Flutter?

flutter dart

0 commentaires

3 Réponses :

7
votes

Utilisez cette fonction:

main(List<String> arguments) {

  retry(2, doSometing);

}

Future doSometing() async {
  print("Doing something...");
  await Future.delayed(Duration(milliseconds: 500));
  return "Something";
}

Et pour l'utiliser:

typedef Future<T> FutureGenerator<T>();
Future<T> retry<T>(int retries, FutureGenerator aFuture) async {
  try {
    return await aFuture();
  } catch (e) {
    if (retries > 1) {
      return retry(retries - 1, aFuture);
    }

    rethrow;
  }
}

0 commentaires

1
votes

Voici comment je l'ai implémenté:

  try {
      await retry(
          function: () async {
            _connection = await BluetoothConnection.toAddress(device.address);
          },
          message: 'Bluetooth Connect');
    } catch (e) {
      _log.finest('Bluetooth init failed  ${e.toString()}');
    }

Voici comment je l'utilise:

Future retry<T>(
    {Future<T> Function() function,
    int numberOfRetries = 3,
    Duration delayToRetry = const Duration(milliseconds: 500),
    String message = ''}) async {
  int retry = numberOfRetries;
  List<Exception> exceptions = [];

  while (retry-- > 0) {
    try {
      return await function();
    } catch (e) {
      exceptions.add(e);
    }
    if (message != null) print('$message:  retry - ${numberOfRetries - retry}');
    await Future.delayed(delayToRetry);
  }

  AggregatedException exception = AggregatedException(message, exceptions);
  throw exception;
}

class AggregatedException implements Exception {
  final String message;
  AggregatedException(this.message, this.exceptions)
      : lastException = exceptions.last,
        numberOfExceptions = exceptions.length;

  final List<Exception> exceptions;
  final Exception lastException;
  final int numberOfExceptions;

  String toString() {
    String result = '';
    exceptions.forEach((e) => result += e.toString() + '\\');
    return result;
  }
}

0 commentaires

0
votes

J'ai ajouté un délai facultatif à la réponse de Daniel Oliveira:

retry(2, doSometing, delay: const Duration(seconds: 1));

Vous pouvez l'utiliser comme suit:

typedef Future<T> FutureGenerator<T>();
Future<T> retry<T>(int retries, FutureGenerator aFuture, {Duration delay}) async {
  try {
    return await aFuture();
  } catch (e) {
    if (retries > 1) {
      if (delay != null) {
        await Future.delayed(delay);
      }
      return retry(retries - 1, aFuture);
    }
    rethrow;
  }
}

0 commentaires