diff --git a/README.md b/README.md
index 9c43230781..eb39fb9d8d 100644
--- a/README.md
+++ b/README.md
@@ -10,6 +10,20 @@ This repository contains four libraries which are conceptually related in that t
Each will be described later in this README.
+## FREE Introduction to Rx.NET 2nd Edition eBook
+
+
+
+Reactive programming provides clarity when our code needs to respond to events. The Rx.NET libraries were designed to enable cloud-native applications to process live data in reliable, predictable ways.
+
+We've written a FREE book which explains the vital abstractions that underpin Rx, and shows how to exploit the powerful and extensive functionality built into the Rx.NET libraries.
+
+Based on Lee Campbell's 2010 book (kindly donated to the project), it has been re-written to bring it up to date with Rx.NET v6.0, .NET 8.0, and modern cloud native use cases such as IoT and real-time stream data processing.
+
+Introduction to Rx.NET is available [Online](https://introtorx.com/), [on GitHub](Rx.NET/Documentation/IntroToRx/), as [PDF](https://endjincdn.blob.core.windows.net/assets/ebooks/introduction-to-rx-dotnet/introduction-to-rx-dotnet-2nd-edition.pdf), and [EPUB](https://endjincdn.blob.core.windows.net/assets/ebooks/introduction-to-rx-dotnet/introduction-to-rx-dotnet-2nd-edition.epub).
+
+
+
## Getting the bits
Channel | Rx | AsyncRx | Ix | System.Linq.Async
@@ -26,7 +40,6 @@ For nightly builds, configure NuGet to use this feed: `https://pkgs.dev.azure.co
Catch us in the #rxnet channel over at http://reactiveui.net/slack
-
## A Brief Introduction to Rx
In this digital age, live data streams are ubiquitous. Financial applications depend on a swift response to timely information. Computer networks have always been able to provide extensive information about their health and operation. Utility companies such as water providers have vast numbers of devices monitoring their operations. User interface and game building frameworks report user interactions in great detail. Delivery vans continuously report their progress. Aircraft provide performance telemetry to detect potential maintenance issues before they become serious problems, and cars are now starting to do the same. Many of us wear or carry devices that track our physical activity and even [vital signs](https://www.youtube.com/watch?v=6yjl_h7-WYA&t=2443s). And the improvements in machine learning have enriched the insights that can be derived from the ever-increasing volume and variety of live data.
@@ -60,7 +73,7 @@ The two key features of Rx are:
Rx has been particularly successfully applied in user interfaces. (This is also true outside of .NET—[RxJS](https://rxjs.dev/) is a JavaScript spin-off of Rx, and it is very popular in user interface code.) The https://github.com/reactiveui/reactiveui makes deep use of Rx to support .NET UI development.
-To learn more, see this [Rx playlist](https://www.youtube.com/playlist?list=PLJt9xcgQpM60Fz20FIXBvj6ku4a7WOLGb).
+Ian Griffiths presented a concise 60 minute overview of [Reactive Extensions for .NET](https://endjin.com/what-we-think/talks/reactive-extensions-for-dotnet) at the dotnetsheff meetup in 2020. More videos are available on the [Rx playlist](https://www.youtube.com/playlist?list=PLJt9xcgQpM60Fz20FIXBvj6ku4a7WOLGb).
## AsyncRx.Net
@@ -140,6 +153,13 @@ Rx has been around for roughly a decade and a half, so we owe a great deal to it
## Roadmap
+As part of .NET Conf 2023, Ian Griffiths provided an update on the efforts to [modernize Rx.NET for v6.0 and the plans to for v7.0](https://endjin.com/what-we-think/talks/modernizing-reactive-extensions-for-dotnet).
+
+For more information, see the following discussions:
+
+- [Future Rx.NET Packaging](https://github.com/dotnet/reactive/discussions/2038)
+- [Rx.NET v6.0 & v7.0 high-level plan](https://github.com/dotnet/reactive/discussions/1868)
+
We have set out a [roadmap](Rx.NET/Documentation/Rx-Roadmap-2023.md) explaining our medium term plans for ongoing development of Rx. This diagram illustrates our view of the platforms on which Rx is used, and the planned support lifecycles for these various targets:
diff --git a/Rx.NET/Documentation/IntroToRx/00_Foreword.md b/Rx.NET/Documentation/IntroToRx/00_Foreword.md
index 3ba80fbad4..76ce1b1355 100644
--- a/Rx.NET/Documentation/IntroToRx/00_Foreword.md
+++ b/Rx.NET/Documentation/IntroToRx/00_Foreword.md
@@ -1,185 +1,54 @@
----
-title : Foreword
----
-
-#Introduction to Rx {#IntroductiontoRx .ignoreToc .kindleOnly}
-##Lee Campbell {.ignoreToc .kindleOnly text-align=center}
-
----
-
-#Preface {#Preface .SectionHeader}
-
-Reactive programming is not a new concept. I remember studying my first Event Driven
-module for Visual Basic 5 in 2000. Even then the technology (Visual Basic 5) was
-already considered somewhat dated. Long before VB5 and the turn of the millennium,
-we have seen languages supporting events. Over time languages like Smalltalk, Delphi
-and the .NET languages have popularized reactive or event-driven programming paradigms.
-This not to say that events are passé: current trends such as CEP (Complex
-Event Processing), CQRS (Command Query Responsibility Segregation) and rich immersive
-GUIs, all have events as a fundamental part of their makeup.
-
-The event driven paradigm allows for code to be invoked without the need for breaking
-encapsulation or applying expensive polling techniques. This is commonly implemented
-with the Observer pattern, events exposed directly in the language (e.g. C#) or
-other forms of callback via delegate registration. The Reactive Extensions extend
-the callback metaphor with LINQ to enable querying sequences of events and managing
-concurrency.
-
-The Reactive Extensions are effectively a library of implementations of the `IObservable`
-and `IObserver` interfaces for .NET, Silverlight and Windows Phone7.
-The libraries are also available in JavaScript. As a dynamic language, JavaScript
-had no need for the two interfaces so the JavaScript implementation could have been
-written long before .NET 4 was released. This book will introduce Rx via C#. Users
-of VB.NET, F# and other .NET languages hopefully will be able to extract the concepts
-and translate them to their particular language. JavaScript users should be able
-to gather the concepts from this book and apply them to their language. JavaScript
-users may however find some features are not supported, and some concepts, such
-as scheduling do not transcend platforms.
-
-As Rx is just a library, the team at Microsoft delivering Rx was able to isolate
-themselves from the release schedule of the .NET Framework. This proved important
-as the libraries saw fairly constant evolution since late 2009 through to their
-official release in mid 2011. This evolution has been largely enabled by the openness
-of the team and their ability to take onboard criticisms, suggestions and feature
-requests from the brave community of pre-release users.
-
-While Rx is _just a library_, it is a significant and bold move forward for
-the team at Microsoft and for any consumers of the library. Rx _will_ change
-the way you design and build software for the following reasons:
-
- * The way that it tackles the Observer pattern is a divorce from .NET events toward a Java-style interface pattern but far more refined.
- * The way it tackles concurrency is quite a shift how many .NET developers would have done it before.
- * The abundance of (extension) methods in the library.
- * The way in which it integrates with LINQ to leverage LINQ's composability & declarative style, makes Rx very usable and discoverable to those already familiar with LINQ and `IEnumerable`.
- * The way it can help any .NET developer that works with event driven and/or asynchronous programs. Developers of Rich Clients, Web Clients and Services alike can all benefit from Rx.
- * The future plans seem even grander, but that is a different book for some time in the future :-)
-
-This book aims to teach you:
-
- * about the new types that Rx will provide
- * about the extension methods and how to use them
- * how to manage subscriptions to "sequences" of data
- * how to visualize "sequences" of data and sketch your solution before coding it
- * how to deal with concurrency to your advantage and avoid common pitfalls
- * how to compose, aggregate and transform streams
- * how to test your Rx code
- * some guidance on best practices when using Rx.
-
-The best way to learn Rx is to use it. Reading the theory from this book will only
-help you be familiar with Rx, but will not really enable you to fully understand
-Rx. You can download the latest version of Rx from the Microsoft Data Developer
-site ()
-or if you use NuGet you can just download Rx via that.
-
-
-My experience with Rx is straight from the trenches. I worked on a team of exceptional
-developers on a project that was an early adopter of Rx (late 2009). The project
-was a financial services application that started off life as a Silverlight project
-then expanded into an integration project. We used Rx everywhere; client side in
-Silverlight 3/4, and server side in .NET 3.5/4.0. We used Rx eagerly and sometimes
-too eagerly. We were past leading edge, we were _bleeding_ edge. We were finding
-bugs in the early releases and posting proposed fixes to the guys at Microsoft.
-We were constantly updating to the latest version. It cost the project to be early
-adopters, but in time the payment was worth it. Rx allowed us to massively simplify
-an application that was inherently asynchronous, highly concurrent and targeted
-low latencies. Similar workflows that I had written in previous projects were pages
-of code long; now with Rx were several lines of LINQ. Trying to test asynchronous
-code on clients (WPF/Win Forms/Silverlight) was a constant challenge, but Rx solved
-that too. Today if you ask a question on the Rx Forums, you will most likely be
-answered by someone from that team (or Dave Sexton).
-
-
-
-#Acknowledgements {#Acknowledgements}
-
-I would like to take this quick pause to recognize the people that made this book
-possible. First is my poor wife for losing a husband to a dark room for several
-months. Her understanding and tolerance is much appreciated. To my old team "Alpha
-Alumni"; every developer on that team has helped me in some way to better myself
-as a developer. Specific mention goes to
-[James Miles](http://enumeratethis.com/),
-[Matt Barrett](http://weareadaptive.com/blog/),
-[John Marks](http://johnhmarks.wordpress.com/),
-Duncan Mole,
-Cathal Golden,
-[Keith Woods](http://keith-woods.com),
-[Ray Booysen](http://nondestructiveme.com) &
-[Olivier DeHeurles](http://odeheurles.com/)
-for all the deep dive sessions, emails, forum banter, BBM exchanges, lunch breaks
-and pub sessions spent trying to get our heads around Rx. To
-[Matt Davey](http://mdavey.wordpress.com)
-for being brave enough to support us in using Rx back in 2009.
-To the team at Microsoft that did the hard work and brought us Rx;
-[Jeffrey Van Gogh](http://blogs.msdn.com/b/jeffva/),
-[Wes Dyer](http://blogs.msdn.com/b/wesdyer/),
-[Erik Meijer](http://www.applied-duality.com/) &
-[Bart De Smet](http://blogs.bartdesmet.net/bart/).
-Extra special mention to Bart, there is just something about the
-[content](http://channel9.msdn.com/Tags/bart+de+smet) that Bart
-[produces](http://www.infoq.com/author/Bart-De-Smet) that clicks with me.
-Finally to the guys that helped edit the book;
-[Joe Albahari](http://www.albahari.com/)
-and Gregory Andrien. Joe is a veteran author of books such
-as the C# in a nutshell, C# pocket reference and LINQ pocket reference, and managed
-to find time to help out on this project while also releasing the latest versions
-of these books. For Gregory and I, this was a first for both of us, as editor and
-author respectively. Gregory committed many late nights to helping complete this
-project. There is also some sweet irony in having a French person as the editor.
-Even though English is not his native tongue, he clearly has a better grasp of it
-than I.
-
-
-It is my intention that from the experiences both good and bad, I can help speed
-up your understanding of Rx and lower that barrier to entry to using Rx. This will
-be a progressive step-by-step approach. It may seem slow in places, but the fundamentals
-are so important to have a firm grasp on the powerful features. I hope you will
-have the patience to join me all the way to the end.
-
-The content of this book was originally posted as a series of blog posts at
-[http://LeeCampbell.blogspot.com](http://leecampbell.blogspot.co.uk/2010/08/reactive-extensions-for-net.html)
-and has proved popular enough that I thought it warranted being reproduced as an e-book.
-In the spirit of other books such as
-Joe Albahari's [Threading in C#](http://www.albahari.com/threading/)
-and Scott Chacon's [Pro Git](http://git-scm.com/book) books, and considering
-the blog was free, I have made the first version of this book free.
-
-The version that this book has been written against is the .Net 4.0 targeted Rx
-assemblies version 1.0.10621.0 (NuGet: Rx-Main v1.0.11226).
-
-So, fire up Visual Studio and let's get started.
-
----
-
-
-
Additional recommended reading
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- - Integrated
- -
- LINQ is integrated into the C# language.
-
- - Unitive
- -
- Using LINQ allows you to leverage your existing skills for querying data at rest
- (LINQ to SQL, LINQ to XML or LINQ to objects) to query data in motion. You could
- think of Rx as LINQ to events. LINQ allows you to transition from other paradigms
- into a common paradigm. For example you can transition a standard .NET event, an
- asynchronous method call, a `Task` or perhaps a 3rd party middleware API
- into a single common Rx paradigm. By leveraging our existing language of choice
- and using familiar operators like `Select`, `Where`, `GroupBy`
- etc, developers can rationalize and communicate designs or code in a common form.
-
- - Extensible
- -
- You can extend Rx with your own custom query operators (extension methods).
-
- - Declarative
- -
- LINQ allows your code to read as a declaration of _what_ your code does and
- leaves the _how_ to the implementation of the operators.
- - Composable
- -
- LINQ features, such as extension methods, lambda syntax and query comprehension
- syntax, provide a fluent API for developers to consume. Queries can be constructed
- with numerous operators. Queries can then be composed together to further produce
- composite queries.
- - Transformative
- -
- Queries can transform their data from one type to another. A query might translate
- a single value to another value, aggregated from a sequence of values to a single
- average value or expand a single data value into a sequence of values.
-
-
-
-##When is Rx appropriate? {#WhenRx}
-
-Rx offers a natural paradigm for dealing with sequences of events.
-A sequence can contain zero or more events.
-Rx proves to be most valuable when composing sequences of events.
-
-
-###Should use Rx {#Should}
-
-Managing events like these is what Rx was built for:
-
- * UI events like mouse move, button click
- * Domain events like property changed, collection updated, "Order Filled", "Registration accepted" etc.
- * Infrastructure events like from file watcher, system and WMI events
- * Integration events like a broadcast from a message bus or a push event from WebSockets API or other low latency middleware like [Nirvana](http://www.my-channels.com)
- * Integration with a CEP engine like [StreamInsight](http://www.microsoft.com/sqlserver/en/us/solutions-technologies/business-intelligence/complex-event-processing.aspx) or [StreamBase](http://www.streambase.com).
-
-Interestingly Microsoft's CEP product StreamInsight, which is part of the SQL Server family, also uses LINQ to build queries over streaming events of data.
-
-Rx is also very well suited for introducing and managing concurrency for the purpose of _offloading_.
-That is, performing a given set of work concurrently to free up the current thread.
-A very popular use of this is maintaining a responsive UI.
-
-You should consider using Rx if you have an existing `IEnumerable` that is attempting to model data in motion.
-While `IEnumerable` _can_ model data in motion (by using lazy evaluation like `yield return`), it probably won't scale.
-Iterating over an `IEnumerable` will consume/block a thread.
-You should either favor the non-blocking nature of Rx via either `IObservable` or consider the `async` features in .NET 4.5.
-
-###Could use Rx {#Could}
-
-Rx can also be used for asynchronous calls.
-These are effectively sequences of one event.
-
- * Result of a `Task` or `Task`
- * Result of an APM method call like `FileStream` BeginRead/EndRead
-
-You may find the using TPL, Dataflow or `async` keyword (.NET 4.5) proves to be a more natural way of composing asynchronous methods.
-While Rx can definitely help with these scenarios, if there are other more appropriate frameworks at your disposal you should consider them first.
-
-Rx can be used, but is less suited for, introducing and managing concurrency for the purposes of _scaling_ or performing _parallel_ computations.
-Other dedicated frameworks like TPL (Task Parallel Library) or C++ AMP are more appropriate for performing parallel compute intensive work.
-
-See more on TPL, Dataflow, `async` and C++ AMP at [Microsoft's Concurrency homepage](http://msdn.microsoft.com/en-us/concurrency).
-
-###Won't use Rx {#Wont}
-
-Rx and specifically `IObservable` is not a replacement for `IEnumerable`.
-I would not recommend trying to take something that is naturally pull based and force it to be push based.
-
- * Translating existing `IEnumerable` values to `IObservable` just so that the code base can be "more Rx"
- * Message queues.
- Queues like in MSMQ or a JMS implementation generally have transactionality and are by definition sequential.
- I feel `IEnumerable` is a natural fit for here.
-
-By choosing the best tool for the job your code should be easier to maintain, provide better performance and you will probably get better support.
-
-##Rx in action {#RxInAction}
-
-Adopting and learning Rx can be an iterative approach where you can slowly apply it to your infrastructure and domain.
-In a short time you should be able to have the skills to produce code, or reduce existing code, to queries composed of simple operators.
-For example this simple ViewModel is all I needed to code to integrate a search that is to be executed as a user types.
-
- public class MemberSearchViewModel : INotifyPropertyChanged
- {
- //Fields removed...
- public MemberSearchViewModel(IMemberSearchModel memberSearchModel,
- ISchedulerProvider schedulerProvider)
- {
- _memberSearchModel = memberSearchModel;
-
- //Run search when SearchText property changes
- this.PropertyChanges(vm => vm.SearchText)
- .Subscribe(Search);
- }
-
- //Assume INotifyPropertyChanged implementations of properties...
- public string SearchText { get; set; }
- public bool IsSearching { get; set; }
- public string Error { get; set; }
- public ObservableCollection Results { get; }
-
- //Search on background thread and return result on dispatcher.
- private void Search(string searchText)
- {
- using (_currentSearch) { }
- IsSearching = true;
- Results.Clear();
- Error = null;
-
- _currentSearch = _memberSearchModel.SearchMembers(searchText)
- .Timeout(TimeSpan.FromSeconds(2))
- .SubscribeOn(_schedulerProvider.TaskPool)
- .ObserveOn(_schedulerProvider.Dispatcher)
- .Subscribe(
- Results.Add,
- ex =>
- {
- IsSearching = false;
- Error = ex.Message;
- },
- () => { IsSearching = false; });
- }
-
- ...
- }
-
-While this code snippet is fairly small it supports the following requirements:
-
- * Maintains a responsive UI
- * Supports timeouts
- * Knows when the search is complete
- * Allows results to come back one at a time
- * Handles errors
- * Is unit testable, even with the concurrency concerns
- * If a user changes the search, cancel current search and execute new search with new text.
-
-To produce this sample is almost a case of composing the operators that match the requirements into a single query.
-The query is small, maintainable, declarative and far less code than "rolling your own".
-There is the added benefit of reusing a well tested API.
-The less code _you_ have to write, the less code _you_ have to test, debug and maintain.
-Creating other queries like the following is simple:
-
- * calculating a moving average of a series of values e.g. *service level agreements* for average latencies or downtime
- * combining event data from multiple sources e.g.: *search results* from Bing, Google and Yahoo, or *sensor data* from Accelerometer, Gyro, Magnetometer or temperatures
- * grouping data e.g. *tweets* by topic or user, or *stock prices* by delta or liquidity*
- * filtering data e.g. *online game servers* within a region, for a specific game or with a minimum number of participants.
-
-
-Push is here.
-Arming yourself with Rx is a powerful way to meet users' expectations of a push world.
-By understanding and composing the constituent parts of Rx you will be able to make short work of complexities of processing incoming events.
-Rx is set to become a day-to-day part of your coding experience.
-
-
----
-
-
-
-
Additional recommended reading
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
Received value 1
-
Received value 2
-
Received value 3
-
Sequence terminated
-
-
Additional recommended reading
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
