Mastering Reactive Extensions with C# and .NET
4.8 (29 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
309 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Mastering Reactive Extensions with C# and .NET to your Wishlist.

Add to Wishlist

Mastering Reactive Extensions with C# and .NET

A complete course on Rx.NET
Bestselling
4.8 (29 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
309 students enrolled
Created by Dmitri Nesteruk
Last updated 4/2017
English
Curiosity Sale
Current price: $10 Original price: $50 Discount: 80% off
30-Day Money-Back Guarantee
Includes:
  • 3.5 hours on-demand video
  • 1 Article
  • 21 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I 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
View Curriculum
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 is the target audience?
  • Experienced .NET developers
  • Anyone interested in the Reactive paradigm
Students Who Viewed This Course Also Viewed
Curriculum For This Course
33 Lectures
03:35:56
+
Course Introduction
1 Lecture 04:14

An overview of the structure and organization of this course.

Preview 04:14
+
Key Interfaces
5 Lectures 21:18

An overview of the lectures in this section.

Overview
01:04

The Observer pattern is incorporated into C# via the event keyword. But what about observable sequences?

Preview 09:45

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()

IObserver<T>
03:56

We are going to discuss IObservable<T>, but we are not going to implement it just yet.

IObservable<T>
04:57

Test your understanding of key Rx interfaces.

Key Interfaces
3 questions

A summary of all the things we've learned in this section of the course.

Summary
01:36
+
Subjects
9 Lectures 38:43

A look at the things we'll learn in this section.

Overview
01:13

The Subject<T> is the simplest class one can use for feeding values to an IObserver<T>.

Subject<T>
08:06

We know how to subscribe to an observable, but how to unsubscribe?

Unsubscribing
02:21

Since a Subject is both an observer and observable, it can act as a sort of proxy.

Proxy and Broadcast
09:25

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.

ReplaySubject<T>
03:35

Just like an ordinary subject, but has a default value that is immediately supplied to any listener.

BehaviorSubject<T>
02:42

A subject that only posts its last value, and only when its OnCompleted() is called.

AsyncSubject<T>
03:03

We finally get to implement IObservable<T> and discuss some of the potential problems.

Implementing IObservable
06:42

Some questions about different Subject classes and what they are used for?

Subjects
3 questions

A summary of all the things we've learned in this section of the course.

Summary
01:36
+
Fundamental Sequence Operators
10 Lectures 01:29:01

A look at the things we'll learn in this section.

Overview
01:50

Simpler ways of making ReplaySubject<T>-style objects.

Simple Factory Methods
02:45

A mechanism that is better and more flexible than all those Subjects.

Observable.Create
13:14

Quick ways of generating simple observable sequences.

Preview 07:24

Ways of converting existing .NET paradigms (delegates, events, Task<T>, IEnumerables) into observable sequences.

Converting Into Observables
12:21

Learn how to filter observable sequences.

Sequence Filtering
11:17

Making categorical judgement about sequences (e.g., claiming that the two sequences are identical) is a bit more complicated than with LINQ.

Sequence Inspection
11:15

Transforming a sequence into something else.

Sequence Transformation
11:53

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.

Sequence Aggregation
12:01

Some questions about the correct use of key sequence processing operators.

Fundamental Sequence Operators
6 questions

A summary of all the things we've learned in this section of the course.

Summary
05:01
+
Advanced Sequence Operators
8 Lectures 01:02:42

A look at the topics we'll discuss in this section.

Overview
01:18

Smart ways of handling exceptions generated in reactive sequences.

Exception Handling
12:25

Ways of combining several reactive sequences.

Sequence Combinators
16:47

Ways of processing sequences with respect to time.

Time-Related Sequence Processing
11:50

A practical example of the use of Rx (and also Autofac) in building an Event Broker.

Preview 15:08

Test your comprehension with these questions.

Advanced Sequence Operators
3 questions

A summary of the things we've learned in this section of the course.

Summary
03:19

A summary of the things we've learned in the course. See also some links to my other courses.

Course Summary
01:41

Congratulation on completing this course!

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

Enjoy!

Dmitri

Bonus Lecture: Other Courses at a Discount
00:14
About the Instructor
Dmitri Nesteruk
4.5 Average rating
1,033 Reviews
10,418 Students
14 Courses
Quant Finance • Algotrading • Software/Hardware Engineering

Dmitri Nesteruk is a developer, speaker and podcaster. His interests lie in software development and integration practices in the areas of computation, quantitative finance and algorithmic trading. His technological interests include C#, F# and C++ programming as well high-performance computing using technologies such as CUDA. He has been a C# MVP since 2009.

Dmitri is a graduate of University of Southampton (B.Sc. Computer Science) where he currently holds a position as a Visiting Researcher. He is also an instructor on an online intro-level Quantitative Finance course, and has also made online video courses on CUDA, MATLAB, D, the Boost libraries and other topics.