Comment puis-je «mettre en veille» un programme Dart

J'aime simuler un appel de service Web asynchrone dans mon application Dart à des fins de test. Pour simuler le caractère aléatoire de la réponse de ces faux appels (peut-être dans le désordre), j'aimerais programmer mes simulacres pour attendre (dormir) pendant un certain temps avant de renvoyer le «futur».

Comment puis-je faire ceci?

Vous pouvez également utiliser l'usine Future.delayed pour terminer un futur après un délai. Voici un exemple de deux fonctions qui retournent une chaîne de manière asynchrone après un délai:

import 'dart:async';

Future sleep1() {
  return new Future.delayed(const Duration(seconds: 1), () => "1");
}

Future sleep2() {
  return new Future.delayed(const Duration(seconds: 2), () => "2");
}

Ce n'est pas toujours ce que vous voulez (parfois vous voulez Future.delayed), mais si vous voulez vraiment dormir dans votre application de ligne de commande Dart, vous pouvez utiliser dart: io's sleep():

import 'dart:io';

main() {
  sleep(const Duration(seconds:1));
}

Édition 2019:

Dans le code asynchrone

await Future.delayed(Duration(seconds: 1));

Code de synchronisation

import 'dart:io';

sleep(Duration(seconds:1));

Remarque: Cela bloque l'ensemble du processus (isoler), de sorte que les autres fonctions asynchrones ne seront pas traitées. Il n'est pas non plus disponible sur le Web car Javascript est vraiment uniquement asynchrone.

J'ai trouvé qu'il existe plusieurs implémentations dans Dart pour retarder l'exécution du code:

new Future.delayed(const Duration(seconds: 1)); //recommend

new Timer(const Duration(seconds: 1), ()=>print("1 second later."));

sleep(const Duration(seconds: 1)); //import 'dart:io';

new Stream.periodic(const Duration(seconds: 1), (_) => print("1 second later.")).first.then((_)=>print("Also 1 second later."));
//new Stream.periodic(const Duration(seconds: 1)).first.then((_)=>print("Also 1 second later."));

Pour la syntaxe Dart 2+, dans un contexte de fonction asynchrone:

import 'package:meta/meta.dart'; //for @required annotation

void main() async {
  void justWait({@required int numberOfSeconds}) async {
    await Future.delayed(Duration(seconds: numberOfSeconds));
  }

  await justWait(numberOfSeconds: 5);
} 

C'est une simulation utile qui peut prendre un paramètre facultatif pour simuler une erreur:

  Future _mockService([dynamic error]) {
    return new Future.delayed(const Duration(seconds: 2), () {
      if (error != null) {
        throw error;
      }
    });
  }

Vous pouvez l'utiliser comme ceci:

  await _mockService(new Exception('network error'));

J'avais également besoin d'attendre la fin d'un service lors d'un test unitaire. J'ai implémenté de cette façon:

void main()
{
    test('Send packages using isolate', () async {
        await SendingService().execute();
    });
    // Loop to the amount of time the service will take to complete
    for( int seconds = 0; seconds < 10; seconds++ ) {
        test('Waiting 1 second...', () {
            sleep(const Duration(seconds:1));
        } );
    }
}
...
class SendingService {
    Isolate _isolate;
    Future execute() async {
        ...
        final MyMessage msg = new MyMessage(...);
        ...
        Isolate.spawn(_send, msg)
            .then<Null>((Isolate isolate) => _isolate = isolate);
    }
    static void _send(MyMessage msg) {
        final IMyApi api = new IMyApi();
        api.send(msg.data)
            .then((ignored) {
                ...
            })
            .catchError((e) {
                ...
            } );
    }
}