Reactive Programming with Rx.NET

Module 1: Reactive programming in .NET, succinct overview

• Why reactive programming motivation, benefits, and use cases in desktop, backend, and UI
• What Rx.NET provides overview of Reactive Extensions on .NET
• Core concepts observables, observers, subscriptions, and schedulers
• Understanding differences vs .NET events, vs IEnumerable or IAsyncEnumerable, vs Stream, vs message queues and brokers, vs functional reactive programming

Module 2: Working with observables

• Creating and subscribing to observables cold vs hot and subject types
• Managing asynchronous streams lifetime, disposal, and backpressure patterns
• Event handling with observables from events and timers to UI and IO
• Architectural placement where Rx.NET belongs by layer and when not to use it

Module 3: Schedulers in Rx.NET

• Scheduler types immediate, current thread, new thread, task pool, event loop, and synchronization contexts
• Controlling concurrency and threading with observeOn and subscribeOn
• Coordinating UI and background work WPF synchronization context examples
• Time virtualization for tests and deterministic behavior

Module 4: LINQ operators in Rx.NET

• Filter and transform select, where, distinctUntilChanged, scan, map like patterns
• Aggregate and compose buffer, window, groupBy, aggregate, reduce
• Time based operations throttle, debounce, sample, interval, timeout
• Materialize and dematerialize for advanced flow control

Module 5: Advanced techniques

• Combining sequences merge, concat, zip, combineLatest, withLatestFrom
• Coordinating workflows switch, switchMap like patterns, concatMap vs flatMap choices
• Error handling retry, retryWhen, catch, onErrorResumeNext and circuit breaker patterns
• Resource management using and finally for cleanup

Module 6: Async with Rx.NET without AsyncRx.NET

• Modeling async operations as observables Task and Task<T> to observable with FromAsync and StartAsync patterns
• Do not run async directly inside Subscribe lifting tasks safely into the stream
• Async boundaries and scheduling avoiding deadlocks and context leaks
• Measuring and tuning overhead tradeoffs compared to pure async and await

Module 7: Testing and debugging reactive code

• Testing operators with TestScheduler and virtual time
• Writing deterministic assertions on emissions and timelines
• Diagnosing pipelines logging, Do, timestamp, and materialize
• Debugging memory issues subscription leaks and Dispose hygiene

Module 8: Integration patterns

• UI with WPF and MVVM commands, property streams, and view model updates
• Backend and services mapping external events, sockets, and message handlers
• Interop with async enumerables bridging IAsyncEnumerable to IObservable and back
• Packaging and reuse extension methods, factories, and composition helpers

Module 9: Handling Rx.NET quirks

• Distribution pitfalls plugins and assembly loading considerations
• Blazor specific issues synchronization context and rendering pipeline impacts
• AsyncRx.NET incompatibility with .NET 10.0 current state and safe alternatives
• Versioning and provider packages keeping dependencies healthy

Module 10: Performance and reliability

• Throughput vs latency understanding operator costs and allocations
• Choosing operators for speed avoiding unnecessary Subject usage
• Backpressure like patterns buffering, windowing, and drop strategies
• Measuring with Stopwatch, counters, and sampling profilers

Module 11: Practical project in WPF with MVVM

• End to end design inputs, transformations, coordination, outputs
• Implementing real scenarios user events, IO, and cancellation
• Applying best practices composition over inheritance and pure functions at edges
• Performance evaluation hotspots, scheduling choices, and targeted fixes

Module 12: Wrap up and next steps

• Checklist for production readiness threading, disposal, error policy
• Testing and diagnostics toolkit templates and conventions
• Migration and coexistence with existing event code
• Personal roadmap and reference resources