{"id":563,"date":"2009-11-28T13:46:05","date_gmt":"2009-11-28T12:46:05","guid":{"rendered":"http:\/\/www.minddriven.de\/?p=563"},"modified":"2010-07-10T10:24:56","modified_gmt":"2010-07-10T09:24:56","slug":"rx-event-composition-multi-valued","status":"publish","type":"post","link":"https:\/\/www.minddriven.de\/index.php\/technology\/dot-net\/rx-event-composition-multi-valued","title":{"rendered":"Rx: Event composition – multi-valued"},"content":{"rendered":"

In preparation of some presentation on the Reactive Extensions (Rx)<\/a> last week I’ve investigated the composition methods for several event streams on the Observable<\/code> class. What methods are existing and what are they doing? Let’s take a look…<\/p>\n

This first blog post treats „multi-valued“ event composition in terms of multiple streams going in and one stream comes out, but each element of the output stream is composed by sub-elements from each<\/em> input stream! There is a second blog post<\/a> that treats „single-valued“ event composition as well.<\/p>\n

Example solution<\/h3>\n

I’ve written a little SL3 application where you can discover the behavior of those composition operators. It builds on example code that first has been published by Paul Batum<\/a> some months ago and extends his code with some more possibilities. I’ve hosted the SL3 on Windows Azure where you can test it directly:<\/p>\n

\"Rx<\/a><\/p>\n

You can download the sourcecode of the Visual Studio 2008 solution as well: [Event Composition Sourcecode (ZIP)<\/a>]
\nAll you need to run the solution is the latest Rx for SL3 build, Visual Studio 2008 and the Silverlight 3 SDK.<\/p>\n

Powerpoint Sources<\/h3>\n

If you want to use my diagrams in your presentations or somewhere else, here is the source PPT file: [Rx Event Composition PPT<\/a>]
\nI would be glad if you could leave my name and\/or the blog URL (www.minddriven.de<\/a>) on every diagram.<\/p>\n

How to read the diagrams and code<\/h3>\n

The general visualization concept is taken from Eric Meijer’s PDC session about Rx<\/a>. Thanks Eric for your great work!<\/p>\n

\"Rx<\/p>\n

The visualization shows an Rx composing operator<\/em> in the middle. On the left there are event input streams, on the right is the composed output stream. The order of the events on a timeline is from right to left: the most right event goes first into the operator and comes first out in composed form. This is visualized by the t1<\/sub>, t2<\/sub>, t3<\/sub> and t1<\/sub>‚, t2<\/sub>‚, t3<\/sub>‚ points.<\/p>\n

The sourcecode snippets<\/em> below are kind of abstract. They only show how the operators are used. They are based on 3 streams stream1<\/code>, stream2<\/code> and stream3<\/code>. Those streams can be seen as general abstract event streams, no matter which datatype they’re really using.<\/p>\n

Now let’s come to our multi-valued composition operators…<\/p>\n

SelectMany()<\/h3>\n

The SelectMany<\/code> operator should be known from LINQ on IEnumerable<\/code> or others and is reflected by the from<\/code> keyword in LINQ queries as well. It projects a foreach<\/code> loop or several cascaded foreach<\/code> loops, if you execute multiple SelectMany<\/code> calls after another. Thus the order<\/em> in which SelectMany<\/code> is executed is relevant!<\/p>\n

The same is true for SelectMany<\/code> on IObservable<\/code>. Take the following code:<\/p>\n

\r\nvar composition = \r\n    from element1 in stream1\r\n    from element2 in stream2\r\n    from element3 in stream3\r\n    select new[] { element1, element2, element3 };\r\n<\/pre>\n
This is equal to the following direct use of SelectMany<\/code>:<\/p>\n
\r\nvar composition = \r\n    stream1.SelectMany(\r\n        element1 => stream2.SelectMany(\r\n        element2 => stream3.SelectMany(\r\n        element3 => Observable.Return(new[] { element1, element2, element3 }))));\r\n<\/pre>\n
With this code an example composition scenario could be:<\/p>\n
\"Rx<\/p>\n
Note that the event order is crucial. The first event on every input stream is in the right order, thus yielding to a first composed event. The second event on input stream 2 first fires when the third event on stream 3 is fired. The resulting event in this case contains the first event from stream 1, since it retains the right event order.<\/p>\n
CombineLatest()<\/h3>\n
CombineLatest<\/code> is a very useful operator. It fires everytime when one input stream fires. Then the corresponding output stream contains the latest<\/em> values\/events from each input stream.<\/p>\n
Here’s the code how to use the operator:<\/p>\n
\r\nvar composition = \r\n    stream1.CombineLatest(\r\n        stream2, (element1, element2) => new[] { element1, element2 })\r\n    .CombineLatest(\r\n        stream3, (elements12, element3) => new[] { elements12[0], elements12[1], element3 }));\r\n<\/pre>\n
And an example composition follows:<\/p>\n
\"Rx<\/p>\n
Zip()<\/h3>\n
In comparison to CombineLatest<\/code> and others the Zip<\/code> operator doesn’t use any results from an event stream multiple times. However it builds a queue<\/em> of the events on every input stream. When every input stream queue contains at least one event, the Zip<\/code> composition operator fires. Thus it synchronizes events, whereas every event on an input stream is waiting for an event on the other input streams.<\/p>\n
The following code shows the usage of Zip()<\/code>:<\/p>\n
\r\nvar composition = \r\n    stream1\r\n        .Zip(stream2, (element1, element2) => new[] { element1, element2 })\r\n        .Zip(stream3, (elements12, element3) => new[] { elements12[0], elements12[1], element3 });\r\n<\/pre>\n
And the following diagram shows an example composition. Note that no event is used twice in the output stream and compare this with CombineLatest<\/code> and the other operators:<\/p>\n
\"Rx<\/p>\n
Note that the last event on stream 3 has no „partner“ on the other streams and thus it doesn’t appear on the output stream in this example.<\/p>\n
Also notice that Zip()<\/code> is equal to Join()<\/code> if used with a conjunction of all input event streams as parameter:<\/p>\n
\r\nvar composition = \r\n    Observable.Join(\r\n        stream1.And(stream2).And(stream3)\r\n            .Then((element1, element2, element3) => new[] { element1, element2, element3 }));\r\n<\/pre>\n
Join() – 2 out of 3<\/h3>\n
The Join<\/code> operator can be used in many cases and is very flexible. The method Join()<\/code> can take several event compositions as parameters. Everytime one composition fires, the whole operator fires. That said, if you create a conjunction of all your event streams, then the composed output stream will be equal to Zip()<\/code>.<\/p>\n
But Join<\/code> gives you more power and flexibility. One example is a „2 out of 3“-situation. Imagine you have 3 input streams and want Join<\/code> to fire everytime when 2 input streams contain an event. This can be done by passing Join<\/code> the appropriate partial compositions as shown in the following code:<\/p>\n
\r\nvar composition = \r\n    Observable.Join(\r\n        stream1.And(stream2)\r\n            .Then((element1, element2) => new[] { element1, element2 }),\r\n        stream1.And(stream3)\r\n            .Then((element1, element3) => new[] { element1, element3 }),\r\n        stream2.And(stream3)\r\n            .Then((element2, element3) => new[] { element2, element3 }));\r\n<\/pre>\n
This yields to the following resulting composition for example input streams:<\/p>\n
\"Rx<\/p>\n
Again in this example, the last event on stream 3 has no partner and doesn’t appear on the output stream (due to an odd amount of events over all input event streams).<\/p>\n
ForkJoin()<\/h3>\n
ForkJoin<\/code> can be used if you want a composition to fire exactly once. When all input event streams contain at least one event\/value, the ForkJoin<\/code> operator fires with the first event on every stream. Afterwards it doesn’t react to any changes\/event on the input streams again.<\/p>\n
Here’s the code how ForkJoin<\/code> can be used:<\/p>\n
\r\nvar composition = \r\n    Observable.ForkJoin(stream1, stream2, stream3);\r\n<\/pre>\n
And here’s the diagram of a composition example:<\/p>\n
\"Rx<\/p>\n
That’s it for now, guys. I hope it’s valuable for you. Since these are just my initial ideas on this topic, I’m reliant on your feedback. Together we could make all those descriptions even more useful.<\/p>\n
\"kick<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
In preparation of some presentation on the Reactive Extensions (Rx) last week I’ve investigated the composition methods for several event streams on the Observable class. What methods are existing and what are they doing? Let’s take a look… This first blog post treats „multi-valued“ event composition in terms of multiple streams going in and one … Rx: Event composition – multi-valued<\/span> weiterlesen<\/a><\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[6],"tags":[198,197,181,195,179,178],"class_list":["post-563","post","type-post","status-publish","format-standard","hentry","category-dot-net","tag-combining","tag-composition","tag-events","tag-reactive-extensions-for-net","tag-reactive-framework","tag-rx"],"_links":{"self":[{"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/posts\/563","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/comments?post=563"}],"version-history":[{"count":18,"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/posts\/563\/revisions"}],"predecessor-version":[{"id":933,"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/posts\/563\/revisions\/933"}],"wp:attachment":[{"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/media?parent=563"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/categories?post=563"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.minddriven.de\/index.php\/wp-json\/wp\/v2\/tags?post=563"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}