MR. Dev

Blog programistyczny.

Programowanie Reaktywne - Kombinatorzy - Concat.


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 - Concat Dzisiejszy post, tak jak i kilka następnych będzie dotyczył kombinowania. Będziemy korzystać z wielu strumieni publikujących dane tego samego typu do łączenia ich w jedną całość. I dopiero wówczas będzie można się zapisać do tak stworzonego dystrybutora.

Concat

Na początek bardzo prosty operator, pozwalający na łączyć wiele strumieni w jeden. Działa podobnie jak kolejka FIFO - First Input First Output.

W tym celu stworzyłem prostą metodę pozwalającą na generowanie nowych obiektów do obserwowania w oparciu o Observable.Generate. Będzie nam to potrzebne do łączenia w jeden sekwencyjny strumień.

Jako parametry metody podajemy składowe wymagane do wygenerowania danych przy pomocy Observable.Generate.

1
2
3
4
5
6
7
8
9
10
11
private static IObservable<int> CreateGenerator(int initialState, int conditionValue, int incrementValue, int periodValue)
{
  var period = TimeSpan.FromMilliseconds(periodValue);

  var generator = Observable.Generate(
    initialState,
    condition => condition <= conditionValue,
    iterate => iterate + incrementValue,
    resultSelector => resultSelector,
    timeSelector => period
  );

Reactive Extensions - Concat Dodatkowo by trochę zróżnicować to so się dzieje, skorzystamy także z prostego operatora Observable.Range.

Posłużyłem się także pętlą, tak by pokazać, że można łączyć wielokrotnie wielu dystrybutorów. Poniższy kod generuje 21 sekwencyjnie ze sobą połączonych strumieni. Ostatecznie wykonujemy zapis na tak stworzony miks.

Publikowanie danych przez strumienie odbędzie się z zachowaniem specyfiki danego dostawcy:

  • Observable.Range - będzie to szło jeden po drugim bez zamierzonego opóźnienia,
  • Observable.Generate - w tym przypadku będzie to zależne od timeSelector-a{:.color_2), cykl publikowania pójdzie zgodnie z wartością TimeSpan.
1
2
3
4
5
6
7
8
9
var observableSequence = Observable.Range(0, 5);

for (var i = 0; i < 10; i++)
{
  observableSequence = observableSequence.Concat(CreateGenerator(0, i * 10, 2, 500));
  observableSequence = observableSequence.Concat(Observable.Range(0, 5));
}

observableSequence.Subscribe(Console.WriteLine);

Zakończenie

To już kolejny operator jaki przedstawiam. Jest bardzo dużo. Pozwalają na bardzo wiele manipulacji związanych ze strumieniami. Mam nadzieję, że znajdzie się dla nich zastosowanie w twoim kodowaniu. Dzięki za czytanie i zapraszam do kolejnych postów.


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 - Łap To - ConsoleKey

Następny: Programowanie Reaktywne - Kombinatorzy - Repeat