Observer Pattern in C# – Real-Time Example (Event Notification System)

What is Observer Pattern?

The Observer Pattern is a behavioral design pattern where one object (Subject) notifies multiple dependent objects (Observers) automatically when its state changes.

It follows a:


One → Many

relationship.

Why Use Observer Pattern?

  • Enable event-driven communication
  • Reduce tight coupling
  • Automatically notify subscribers
  • Improve scalability and flexibility

Real-Time Scenario

Order Placed:

  • Send Email
  • Send SMS
  • Push Notification
  • Update Dashboard

👉 One event triggers multiple actions.

Real-Time Example – Order Notification System

Step 1: Observer Interface


public interface IObserver
{
    void Update(string message);
}

Step 2: Concrete Observers

Email Service


public class EmailService : IObserver
{
    public void Update(string message)
    {
        Console.WriteLine($"Email: {message}");
    }
}

SMS Service


public class SmsService : IObserver
{
    public void Update(string message)
    {
        Console.WriteLine($"SMS: {message}");
    }
}

Push Notification Service


public class PushNotificationService : IObserver
{
    public void Update(string message)
    {
        Console.WriteLine($"Push: {message}");
    }
}

Step 3: Subject (Publisher)


public class Order
{
    private readonly List<IObserver> _observers = new();

    public void Subscribe(IObserver observer)
    {
        _observers.Add(observer);
    }

    public void Unsubscribe(IObserver observer)
    {
        _observers.Remove(observer);
    }

    public void Notify(string message)
    {
        foreach (var observer in _observers)
        {
            observer.Update(message);
        }
    }
}

Usage Example


var order = new Order();

order.Subscribe(new EmailService());
order.Subscribe(new SmsService());
order.Subscribe(new PushNotificationService());

order.Notify("Order Placed Successfully");

Output


Email: Order Placed Successfully
SMS: Order Placed Successfully
Push: Order Placed Successfully

Key Concept

Instead of:


email.Send();
sms.Send();
push.Send();

We do:


order.Notify();

👉 Subject automatically notifies all observers.

Diagram Understanding


Order (Subject)
   ↓
-------------------------
|        |             |
Email    SMS       PushNotification

👉 One event triggers many listeners.

Advantages

  • ✔ Loose coupling
  • ✔ Easy to add/remove subscribers
  • ✔ Event-driven architecture support
  • ✔ Flexible notification system
  • ✔ Scalable communication model

Disadvantages

  • ✖ Harder debugging
  • ✖ Too many notifications possible
  • ✖ Performance issues with many observers
  • ✖ Event chains can become complex

When to Use

Use Observer Pattern when:

  • Multiple objects depend on one object
  • Event-driven systems are needed
  • Notifications are required
  • Loose coupling is important

Real Project Mapping (.NET + Angular)

Feature Usage
Order notifications Observer
SignalR updates Observer
Event bus systems Observer
Email/SMS triggers Observer
Real-time dashboards Observer

ASP.NET Core Real Example

Event Handlers


OrderPlacedEvent
 ├── EmailHandler
 ├── SmsHandler
 └── InventoryHandler

👉 Event published → multiple handlers triggered.

Advanced Example – Microservices


Order Service
    ↓ Event
Kafka / RabbitMQ
    ↓
-------------------------
Email Service
Payment Service
Inventory Service

👉 Observer Pattern in distributed systems.

Observer vs Mediator

Observer Mediator
One-to-many notifications Centralized communication
Event-driven Controlled interaction
Observers don't know each other Mediator coordinates all

Pro Tip

Observer Pattern works well with:

  • SignalR
  • RabbitMQ
  • Kafka
  • Domain Events
  • Event-driven architecture

Summary

Observer Pattern helps you:

  • Build event-driven systems
  • Notify multiple subscribers automatically
  • Reduce direct dependencies

👉 Perfect for:

  • Notifications
  • Real-time systems
  • Event handling
  • Messaging systems

Comments

Post a Comment

Popular posts from this blog

Promises in Angular

🚀 Promises in Angular – The Complete Beginner’s Guide (with Examples) 📘 Introduction In modern Angular development, handling asynchronous operations is essential. Whether you're fetching data from an API, loading files, or wrapping browser-native APIs, Promises offer a clean and readable way to deal with one-time asynchronous operations. This guide explains: What Promises are How they compare with Observables Real-world examples using .then() and async/await When to use Promises vs Observables in Angular 📚 Table of Contents 🔍 What is a Promise? 🔁 Promise Lifecycle ✨ Key Features 📌 Syntax 💻 Example 1: Fetch 💻 Example 2: setTimeout 📊 Promises vs Observables 🎯 When to Use Promises 📦 Angular Service Example 🔄 Observable vs Promise ❓ FAQ ✅ Summary 🔍 What is a Promise? A Promise is a JavaScript object that represents the eventual success (fulfilled) or failure (rejected) of an asynchronous operation. 📌 Com...
Read more

Debouncing & Throttling in RxJS: Optimizing API Calls and User Interactions

RxJS Debounce vs Throttle in Angular – Best Practices & Examples What is RxJS — quick primer RxJS (Reactive Extensions for JavaScript) provides Observables and operators to model and manipulate streams of asynchronous events — from keystrokes and HTTP requests to timers and WebSocket messages. 💡 Why this matters: Operators like debounceTime and throttleTime help you control event frequency, reducing wasted CPU and network work while improving UX. 1. Debouncing — emit after silence Debouncing delays emitting a value until a specified period of inactivity. It's best for typeahead inputs where only the final value after the user stops typing is relevant. Live search example (production-ready) // search.component.ts import { Component, OnDestroy } from '@angular/core'; import { FormControl } from '@angular/forms'; import { Subject } from 'rxjs'; import { debounc...
Read more

Csharp Coding - Session

Image
✅ Reverse String Array using System; public class Program { public static void Main() { ReverseStringArray (); } public static void ReverseStringArray() { string[] str = { "priya", "Sai" }; int length = str.Length; for (int i = 0, j = length - 1; i < j; i++, j--) { string temp = str[i]; str[i] = str[j]; str[j] = temp; } Console.WriteLine(string.Join(", ", str)); // Output: Sai, priya } } Output: Sai, priya ✅ Reverse String Array + Each Word using System; public class Program { public static void Main() { ReverseStringArray(); } public static void ReverseStringArray() { string[] str = { "priya", "Sai" }; // Step 1: Reverse the array string[] reversedArray = ReverseArray (str); // Step 2: Reverse e...
Read more