MR. Dev

Blog programisty.

Programowanie Reaktywne - Kombinatorzy - Merge.


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 - Merge To już dwudziesty raz się spotykamy odnośnie Rx-owatych. Tydzień pomału dobiega końca. Taki i zbliżamy się do zakończenia serii postów dotyczących kombinatorów. Okazuje się, że rozpisałem się bardzo w tej podgrupie. W najgorszym wypadku nie zakończę na 30 postach :).

Observable.Merge

Jakże dobrze znany ten termin jest programistom. Zapewne wiele razy spotkaliśmy podczas pracy z GIT-em. Tutaj jednak nie będziemy konfliktować. Operator Observable.Merge przeznaczony jest do łączenia wielu strumieni. Połączeni razem dystrybutorzy tworzą nowy twór (jak w Power Rangers).

Tego samego typu strumienie musisz mieć. Inaczej ciemna strona Mocy odrodzi się.

Użyłem tutaj małego triku w celu wykorzystania innego typu strumienia do Observable.Merge. Przy pomocy małego selekta i rzutowania uzyskałem strumień taki sam jak generowane przez GeneratorFactory.CreateGenerator.

1
2
3
4
5
6
7
8
9
10
11
12
13
var observableProvider = new ObservableProvider();
  var observableGenerator1 = GeneratorFactory.CreateGenerator(0, 100, 1, 100);
  var observableGenerator2 = GeneratorFactory.CreateGenerator(1000, 2000, 2, 600);
  var observableGenerator3 = GeneratorFactory.CreateGenerator(10000, 15000, 51, 1000);

  Console.WriteLine("Press any keys, enter to end ConsoleKey stream.");

  var observableMerge1 = Observable.Merge(
    observableProvider.ConsoleKey.Select(x => (int)x.Key),
    observableGenerator1,
    observableGenerator2,
    observableGenerator3
    );

Złączone w ten sposób strumienie, tworzą jeden. Do niego wystarczy się już tylko zapisać i czerpać dane ze źródełka.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
var consoleKeySubscribent = observableProvider.ConsoleKey.Subscribe(
  key =>
  {
    if (key.Key != ConsoleKey.Enter)
    {
      return;
    }

    observableProvider.ConsoleKey.Stop();

    Console.WriteLine("Press any key to stop program.");
  });

var subscribent1 = observableMerge1.Subscribe(
  item =>
  {
    Console.WriteLine($"Merge1: {item}");
  },

Reactive Extensions - Merge

Dodatkowo oczywiście, zapis na strumień klawiszy pochodzący z konsoli spowoduje nam możliwość jego przerwania przy pomocy Stop().

Oczywiście wiele dróg prowadzi do rozwiązania problemu, zwłaszcza jak mamy takie elastyczne możliwości składania kodu jak w Rx-ach. Podobny efekt uzyskamy wykorzystują poniższy przykład.

1
2
3
4
5
6
7
8
9
10
11
12
var observableMerge2 = GeneratorFactory.CreateGenerator(-1000, 0, 1, 10);
    observableMerge2
      .Merge(observableGenerator1)
      .Merge(observableGenerator2)
      .Merge(observableGenerator3);

    var subscribent2 = observableMerge2.Subscribe(
      item =>
      {
        Console.WriteLine($"Merge2: {item}");
      },
      exception => Console.WriteLine(exception));

Zapewne ten zapis jest bardziej seksy.

Zakończenie

Observable.Merge jest jak bar. Gdzie wiele strumieni spotyka się wieloma odbiorcami. Konsumenci i producenci razem w jednym miejscu. Łączy ich jeden główny powód ”%”.

Kończę by sobie już wstydu oszczędzić.

Kod z Wami!.


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 - Kombinatorzy - Ambiguous

Następny: Programowanie Reaktywne - Kombinatorzy - Zip