DEV Community

Cover image for How To Harness System.Reactive For The Observer Pattern
Dev Leader
Dev Leader

Posted on • Originally published at

How To Harness System.Reactive For The Observer Pattern

The traditional observer pattern in C# provides a solid foundation, but there’s room for improvement in terms of simplicity and functionality. This is where System.Reactive, a set of libraries known as Reactive Extensions (Rx), comes into play. Rx introduces a new perspective to handling events and asynchronous programming, making it a valuable asset for modern C# developers.

Understanding System.Reactive

System.Reactive, or Rx, extends the observer pattern by offering a more flexible and powerful approach to event handling. It’s a library that allows developers to compose and consume asynchronous and event-based programs using observable sequences and LINQ-style query operators. In essence, Rx transforms the way we deal with sequences of events or data streams, turning them into observable sequences that can be easily manipulated and controlled.

Transition from Traditional to Reactive

If you’re familiar with the standard observer pattern, as discussed in the previous article, transitioning to Rx might initially seem daunting. However, it’s more of an extension rather than a replacement. Rx builds upon the observer pattern, enhancing it with more capabilities and simplifying complex scenarios. This transition not only streamlines your code but also opens up new possibilities in handling events and data flows.

Why System.Reactive?

Before diving deeper into System.Reactive, it’s important to understand its advantages:

  1. Simplifies Complex Scenarios: Rx makes handling complex event-driven scenarios more straightforward, especially when dealing with multiple sources of events or asynchronous data streams.

  2. More Control and Flexibility: It provides greater control over how events are processed, filtered, and transformed, thanks to its rich set of operators.

  3. Improved Readability and Maintenance: Reactive code can be more readable and easier to maintain, especially when dealing with complex event handling and asynchronous operations.

In the upcoming sections, we’ll explore how to implement System.Reactive in C#, compare it with traditional observer pattern implementations, and delve into practical examples to demonstrate its effectiveness in simplifying event management. Stay tuned as we embark on this journey to harness the power of Reactive Extensions in C#.

Implementing System.Reactive in C#

Getting Started with Rx

To begin using System.Reactive in your C# projects, you first need to include the necessary NuGet packages. The primary package is System.Reactive, which provides the core functionality. Once installed, you can start exploring the rich capabilities of Reactive Extensions.

Basic Structure of Rx

System.Reactive revolves around two key components: IObservable<T> and IObserver<T>. These are the reactive counterparts to the traditional observer pattern’s Subject and Observer. In Rx, IObservable<T> represents the source of data or events, while IObserver<T> represents the subscriber that reacts to the data or events.

Creating Observables

Creating an observable sequence in Rx is straightforward. You can convert existing data collections, event handlers, or even custom logic into observables. For example, creating an observable from a list of integers is as simple as:

var numbers = new List<int> { 1, 2, 3, 4, 5 };
var observableNumbers = numbers.ToObservable();
Enter fullscreen mode Exit fullscreen mode

Subscribing to Observables

Once you have an observable sequence, you can subscribe to it using an observer. This observer reacts to each item in the sequence, handling events like OnNext, OnError, and OnCompleted. Here’s a basic example of subscribing to the observableNumbers:

    number => Console.WriteLine($"Received {number}"),
    ex => Console.WriteLine($"Error: {ex.Message}"),
    () => Console.WriteLine("Completed"));
Enter fullscreen mode Exit fullscreen mode

Check out this video for how to use System.Reactive to implement the observer pattern in C#.

Comparing with the Traditional Observer Pattern

Similarities and Differences

While both the traditional observer pattern and System.Reactive are based on the concept of observers and observables, there are notable differences:

  1. Ease of Use: Rx simplifies complex scenarios, such as handling multiple event sources or asynchronous streams, which can be cumbersome with the traditional observer pattern.

  2. Rich Operator Set: Rx comes with a plethora of operators for filtering, transforming, and combining data streams, offering more control and flexibility compared to the traditional approach.

Practical Comparison

To illustrate the difference, let’s revisit the notification management use case from the previous article. In the traditional observer pattern, managing multiple notifications and their dependencies can quickly become complex. With Rx, however, you can easily filter, merge, or transform these notifications using Rx’s operators, resulting in cleaner and more manageable code.

In the next sections, we’ll dive into practical examples to showcase how System.Reactive can be used in different scenarios to manage events more efficiently and effectively. We’ll see how Rx can transform the way we approach event-driven programming in C#.

Advanced Scenarios with System.Reactive

Handling Multiple Event Streams

One of the strengths of System.Reactive is its ability to handle multiple event sources seamlessly. Suppose you have a scenario where you need to listen to several event streams and react only when specific conditions are met. Rx makes it easy to merge these streams and apply filters or transformations.

For example, imagine you’re building an application that needs to respond to both user inputs and system notifications. With Rx, you can merge these two streams and apply a filter to react only to specific types of events.

Time-Based Operations

System.Reactive excels in scenarios where time plays a crucial role. Operations like debouncing, throttling, and windowing are built-in, allowing you to handle events in a time-sensitive manner. For instance, if you want to process user keystrokes but only want to react if there’s a pause in typing (debouncing), Rx provides a straightforward way to implement this.

Error Handling and Recovery

Another advantage of using Rx is its robust error handling capabilities. You can handle errors at any point in the event stream and even recover from certain errors to continue processing other events. This level of control is not as easily achieved with the traditional observer pattern.

Practical Examples

Real-Time Notifications with Filtering

Let’s consider the notification management use case again. Using Rx, you can create an observable that listens to user activities and filters notifications based on user preferences. This not only simplifies the implementation but also makes the code more readable and maintainable.

Here’s an example of how you could set this up:

var userActivityObservable = GetUserActivityStream();
var filteredNotifications = userActivityObservable
    .Where(activity => activity.MeetsNotificationCriteria())
    .Select(activity => CreateNotification(activity));
    notification => DisplayNotification(notification),
    ex => HandleError(ex),
    () => Console.WriteLine("Notification stream completed") );
Enter fullscreen mode Exit fullscreen mode

GUI Development with Data Binding

In the context of GUI development, Rx can simplify the process of updating the view when the model changes. Instead of manually updating the view or relying on complex event handlers, you can use Rx to create an observable of model changes and bind it directly to the view. This results in a more reactive and responsive UI.

For example:

var modelChanges = model.ToObservable();
modelChanges.Subscribe(change => UpdateView(change));
Enter fullscreen mode Exit fullscreen mode

System.Reactive For The Win!

System.Reactive introduces a new paradigm in handling event-driven scenarios in C#. By leveraging its powerful features, developers can write more concise, maintainable, and robust event-handling code. Whether it’s managing multiple event sources, dealing with time-sensitive operations, or ensuring robust error handling, Rx provides the tools to make these tasks simpler and more intuitive.

Want More Dev Leader Content?

  • Follow along on this platform if you haven’t already!

  • Subscribe to my free weekly software engineering and dotnet-focused newsletter. I include exclusive articles and early access to videos:


  • Check out the courses I’m offering:


  • Watch hundreds of full-length videos on my YouTube channel:


  • Visit my website for hundreds of articles on various software engineering topics (including code snippets):


  • Check out the repository with many code examples from my articles and videos on GitHub:


Top comments (0)