Somme courante avec Rx

Question

Il doit y avoir quelqu'un là-bas qui a déjà résolu cela. Imaginez que j'ai une classe qui soulève périodiquement un événement sur le changement d'une valeur (par exemple PropertyChanged) Cette valeur n'est rien d'autre qu'une somme d'argent. Maintenant, je voudrais utiliser Rx pour obtenir la somme de l'augmentation de ces 10 dernières minutes. par exemple. BufferWithTime n'aide pas, car j'ai toujours besoin des 10 dernières minutes.

Des idées comment je peux le faire?

tia Martin

Answer 1

La solution consiste à maintenir en dessous de l'état des données d'événements pertinents dans les dix dernières minutes dans une liste à l'aide Observable.Scan. L'état est maintenu sous la forme d'une liste de tuples avec un int (argent) et un DateTime comme valeurs.

var events = Observable.FromEvent<YourEventArgs>(
    h => SomeEvent += h, h => SomeEvent -= h); 
var runningSums = 
    events.Scan(new List<Tuple<int, DateTime>>(), 
       (l, e) => 
       { 
        var now = DateTime.Now; 
        // Add last event data to list. 
        l.Add(Tuple.Create(e.EventArgs.Money, now)); 
        // Return the correct part of the list (everything 
        // from the last ten minutes). 
        return l.Where(t => (now - t.Item2) < 
            TimeSpan.FromMinutes(10)).ToList(); 
       }) 
      .Select(l => l.Sum(t => t.Item1)); 
runningSums.Subscribe(sum => Console.WriteLine(sum)); 

EDIT: Exemple qui ne renvoie pas une nouvelle liste pour chaque événement:

var events = Observable.FromEvent<YourEventArgs>(
    h => SomeEvent += h, h => SomeEvent -= h); 
var runningSums = 
    events.Scan(Tuple.Create(new List<Tuple<int, DateTime>>(), 
          DateTime.Now - TimeSpan.FromMinutes(10)), 
       (l, e) => 
       { 
        var now = DateTime.Now; 
        l.Item1.Add(Tuple.Create(e.EventArgs.Nr, now)); 
        // if (trimming-condition) then trim front of list... 
        return Tuple.Create(l.Item1, now - TimeSpan.FromMinutes(10)); 
       }) 
      .Select(l => l.Item1.Where(t => t.Item2 > l.Item2).Sum(t => t.Item1)); 
runningSums.Subscribe(sum => Console.WriteLine(sum)); 

Answer 2

Eh bien, consultez la solution suivante. Il s'appuie sur la solution présentée précédemment, mais laisse tomber le pur style fonctionnel pour des raisons d'efficacité (et de lisibilité, je pense). Il réutilise aswell le type construit Timestamped pour suivre le calendrier ...

acclamations

public static class RxEntentsions 
     { 
      class TimeLimitedList<T> 
      { 
       public List<Timestamped<T>> Values = new List<Timestamped<T>>(); 
       TimeSpan span; 
       public TimeLimitedList(TimeSpan sp) { span = sp; } 
       public void Add(Timestamped<T> v) 
       { 
        Values.Add(v); 
        Values.RemoveAll(a => a.Timestamp < (DateTime.Now - span)); 
       } 
      } 

      public static IObservable<List<Timestamped<TSource>>> SlidingWindow<TSource>(this IObservable<Timestamped<TSource>> source, TimeSpan slidingWindow) 
      { 
       return source.Scan0(new TimeLimitedList<TSource>(slidingWindow), (acc, v) => { acc.Add(v); return acc; }).Select(a => a.Values); 
      } 
     } 


    static void Main(string[] args) 
    { 
     var gen = Observable.Interval(TimeSpan.FromSeconds(0.25d)).Timestamp(); 
     gen.SlidingWindow(TimeSpan.FromSeconds(1)).Subscribe(slw => {slw.ForEach(e=> Console.WriteLine(e)); Console.WriteLine("--------");}); 
     Console.ReadLine(); 
    }