RxFree

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 invole handling disposables and potentially filtering/querying/converting other observables they consume themselves in turn. For that purpose, the following simple features are included too:

• Subject<T>: for producing observable sequences
• Disposable.Empty and Disposable.Create(Action)
• CompositeDisposable: allows disposing subscriptions as a group
• 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 the package provides them automatically to the compiler, compiled into your own assembly, and which you can fully debug as any other code in your project.

All types are included as partial classes, so you can easily add your own code to them, and make them public if you need to.

Dogfooding

We also produce CI packages from branches and pull requests so you can dogfood builds as quickly as they are produced.

The CI feed is https://pkg.kzu.io/index.json.

The versioning scheme for packages is:

• PR builds: 42.42.42-pr[NUMBER]
• Branch builds: 42.42.42-[BRANCH].[COMMITS]

Sponsors

 

Learn more about GitHub Sponsors