Programowanie Reaktywne - Kombinatorzy - Merge.

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

Zapraszam na GitHub-a.

Tematy

Wstęp

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}");
  },

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

Programowanie Reaktywne - Kombinatorzy - Merge.

Wstęp

Observable.Merge

Zakończenie

Dołącz do newslettera.

Na temat Modelu C4.

Newsletter o modelowaniu.

Szkoła Event Stormingu

Zapisz się na listę :)