system.reactive

Consider the following: [Fact] public void foo() { var result = new Subject<bool>(); var startCount = 0; var completionCount = 0; var obs = Observable .Defer(() => { ++startCount; return result.FirstAsync(); }) .Do(_ => ++completionCount) .Publish() .RefCount(); // pretend there are lots of subscribers at once var s1 = obs.Subscribe(); var s2 = obs.Subscribe(); var s3 = obs.Subscribe(); // even so, we only expect to be started once Assert.Equal(1, startCount); Assert.Equal(0, completionCount); // and we won't complete until the result ticks through result.OnNext(true); Assert.Equal(1,

In the latest video by Rx team Bart De Smet: Rx Update - .NET 4.5, Async, WinRT I saw that WinRT events exposed to .NET by some really strange metadata, more preciesly - add_ / remove_ pair methods signature: EventRegistrationToken add_MyEvent(EventHandler<MyEventArgs> handler) { … } void remove_MyEvent(EventRegistrationToken registrationToken) { … } It looks really great, allowing unsubscribing from event by "disposing" the registration token (Rx does the same kind of thing, returning IDisposable instance from Subscribe() method). So it's became possible to easily unsubscribe lamba

I have been using RxJava in my project for about a year now. With time, I grew to love it very much - now I'm thinking maybe too much... Most methods I write now have some form of Rx in it, which is great! (until it's not). I now notice that some methods require a lot of work to combine the different observable producing methods. I get the feeling that although I understand what I write now, the next programmer will have a really hard time understanding my code. Before I get to the bottom line let me give an example straight from my code in Kotlin (Don't dive too deep into it): private fun <T

I have an RX producer that creates a stream of strings like so (simplified version of the real stream): A1 A2 A3 B1 B2 C1 C2 C3 C4 C5 C6.... The stream is endless, but ordered. So after the strings that start with A run out, B starts. When B runs out, C starts... when Z run out, we move to AA1 etc. There's an unknown number of A 's, B 's etc, but it's typically 10-30 instances per letter. I'm looking for a way to divide this stream into blocks of all A's: A1 A2 A3 , all B's: B1 B2 , all C's: C1 C2 C3 C4 C5 C6 etc. Each block can be either an observable (which I'll turn into a list) or simply a

A use case which I have encountered, and I suspect I can't be the only one, is for a method like: IObservable<T> Observable.RepeatLastValueDuringSilence(this IObservable<T> inner, TimeSpan maxQuietPeriod); which would return all the future items from the inner observable, but also, if the inner observable doesn't call OnNext for a certain period of time (maxQuietPeriod), it just repeats the last value (until of course inner calls OnCompleted or OnError). A justification would be for a service to periodically ping out a periodic status update. For example: var myStatus = Observable.FromEvent( h