RxFree 1.1.2

An ultra-lightweight Rx source-only (C#) nuget to avoid depending on the full System.Reactive for IObservable<T> producers.

100% dependency-free (source-based) support for library authors exposing IObservable<T> leveraging Subject<T>, CompositeDisposable, IObservable<T>.Subscribe extension method overloads, IObservable<T>.Select/Where/OfType LINQ operators, and others.

Usage

All of the documentation and samples for Subject<T> and the provided extension methods (i.e. Subscribe overloads) that are officially available for System.Reactive apply to this project as well, since the implementations are heavily based on it (taking them to the bare essentials for source-only inclusion, with Subject<T> being pretty much exactly the same). For example: Using Subjects.

using System;
using System.Reactive.Subjects;

var subject = new Subject<string>();

subject.Subscribe(x => Console.WriteLine($"Got raw value {x}"));

subject.Where(x => int.TryParse(x, out _))
    .Select(x => int.Parse(x))
    .Subscribe(x => Console.WriteLine($"Got number {x} (squared is {x * x})"));

subject.Where(x => bool.TryParse(x, out var value) && value)
    .Subscribe(x => Console.WriteLine($"Got a boolean True"));

while (Console.ReadLine() is var line && !string.IsNullOrEmpty(line))
    subject.OnNext(line);

This package is a drop-in replacement for System.Reactive if you are only using the most common subset of features in it that are also provided in this project.

Why

For the most part, a producer needs the Subject<T> (read more about using subjects) and maybe the ObservableExtensions that provide Subscribe overloads to provide lambdas instead of an IObserver<T>. Taking the somewhat large and heavy dependency on the full System.Reactive to consume just the basics a reusable library needs is overkill in most cases.

In addition to Subject<T>, typical activities of a producer are to handle disposables and potentially filter/query/convert other observables they consume themselves. So the following simple features are provided:

• Disposable.Empty and Disposable.Create(Action)
• CompositeDisposable: allows disposing subscriptions as a group
• Subject<T>: for producing observable sequences
• Extension methods for IObservable<T>:
  • Subscribe overloads receiving delegates for onNext, onError and onCompleted
  • Select/Where/OfType LINQ operators

This is what this project provides at the moment, in source form, in your project, as internal classes for your own implementation usage, with no external dependencies. They are not even visible in the project since NuGet provides them automatically to the compiler, embedded into your own assembly, and which you can fully debug as any other code in your project.

Sponsors

Learn more about GitHub Sponsors