Reactive Programming for .NET Developers电子书

Reactive Programming for .NET Developers

Reactive Programming for .NET Developers

Credits

About the Authors

About the Reviewer

www.PacktPub.com

Why subscribe?

Free access for Packt account holders

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

1. First Steps Toward Reactive Programming

Programming paradigms

Dataflow programming

Statelessness

The data-driven approach

Data streams

Observer pattern

Functional programming

Reactive programming

Reactive manifesto

The programming experience

Change propagation and cancellation

Linguistic characteristics

Programming languages and frameworks

Reactive programming approaches

Further reading

Summary

2. Reactive Programming with C#

IObserver interface

IObservable interface

Subscription life cycle

Sourcing events

Filtering events

Correlating events

Sourcing from CLR streams

Sourcing from CLR enumerables

Changeable collections

Infinite collections

Summary

3. Reactive Extension Programming

Setting up Rx.NET

Marble diagrams

Subjects

ReplaySubject

BehaviorSubject

AsyncSubject

Custom subjects

Subject from IObservable/IObserver

Transforming operators

Delay

Map

Scan

Debounce

Amb

Combining operators

Combine latest

Concat

Merge

Sample

StartWith

Zip

Filtering operators

Filter

Distinct

DistinctUntilChanged

ElementAt

Skip

Take

Mathematical operators

Min/Max/Avg/Sum/Count

Logic operators

Every/Some/Includes

SequenceEqual

References

Summary

4. Observable Sequence Programming

Sequence creation basics

Empty/Never

Return

Throw

Create

Range

Generate

Time-based sequence creation

Interval

Timer

Timeout

TimeInterval/Timestamp

Sequence manipulation and filtering

Where

Join

If

TakeUntil/TakeWhile/SkipUntil/SkipWhile

TakeLast/SkipLast

Sequence partitioning

GroupBy

Aggregate

MaxBy/MinBy

Advanced operators

IgnoreElements

Repeat

Publish/Connect

RefCount

PublishLast

Replay

Multicast

Summary

5. Debugging Reactive Extensions

Tracing sequences

Materialize

Dematerialize

TimeInterval

Do

Inspecting sequences

Contains

Any

All

SequenceEqual

Exception handling

Catch

OnErrorResumeNext

Finally

Retry

Summary

6. CLR Integration and Scheduling

Sourcing from CLR events

FromEventPattern

FromEvent

ToEvent

Threading integration

Sourcing from a Task

Task cancellation

Scheduling

Default schedulers

SubscribeOn/ObserveOn

Injecting schedulers

Custom scheduling

Future scheduling

Virtual time

Testing schedulers

Historical records

Summary

7. Advanced Techniques

Designing a custom operator

Designing the AsObservable operator

Designing the AcceptObservableClient operator

Case study - writing a reactive socket server

Disposing Create<T>

Designing a custom provider

Designing a custom scheduler

Dealing with the scheduler state

Creating Pattern<T>

Implementing event sourcing with Rx

Creating and validating an invoice

Event sourcing an invoice creation

Creating Interactive Extensions (Ix) operators

Summary

8. F# and Functional Reactive Programming

F# - first time

Introduction to F# and FRP

The immutable and deduce type

Type inference

Functions as first class values

Using the Type function for object-oriented programming

Collection – The heart of F#

F# – how to use it

Pattern Matching and pipe forward

Pipeline and composition

Discriminated Unions and the Record type

Active Patterns

Asynchronous pattern in F#

The concept of asynchronous workflow

Asynchronous code and examples

Functional Reactive Programming

What is FRP and how is it represented?

Introduction to functional reactive programming

Collections and functions in a flow

FRP and its scenarios

Event data flow

Push and pull-based domains

Examples of scenarios with AsyncSeq

Summary

9. Advanced FRP and Best Practices

Discrete and continuous components

Discrete components

The discrete event example with the discriminated union

Continuous components

Changing continuous value and event stream

Hybrid system

Time flow and dynamic change

Time flow in asynchronous data flow

Using F# and collection function for dynamic changing

Even more on FRP and F#

Railway-oriented Programming

Making an Observable in FRP

Summary