GoDev

Blog programisty.

Programowanie Reaktywne - Zabawa z czasem - Buffer.


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 - Buffer

Dużo tych operatorów na klasie Observable powiązanych z czasem można znaleźć w bibliotece Rx-ów. Dzisiaj zajmiemy się dość ciekawym tworem, dzięki któremu możemy operować strumieniami niczym światłami drogowymi…

Observable.Buffer

Bufor działa jak zapora pomiędzy danymi do publikacji a samą publikacją. Gdzie analogia do świateł? Dojeżdżając do skrzyżowania, jeżeli mamy szczęście to jest zielone i jedziemy. Natomiast jeśli trafimy na ten gorszy czas to wówczas jesteśmy “zbuforowani” do czasu, gdy światła ponownie nas przepuszczą.

Podobnie jest z Observable.Buffer, gromadzi on pule do publikacji i wypuszcza ją, dopiero gdy upłynie określony czas.

Najpierw przygotujemy sobie dane, to znaczy będziemy generować samochody dojeżdżające do świateł. Co 500ms nowy samochód.

1
2
3
4
5
6
7
_observableCarList = Observable.Interval(TimeSpan.FromMilliseconds(500));

_intervalSubscribent = _observableCarList.Subscribe(
  carId =>
	{
	  Console.WriteLine($"New Car {carId} ");
	});

Skoro już samochody mamy zapewnione to pora zainicjować buffor:

1
2
3
4
var wait = TimeSpan.FromSeconds(2);
var period = TimeSpan.FromSeconds(5);

_bufferObservable = Observable.Buffer(_observableCarList, wait, period);

Przy pomocy operatora Observable.Buffer tworzymy nowy obiekt do obserwowania. Jako parametry podajemy opóźnienie pierwszej publikacji strumienia samochodu (wait).

Drugi parametr period określa co ile będą publikowane kolejne partie samochodów na strumień.

Pozostaje jeszcze obsłużyć strumień samochodów. Czyli je przepuszczać, gdy światło będzie zielone i zatrzymywać, gdy będzie zielone:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
_bufferSubscribent = _bufferObservable.Subscribe(
  newCars =>
	{
	  try
		{
		  Console.WriteLine("Green light!");

			foreach (var carId in newCars)
			{
				Console.WriteLine($"\t\tPass car {carId}.");
				Thread.Sleep(100);
			}

			Console.WriteLine("Red light!");
			Console.WriteLine();
		}
		catch (Exception e)
		{
			Console.WriteLine(e);
		}
	},
() => Console.WriteLine("Completed"));

Reactive Extensions - Buffer

W pętli dodałem opóźnienie w celach demonstracyjnych tak by symulować przejeżdżanie samochodów.

Zawartość newCars będzie zawierała wygenerowaną sekwencję danych(samochodów) w danej chwili. Jeżeli coś się wydarzy nie przewidzianego to wówczas cała lista zostanie utracona!

Zakończenie

Taki kulawy przykład myślę, że przynajmniej po części pozwoli na zrozumienie Observable.Buffer. Oczywiście metoda zawiera wiele braci i sióstr. Jednak zapoznałem Was tylko z jedną. Proponuję poeksperymentować tak jak Ja to zrobiłem w tym przykładzie. Zapraszam na GitHub-a!


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 - Zabawa z czasem - Interval

Następny: Programowanie Reaktywne - Zabawa z czasem - Delay