Mastering Reactive Extensions with C# and .NET

Name: Mastering Reactive Extensions with C# and .NET
Rating: 4.2 (792 reviews)

A complete course on Rx.NET

Created byDmitri Nesteruk

Last updated 4/2017

English

What you'll learn

Create and consume observable sequences
Generate sequences using Observable factory methods
Quickly work with sequences using Subject classes
Combine multiple sequences into a single stream
Master time-related sequence processing

Course content

5 sections • 33 lectures • 3h 35m total length

Course Introduction4:14
An overview of the structure and organization of this course.

Overview1:04
An overview of the lectures in this section.
Observer Design Pattern9:45
The Observer pattern is incorporated into C# via the event keyword. But what about observable sequences?
IObserver<T>3:56
The IObserver<T> interface formalizes the expectations that the consumer of a sequence of values might have. Specifically, it anticipates the following outcomes:

The sequence generates zero or more values in OnNext()

Failures in the sequence are propagated through OnError()

When the sequence is exhausted, we get an OnComplete()
IObservable<T>4:57
We are going to discuss IObservable<T>, but we are not going to implement it just yet.
Key Interfaces
Summary1:36
A summary of all the things we've learned in this section of the course.

Overview1:13
A look at the things we'll learn in this section.
Subject<T>8:06
The Subject<T> is the simplest class one can use for feeding values to an IObserver<T>.
Unsubscribing2:21
We know how to subscribe to an observable, but how to unsubscribe?
Proxy and Broadcast9:25
Since a Subject is both an observer and observable, it can act as a sort of proxy.
ReplaySubject<T>3:35
A subject that is able to store the values that came in and then replay them for any subscriber. Can be limited with either a time window or a buffer size.
BehaviorSubject<T>2:42
Just like an ordinary subject, but has a default value that is immediately supplied to any listener.
AsyncSubject<T>3:03
A subject that only posts its last value, and only when its OnCompleted() is called.
Implementing IObservable6:42
We finally get to implement IObservable<T> and discuss some of the potential problems.
Subjects
Summary1:36
A summary of all the things we've learned in this section of the course.

Overview1:50
A look at the things we'll learn in this section.
Simple Factory Methods2:45
Simpler ways of making ReplaySubject<T>-style objects.
Observable.Create13:14
A mechanism that is better and more flexible than all those Subjects.
Sequence Generators7:24
Quick ways of generating simple observable sequences.
Converting Into Observables12:21
Ways of converting existing .NET paradigms (delegates, events, Task<T>, IEnumerables) into observable sequences.
Sequence Filtering11:17
Learn how to filter observable sequences.
Sequence Inspection11:15
Making categorical judgement about sequences (e.g., claiming that the two sequences are identical) is a bit more complicated than with LINQ.
Sequence Transformation11:53
Transforming a sequence into something else.
Sequence Aggregation12:01
Aggregation can work in two different ways with reactive sequences: either collapsing a sequence to a single value, or having a running sum/average/whatever that doesn't require completion.
Fundamental Sequence Operators
Summary5:01
A summary of all the things we've learned in this section of the course.

Overview1:18
A look at the topics we'll discuss in this section.
Exception Handling12:25
Smart ways of handling exceptions generated in reactive sequences.
Sequence Combinators16:47
Ways of combining several reactive sequences.
Time-Related Sequence Processing11:50
Ways of processing sequences with respect to time.
Reactive Extensions Event Broker15:08
A practical example of the use of Rx (and also Autofac) in building an Event Broker.
Advanced Sequence Operators
Summary3:19
A summary of the things we've learned in this section of the course.
Course Summary1:41
A summary of the things we've learned in the course. See also some links to my other courses.
Bonus Lecture: Other Courses at a Discount0:11
Congratulation on completing this course!

Now that you’ve mastered the curriculum, check out some of my other .NET/C# courses:

Design Patterns in C# and .NET
Mastering LINQ with C# and .NET
Learn Parallel Programming with C# and .NET
Dependency Injection in C# and .NET with the Autofac Library
Mastering Reactive Extensions with C# and .NET

Enjoy!

Dmitri

Requirements

Good understanding of C# and .NET
Good understanding of LINQ

Description

This course covers Reactive Extensions, a technology for working with streams of data in a reactive fashion. With Reactive Extensions, you can ingest, filter analyze and re-broadcast data streams. You can also build your own components which generate reactive streams for others to produce.

Reactive Extensions started its life as a .NET technology, but has since been ported to every other language imaginable, including even JavaScript. This course shows how Rx can be used specifically with C# and .NET.

Topics Covered

The reactive paradigm and push collections
Key Rx operators
Rx's Subject classes that help working with observable sequences
Fundamental Stream Operators
Advanced Stream Operators, including operations on multiple streams

Pre-requisites

This is an intermediate-level course, designed for serious .NET programmers wishing to expand their arsenal of .NET related skills. To take the course, you will need the following:

Good knowledge of C# and .NET framework
Good understanding of .NET application development (esp. collections/data storage)
Good knowledge of LINQ
Cursory knowledge of TPL may be benefitial

Course Materials

100% hands-on, with live demonstrations of every topic covered
Presented in Visual Studio 2017
Every lesson comes with a single-file demo
End-of-section quizzes are available

Learning Outcomes

By the end of the course, students should:

Understand the use of reactive sequences
Appreciate key observable/observer .NET interfaces and how to use them
Efficiently use Subject classes for setting up simple scenarios
Apply single-stream operators, including operators involving time
Apply advanced operators, including multi-stream operators

Who this course is for:

Experienced .NET developers
Anyone interested in the Reactive paradigm

Mastering Reactive Extensions with C# and .NET

What you'll learn

Explore related topics

Course content

Course Introduction1 lecture • 4min

Key Interfaces5 lectures • 21min

Subjects9 lectures • 39min

Fundamental Sequence Operators10 lectures • 1hr 29min

Advanced Sequence Operators8 lectures • 1hr 3min

Requirements

Description

Who this course is for: