Dealing with asynchronous code in .NET has always been problematic, as it is very different from synchronous, linear code. In this course, Taming Asynchronous .NET Code with Rx, you will learn how to model applications as streams of data with Rx. First, you will learn how to create sequences of observable data. Next, you'll learn how to consume these sequences in different ways. Finally, you'll learn how to easily synchronize multiple threads and data streams. When you finish this course, you will have working knowledge of reactive programming with .NET that will help you write asynchronous and event-driven code that is simpler and easier to maintain.
Creating Sequences of Observables Hello, this is Edin Kapic from Pluralsight. In this module, I will show you how to create sequences of observable objects from scratch or from existing data structures. Creating the data flow structure of our application starts by identifying and creating the appropriate observable sequences, and that's what you'll be doing very soon. As you should remember from the previous module, the basics of our sequences are the two simple interfaces in the System. Reactive namespace, IObservable and IObserver. However, you won't be using them directly in your work with Reactive Extensions. You'll be using higher-level constructs such as factories and subjects, it'll be much easier, and your code will start looking more declarative, almost looking like functional programming. In general, there are three ways to create an observable in Rx. The first one is to return a simple one-time result. The second one is to wrap an existing result in an observable. And the third one is to write a generation function. As you can imagine, the difficulty increases from left to right. I will show them in more detail in the following section.
Filtering and Controlling the Sequences Hello, this is Edin Kapic from Pluralsight. In this module, I will show how you can control and tame the sequences with built-in Linq operators. The power and ease of use of Linq operators is one of the main strengths of using Reactive Extensions in the first place. So far, you have learned how to generate observable sequences from a variety of sources. Also you have seen how to consume those observables. In this module, I'm going to focus on the missing piece of Rx Framework, the rich Linq operators for filtering and controlling of the sequence. There are roughly four categories of Linq operators in Rx. The ones that you are going to be using most frequently are the filtering operators. They constrain the sequence output to only those values that fit certain criteria. The second group of operators are the ones that are used to combine two or more sequences. With Rx, it's very easy to derive a combined sequence of values using only a few lines of code. The third group of operators are the ones that calculate aggregated values. They are a way of flattening the sequence into a single value, leaving the push model, and getting a scalar value as a result. The last group of operators are utility operators. They are used for side effects and overall configuration of the sequences. With these four groups of operators, I'll show you how they behave, and when it's appropriate to use them in your applications.
Simplifying Asynchrony and Multithreading Hello, this is Edin Kapic from Pluralsight. In this module, I'm going to dig deeper in the concurrency, asynchrony, and multithreading in Reactive Extensions, and how these concepts are elegantly obstructed away for you, the developer. In more detail, I'm going to remind you how asynchronous operations are well suited for Reactive Extensions. Then I'm going to explain concurrency and multithreading that happens under the cover with many of the Rx operations. Finally I will introduce the concept of schedulers in Rx, and how they are used to achieve concurrency.