MR. Dev

Blog programistyczny.

Programowanie Reaktywne - Marudzimy - Skip.


Artykuł ten jest częścią serii artykułów na temat Programowania reaktywnego.

Zapraszam na GitHub-a.

Tematy

  1. Wstęp
  2. Zabawa z czasem - Timer
  3. Kto za tym stoi? - Scheduler
  4. Nie zapominaj - Subscribe
  5. Zabawa z czasem - Interval
  6. Zabawa z czasem - Buffer
  7. Zabawa z czasem - Delay
  8. Zabawa z czasem - Sample
  9. Zabawa z czasem - Throttle
  10. Zabawa z czasem - Timestamp/TimeInterval
  11. Tworzymy dane - Generators
  12. Tworzymy dane - Własna klasa publikująca
  13. Marudzimy - Skip
  14. Marudzimy - Take
  15. Łap To! - ConsoleKey
  16. Kombinatorzy - Concat
  17. Kombinatorzy - Repeat
  18. Kombinatorzy - Start With
  19. Kombinatorzy - Ambiguous
  20. Kombinatorzy - Merge
  21. Kombinatorzy - Zip
  22. Kombinatorzy - Switch
  23. Kombinatorzy - When-And-Then
  24. Kombinatorzy - Combine Latest
  25. Transformers - Select
  26. Transformers - OfType and Cast
  27. Transformers - Metadata
  28. Bileciki do kontroli - Unit Tests of Interval
  29. Bileciki do kontroli - Unit Tests of Observer Interval
  30. Bileciki do kontroli - Unit Tests of Create Cold/Hot Observable
  31. Szpryca - AutoFac

Wstęp

Reactive Extensions - Take Po wczorajszym sowitym poście, dzisiaj trochę przystopujemy. Będzie krócej. Poruszymy tematykę marudzenia ;). Marudzić można na dwa sposoby. Albo że się coś chcę albo nie!

Na początek pomarudzimy że czegoś nie chcemy, zapraszam!

Skip - tego nie chce tamtego też…

Na samym początku zapewnimy sobie źródłowe strumienie na jakie bęziemy mogli się zapisywać. Skorzystamy w tym przypadku z biblioteki RXLib opisanej w poprzednim poście. Drugim źródełkiem będzie prosty generator.

1
2
3
4
5
6
7
8
9
10
11
12
13
private static void InitializeGenerators()
{
  _observableProvider = new ObservableProvider();

  var initialState = 0;

  _generator = Observable.Generate(
    initialState,
    condition => condition < GenerateItemCount,
    iterate => iterate + 1,
    resultSelector => resultSelector,
    timeSelector => TimeSpan.FromMilliseconds(100)
  );

Generator bardzo prosty, wypluje co 100ms cyferkę zwiększaną o 1, do uzyskania wartości 20.

Ze strumieniem pochodzącym z generatora mamy powiązane dwie marudy. Pierwsza maruda nie chce ostatnich dziesięciu publikowanych treści. Do tego celu między strumień (_generator), a zapis(Subscribe) dodajemy żądania marudy (SkipLast). Określamy jednocześnie ilu ostatnich publikacji od obiektu obserwowanego nie chcemy.

1
2
3
4
5
6
7
8
private static void AddSkipLastSubscribent()
{
  _skipLastSubscribent = _generator
    .SkipLast(10)
    .Subscribe(
      item =>
      {
        Console.WriteLine($"SkipeLast 10 items from {GenerateItemCount}: {item}");

Reactive Extensions - Take

Druga maruda zależna od strumienia wyplutego przez generator, nie będzie nic robić puki ten właśnie strumień nie przestanie swojego rozpowszechniania treści. “Zacznę działać, ale najpierw niech tamten skończy”.

Podobnie jak poprzednio wstrzykujemy marudę (SkipUntil) między strumień, a zapis na strumień. Uwaga zapis wykonujemy na strumień publikujący licznik czasu (z poprzedniego posta). I przy pomocy SkipUntil określamy jaki inny obiekt publikujący musi przejść w stan OnCompleted by ruszył tyłek.

1
2
3
4
5
6
7
8
private static void AddSkipUntilSubscribent()
{
  _observableProvider.TimeCounter
    .SkipUntil(_generator)
    .Subscribe(
      time =>
      {
        Console.WriteLine($"SkipUntil, ignore: {time}");

Pozostałe marudy już nie będą zależne od _generator.

Pierwszy bardzo prosty Skip. Po prostu nie chce tych początkowych elementów. Podając konkretne kryteria liczbowe. Wstrzykujemy jak poprzednio;).

1
2
3
4
5
6
7
8
private static void AddSkipSubscribent()
{
  _observableProvider.TimeCounter
    .Skip(10)
    .Subscribe(
      time =>
      {
        Console.WriteLine($"Skip (10): {time}");

Na koniec ten szczególnie wybredny (SkipWhile). Co to kręci nosem na żywca (w czasie rzeczywistym). “Zobaczę to zdecyduję, teraz to jeszcze nie wiem”.

Przebiera według określonych warunków co skonsumuje co nie. Ten poniżej nic nie będzie robił przez pierwszą minutę.

1
2
3
4
5
6
7
8
private static void AddSkipWhileSubscribent()
{
  _observableProvider.TimeCounter
    .SkipWhile(x => x.Minutes == 0)
    .Subscribe(
      time =>
      {
        Console.WriteLine($"SkipWhile, ignore first minute: {time}");

Zakończenie

Dzisiaj to tyle marudzenia, jutro ponownie przedstawię kolejne marudy. Czasem marudzenie jest przydatne. Daje większe możliwości;).

PS: Dzisiaj 13 post, być może pechowy. Kto wie co będzie jutro…


Jest to post wchodzący w skład podjętego wyzwania ogłoszonego przez MIROBURN we vlogu z dnia 3 lutego 2018 roku.

Celem wyzwania jest systematyczne działanie w ciągu 30 dni.

Postanowiłem pisać post dziennie o tematyce Programowania Reaktywnego dla platformy .NET.

Wszelkie źródła związane z postami znajdują się na repozytorium GitHub.

Stan obecny wyzwania: 30 z 30 dni.


Referencje:


Wcześniejszy: Programowanie Reaktywne - Tworzymy dane - Własna klasa publikująca

Następny: Programowanie Reaktywne - Marudzimy - Take