{"@context":"https://schema.org","@type":"FAQPage","mainEntity":[{"@type":"Question","name":"What is the IObservable interface in Reactive Extensions (Rx.NET)?","acceptedAnswer":{"@type":"Answer","text":"IObservable is the fundamental interface in Rx.NET that represents a push-based data source. It exposes a Subscribe method allowing observers to subscribe to receive asynchronous notifications. It's the reactive counterpart to IEnumerable: while IEnumerable pulls data synchronously, IObservable pushes data asynchronously to subscribers."}},{"@type":"Question","name":"What are the three methods of the IObserver interface in Rx.NET?","acceptedAnswer":{"@type":"Answer","text":"IObserver defines three methods: OnNext(T value) to receive each element of the sequence, OnError(Exception error) to handle errors and signal the end of the sequence in case of failure, and OnCompleted() to indicate that the sequence completed successfully. These three methods form the observer contract which guarantees that after OnError or OnCompleted, no further OnNext will be called."}},{"@type":"Question","name":"What is the main difference between IEnumerable and IObservable?","acceptedAnswer":{"@type":"Answer","text":"IEnumerable is a pull model where the consumer requests data synchronously with GetEnumerator() and MoveNext(). IObservable is a push model where the source pushes data asynchronously to subscribers via Subscribe(). IEnumerable blocks the calling thread during iteration, while IObservable enables non-blocking operations and composition of asynchronous events with LINQ operators."}},{"@type":"Question","name":"What is the role of the Select operator in Rx.NET?","acceptedAnswer":{"@type":"Answer","text":"Select is a transformation operator that projects each element of an observable sequence into a new form by applying a function. It's the reactive equivalent of LINQ Select for IEnumerable. For example, observable.Select(x => x * 2) multiplies each value by 2. Select preserves the order and timing of emissions while transforming values, and it propagates errors and completion from the source."}},{"@type":"Question","name":"How does the Where operator work in Rx.NET?","acceptedAnswer":{"@type":"Answer","text":"Where is a filtering operator that only forwards elements of an observable sequence that satisfy a specified predicate. It applies a boolean function to each element and emits only those for which it returns true. The operator maintains element order, preserves relative emission timing, and automatically propagates OnError and OnCompleted from the source to downstream subscribers."}},{"@type":"Question","name":"What is a Subject in Rx.NET and when to use it?","acceptedAnswer":{"@type":"Answer","text":"Subject is a class that implements both IObservable and IObserver, acting as a bridge between the two. It allows manually pushing values with OnNext() while serving as an observable source to which observers can subscribe. Use Subject when converting imperative code to observable sequences, or to manually multicast events to multiple subscribers. Beware of memory leaks if subscriptions are not disposed."}},{"@type":"Question","name":"What is the difference between BehaviorSubject and Subject?","acceptedAnswer":{"@type":"Answer","text":"BehaviorSubject stores the last emitted value and immediately re-emits it to new subscribers, ensuring they always receive an initial value. It requires an initial value at construction time. Subject has no memory: new subscribers only receive values emitted after their subscription. Use BehaviorSubject to represent current state like user connection status, and Subject for simple event streams."}},{"@type":"Question","name":"What is the purpose of the SelectMany operator in Rx.NET?","acceptedAnswer":{"@type":"Answer","text":"SelectMany (also called FlatMap) projects each element of an observable sequence into a new observable sequence, then flattens all resulting sequences into a single sequence. It's essential for handling nested asynchronous operations: for example, for each user, make an async API call and merge all results. SelectMany also enables composing dependent operations and automatically handles concurrency of inner observables."}},{"@type":"Question","name":"What is the role of the Merge operator in Rx.NET?","acceptedAnswer":{"@type":"Answer","text":"Merge combines multiple observable sequences into a single sequence by interleaving their emissions in temporal arrival order. Elements from all sources are forwarded as soon as they arrive, without waiting for other sources. The resulting sequence completes when all sources have completed. If a source emits OnError, the error is propagated immediately and all other sources are unsubscribed. Merge is useful for combining independent event streams like multiple WebSockets."}},{"@type":"Question","name":"How does the Buffer operator work in Rx.NET?","acceptedAnswer":{"@type":"Answer","text":"Buffer accumulates elements of an observable sequence into lists and emits each complete list according to a specified criterion: fixed size, time interval, or signal from another observable. For example, Buffer(10) groups into batches of 10 elements, or Buffer(TimeSpan.FromSeconds(5)) groups elements arrived during 5 seconds. It's useful for batch processing, reducing notification frequency, or aggregating data before processing."}},{"@type":"Question","name":"What is the difference between a Hot observable and a Cold observable?","acceptedAnswer":{"@type":"Answer","text":"A Cold observable starts emitting only when an observer subscribes and each subscriber receives its own complete sequence from the beginning. Example: Observable.Range(1, 10). A Hot observable emits independently of subscriptions and all subscribers share the same ongoing sequence. New subscribers only see future events. Example: Subject, UI events, or real-time streams. Use Publish() or Share() to convert Cold to Hot."}},{"@type":"Question","name":"What is an IScheduler in Rx.NET and what is it used for?","acceptedAnswer":{"@type":"Answer","text":"IScheduler is an abstraction that controls where and when Rx actions are executed. It determines the execution context (thread) and timing of asynchronous operations. IScheduler exposes Schedule methods to schedule actions immediately, with delay, or at a precise time. It enables controlling concurrency, avoiding deadlocks, and testing temporal code deterministically with TestScheduler. Common schedulers include CurrentThreadScheduler, ThreadPoolScheduler, and EventLoopScheduler."}},{"@type":"Question","name":"When to use ThreadPoolScheduler in Rx.NET?","acceptedAnswer":{"@type":"Answer","text":"ThreadPoolScheduler executes Rx actions on .NET ThreadPool threads, suitable for short, parallelizable CPU-bound operations. Use to delegate work off the UI or main thread to avoid blocking. Example: Observable.Range(1, 100, Scheduler.ThreadPool) generates values on a thread pool. Beware of race conditions and synchronization when multiple observables share mutable state. Don't use for long I/O-bound operations that can saturate the pool."}},{"@type":"Question","name":"How does the Delay operator work in Rx.NET?","acceptedAnswer":{"@type":"Answer","text":"Delay temporally shifts all notifications of an observable sequence by a specified duration. It uses a scheduler to schedule delayed emissions on an appropriate thread. For example, observable.Delay(TimeSpan.FromSeconds(2)) emits each value 2 seconds after its original emission, preserving relative spacing between elements. Delay also preserves emission order and propagates OnCompleted and OnError with the same delay. Useful for implementing timeouts, debouncing, or simulating network latency."}},{"@type":"Question","name":"What is ReplaySubject and when to use it?","acceptedAnswer":{"@type":"Answer","text":"ReplaySubject is a Subject that memorizes N last values (or all values, or those emitted in a time window) and immediately replays them to new subscribers. Example: ReplaySubject(3) replays the last 3 values. Useful for caching scenarios, event logs, or state synchronization for late subscribers. Beware of memory consumption if too many values are stored. Different from BehaviorSubject which only stores the last value."}},{"@type":"Question","name":"What is the purpose of the Throttle (or Sample) operator in Rx.NET?","acceptedAnswer":{"@type":"Answer","text":"Throttle emits only the last element of an observable sequence after a specified inactivity period, ignoring all intermediate elements emitted too quickly. It's useful for handling high-frequency events like user input in a search bar: wait 300ms of inactivity before launching an API request. Sample is similar but periodically emits the last element according to a fixed interval. These operators drastically reduce load by filtering redundant emissions."}},{"@type":"Question","name":"How to handle errors in an observable sequence with Rx.NET?","acceptedAnswer":{"@type":"Answer","text":"Rx.NET offers several operators to handle errors: Catch to intercept an exception and switch to a fallback observable, Retry to automatically retry N times on error, OnErrorResumeNext to continue with another observable after error. Errors can be handled in Subscribe with the onError callback. Once OnError is called, the sequence terminates and no further OnNext will be emitted. Always handle errors to avoid unhandled exceptions that crash the application."}},{"@type":"Question","name":"What is the CombineLatest operator and when to use it?","acceptedAnswer":{"@type":"Answer","text":"CombineLatest combines latest values from multiple observable sequences by applying a selector function and emits a new result each time at least one of the sources changes. It waits for all sources to emit at least one value before the first emission. Useful for combining multiple reactive states: for example, enable Submit button only if both name AND email are valid. Different from Zip which emits by corresponding index pairs, CombineLatest re-emits on each source change."}},{"@type":"Question","name":"How does the Zip operator work in Rx.NET?","acceptedAnswer":{"@type":"Answer","text":"Zip combines elements from multiple observable sequences into tuples by corresponding index: the 1st element from each source forms the 1st tuple, the 2nd element from each source forms the 2nd tuple, etc. A tuple is emitted only when all sources have emitted at the corresponding index. The resulting sequence completes when the shortest source completes. Useful for synchronizing different temporal streams or combining results by ordered pairs. Different from CombineLatest which re-emits on each change."}},{"@type":"Question","name":"What is the DistinctUntilChanged operator and what is it used for?","acceptedAnswer":{"@type":"Answer","text":"DistinctUntilChanged filters consecutive duplicate elements by forwarding an element only if it differs from the previous one. For example, the sequence 1, 1, 2, 2, 2, 3, 1 becomes 1, 2, 3, 1. Useful to avoid redundant processing in reactive UIs: if a state changes from A to A, don't re-render. By default, uses default equality but accepts a custom comparer. DistinctUntilChanged only compares consecutive elements, different from Distinct which eliminates all duplicates across the entire sequence."}},{"@type":"Question","name":"How to use the Publish operator to convert a Cold observable to Hot?","acceptedAnswer":{"@type":"Answer","text":"Publish transforms a Cold observable into a Hot ConnectableObservable that shares a single source subscription among all subscribers. Calling Publish() returns a ConnectableObservable that only starts emitting when Connect() is called. All subscribers before and after Connect() share the same sequence. Use RefCount() after Publish() to automatically connect/disconnect based on active subscriber count. PublishLast, PublishReplay also exist for different caching behaviors. Essential to avoid multiple side effects like multiple HTTP calls."}},{"@type":"Question","name":"What is backpressure in reactive programming and how to handle it in Rx.NET?","acceptedAnswer":{"@type":"Answer","text":"Backpressure occurs when a producer emits events faster than the consumer can process them, causing memory overload or data loss. Rx.NET doesn't have native backpressure support like RxJava, but offers strategies: Throttle/Sample to ignore elements, Buffer to accumulate in batches, Window to process by time windows, or ObserveOn with scheduler to delegate to a dedicated thread. For strict control, use an async channel with System.Threading.Channels or IAsyncEnumerable."}},{"@type":"Question","name":"What is the difference between ObserveOn and SubscribeOn in Rx.NET?","acceptedAnswer":{"@type":"Answer","text":"SubscribeOn specifies the scheduler on which the initial subscription and element generation occur (affects entire upstream chain). ObserveOn specifies the scheduler on which OnNext, OnError, OnCompleted notifications are received by the observer (affects only downstream). For example: observable.SubscribeOn(ThreadPool).ObserveOn(UIScheduler) generates data on a thread pool but notifies UI on the UI thread. SubscribeOn can be placed anywhere, ObserveOn affects from its location."}},{"@type":"Question","name":"Why is it important to dispose Rx.NET subscriptions and how to do it?","acceptedAnswer":{"@type":"Answer","text":"Not disposing Rx subscriptions causes memory leaks because the observable keeps a reference to the observer, preventing garbage collection. Subscribe() returns an IDisposable that must be called to cancel the subscription. Use using to dispose automatically, store in CompositeDisposable to group multiple subscriptions, or use TakeUntil to automatically terminate on an event. In UIs, dispose in OnDestroy/Dispose. Observables that naturally complete dispose automatically but not infinite ones like Interval."}}]}