All 11 Design Patterns in C# questions
More in Design Patterns in C#
How does the Factory Method pattern work in C#, and what problem does it solve? How would you implement the Strategy pattern in C# using either interfaces or delegates? How does the Repository pattern abstract data access, and what interface typically defines its contract? How would you implement the Decorator pattern in C# to add behavior to an object without modifying its original class? How would you implement the Unit of Work pattern alongside the Repository pattern to coordinate multiple repository changes within a single transaction? How would you implement the CQRS (Command Query Responsibility Segregation) pattern's basic structure in a C# application using MediatR-style handlers? How would you implement the Builder pattern using method chaining (a fluent API) to construct a complex object step by step? How would you implement the Chain of Responsibility pattern in C# to process a request through a series of independent handlers? What are design patterns, and how are the Singleton, Adapter, and Strategy patterns typically implemented in C#?
Advertisement
Back to results for “Design Patterns in C#”
C# › Design Patterns in C#

How would you implement the Observer pattern in C# using events, versus using the IObservable<T>/IObserver<T> interfaces from System?

Advanced

Answer

A simple event-based Observer uses standard C# events (publisher raises an event, subscribers attach handlers) — straightforward but tightly coupled to the delegate/event model. IObservable<T>/IObserver<T> (the Reactive Extensions foundation) formalizes the pattern with an explicit Subscribe()/OnNext()/OnCompleted()/OnError() contract, better suited for composable, LINQ-style event stream processing.
// Event-based
public class StockTicker { public event Action<decimal>? PriceChanged; }

// IObservable-based (more composable, works with Rx operators)
public class StockTickerObservable : IObservable<decimal> {
  public IDisposable Subscribe(IObserver<decimal> observer) { /* ... */ return Disposable.Empty; }
}
Real-world example Choosing plain events for a simple UI click handler versus IObservable<T> for a composable, filterable stream of live stock price updates.

Common follow-ups: What extra composability (like filtering or throttling) does Reactive Extensions (Rx.NET) add on top of raw IObservable<T>?

Delegates Events & Lambdas
All 11 Design Patterns in C# questions