system.reactive – Page 3

How to use Observable.FromEvent instead of FromEventPattern and avoid string literal event names

July 28, 2023 by Tarik

Summary The first point to make is that you don’t actually need to use Observable.FromEvent to avoid the string literal reference. This version of FromEventPattern will work: var groupedKeyPresses = Observable.FromEventPattern<KeyPressEventHandler, KeyPressEventArgs>( h => KeyPress += h, h => KeyPress -= h) .Select(k => k.EventArgs.KeyChar) .GroupBy(k => k); If you do want to make FromEvent … Read more

SignalR vs. Reactive Extensions

May 31, 2023 by Tarik

No, they are absolutely not the same thing. Reactive Extensions is a library for creating and composing observable streams of data or events (which are actually quite similar). It basically knows nothing about client-server connections or other things. It is focused solely on Observables and is capable of wrapping any collection, stream, event, async method, … Read more

What is the conceptual difference between SynchronizationContext and TaskScheduler

May 23, 2023 by Tarik

I was just reading CLR via C# book by Jeffrey Ritcher and thanks to him I can also give some easy explanation related to that topic. (assuming that I am not fully agreed with the whole details in answers) First of all, TaskScheduler object is responsible for executing scheduled tasks. The FCL ships with two … Read more

What are the default Schedulers for each observable operator?

May 22, 2023 by Tarik

Wow, that was not trivial to find… Deep within the bowels of the System.Reactive.Concurrency namespace, there is an internal static class called SchedulerDefaults, which is declared as: internal static class SchedulerDefaults { internal static IScheduler AsyncConversions { get { return DefaultScheduler.Instance; }} internal static IScheduler ConstantTimeOperations { get { return ImmediateScheduler.Instance; }} internal static IScheduler … Read more

TPL vs Reactive Framework

May 10, 2023 by Tarik

The main purpose of Rx is not to provide an abstraction over events. This is just one of its outcomes. Its primary purpose is to provide a composable push model for collections. The reactive framework (Rx) is based on IObservable<T> being the mathematical dual of IEnumerable<T>. So rather than “pull” items from a collection using … Read more

Reactive Extension (Rx) tutorial that is up to date

April 28, 2023 by Tarik

When learning Rx the first thing is to understand the philosophy behind IObservable and how it’s push based nature compares with IEnumerable. I suggest the following one for a good explanation: A[nother] Simpler Tutorial for Reactive Extensions Lee Campbell has nice series explaining the api and when to use them. He also tries to keep … Read more

IObservable vs Plain Events or Why Should I use IObservable?

April 25, 2023 by Tarik

Observable is the cornerstone of the Rx library. They provide pretty much all the implementations and operators you’ll need. The idea behind IObservable<T> and Rx is not just the “handling” of events, but enabling “LINQ to Events.” So you can easily compose “event streams,” which gives you a lot of power compared to regular event … Read more

When to use Observable.FromEventPattern rather than Observable.FromEvent?

March 29, 2023 by Tarik

“Use FromEvent for events structurally don’t look like a .NET event pattern (i.e. not based on sender, event args), and use FromEventPattern for the pattern-based ones.” – Bart De Smet (Rx team)

ObserveOn and SubscribeOn – where the work is being done

March 3, 2023 by Tarik

There’s a lot of misleading info out there about SubscribeOn and ObserveOn. Summary SubscribeOn intercepts calls to the single method of IObservable<T>, which is Subscribe, and calls to Dispose on the IDisposable handle returned by Subscribe. ObserveOn intercepts calls to the methods of IObserver<T>, which are OnNext, OnCompleted & OnError. Both methods cause the respective … Read more

How do Reactive Framework, PLINQ, TPL and Parallel Extensions relate to each other?

February 26, 2023 by Tarik

PLINQ (Parallel Linq) is simply a new way to write regular Linq queries so that they run in parallel – in other words, the Framework will automatically take care of running your query across multiple threads so that they finish faster (i.e. using multiple CPU cores). For example, let’s say that you have a bunch … Read more