Streams équivalent à Observable.Throttle?

Question

Existe-t-il un flux équivalent à Observable.Throttle? Si non - existe-t-il un moyen raisonnablement élégant d'obtenir un effet similaire?

Answer 1

Le rate_limit package fournit étranglement et anti-rebond des Streams.

Answer 2

Il n'existe aucune méthode de ce type sur les flux pour le moment. Une demande d'amélioration a été déposée, vous pouvez jouer issue 8492.

Cependant, vous pouvez le faire avec la méthode where. Dans l'exemple suivant, je l'ai défini une classe ThrottleFilter d'ignorer les événements pendant une durée donnée:

import 'dart:async'; 

class ThrottleFilter<T> { 
    DateTime lastEventDateTime = null; 
    final Duration duration; 

    ThrottleFilter(this.duration); 

    bool call(T e) { 
    final now = new DateTime.now(); 
    if (lastEventDateTime == null || 
     now.difference(lastEventDateTime) > duration) { 
     lastEventDateTime = now; 
     return true; 
    } 
    return false; 
    } 
} 

main() { 
    final sc = new StreamController<int>(); 
    final stream = sc.stream; 

    // filter stream with ThrottleFilter 
    stream.where(new ThrottleFilter<int>(const Duration(seconds: 10)).call) 
    .listen(print); 

    // send ints to stream every second, but ThrottleFilter will give only one int 
    // every 10 sec. 
    int i = 0; 
    new Timer.repeating(const Duration(seconds:1), (t) { sc.add(i++); }); 
} 

Answer 3

La version suivante est plus proche de ce que fait Observable.Throttle:

class Throttle extends StreamEventTransformer { 
    final duration; 
    Timer lastTimer; 

    Throttle(millis) : 
    duration = new Duration(milliseconds : millis); 


    void handleData(event, EventSink<int> sink) { 
    if(lastTimer != null){ 
     lastTimer.cancel(); 
    } 
    lastTimer = new Timer(duration,() => sink.add(event)); 
    } 
} 

main(){ 
    //... 
    stream.transform(new Throttle(500)).listen((_) => print(_)); 
    //.. 
}