Behavioral Design Patterns

-

Behavioral Design Patterns (C# / .NET)

Definition

  • Focus on communication between objects
  • Defines how objects interact and share responsibilities

Purpose

  • Improve communication flow
  • Reduce tight coupling between objects
  • Make behavior dynamic and flexible
  • Encapsulate business logic

Types with Real-Time Usage

1. Strategy Pattern

Idea: Change behavior at runtime

Real Scenario: Tax / Discount calculation in invoice

public interface ITaxStrategy
{
    decimal Calculate(decimal amount);
}

public class GstTax : ITaxStrategy
{
    public decimal Calculate(decimal amount) => amount * 0.18m;
}

public class NoTax : ITaxStrategy
{
    public decimal Calculate(decimal amount) => 0;
}

public class InvoiceService
{
    private readonly ITaxStrategy _tax;

    public InvoiceService(ITaxStrategy tax)
    {
        _tax = tax;
    }

    public decimal GetTotal(decimal amount)
    {
        return amount + _tax.Calculate(amount);
    }
}

2. Observer Pattern

Idea: One object notifies multiple objects

Real Scenario: Order placed → Email, SMS, Notification triggered

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

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

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

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

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

3. Command Pattern

Idea: Encapsulate request as an object

Real Scenario: Button click → Execute action (Save, Delete)

public interface ICommand
{
    void Execute();
}

public class CreateInvoiceCommand : ICommand
{
    public void Execute()
    {
        Console.WriteLine("Invoice Created");
    }
}

ICommand command = new CreateInvoiceCommand();
command.Execute();

4. Mediator Pattern

Idea: Central object controls communication

Real Scenario: Chat system / multiple services interaction

public class Mediator
{
    public void Send(string message, User user)
    {
        Console.WriteLine($"{user.Name}: {message}");
    }
}

public class User
{
    private readonly Mediator _mediator;
    public string Name { get; }

    public User(Mediator mediator, string name)
    {
        _mediator = mediator;
        Name = name;
    }

    public void Send(string message)
    {
        _mediator.Send(message, this);
    }
}

Pros

  • Loose coupling between objects
  • Flexible and scalable behavior
  • Easier to extend features
  • Better separation of concerns

Cons

  • More classes and complexity
  • Harder debugging
  • Learning curve

When to Use

  • When multiple objects need to communicate
  • When behavior needs to change dynamically
  • When reducing direct dependency is important
  • When implementing event-driven systems

Quick Summary Table

Type Focus Main Goal
Creational Object Creation Flexible object creation
Structural Object Structure Simplify relationships
Behavioral Object Interaction Better communication

Mapping to Your .NET Project

Feature Pattern
Tax / Discount logic Strategy
Order notifications Observer
API actions (Create/Update) Command
Service coordination Mediator

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

Comprehensive Guide to C# and .NET Core OOP Concepts and Language Features

-
Comprehensive Guide to C# and .NET Core OOP Concepts Class A class is a blueprint for creating objects that encapsulate both data and behavior. Access Modifiers : public, internal, abstract, sealed control visibility and inheritance. Static Classes : Cannot be instantiated, contain only static members. Partial Classes : Split across files using partial keyword for better organization. public class Car { public string Model; public void Drive() => Console.WriteLine($"{Model} is driving."); } Analogy: A car blueprint used to build many actual cars. Benefits: Reusability, Encapsulation, Abstraction, Inheritance Object An object is an instance of a class. Managed by Garbage Collector for automatic memory cleanup. Boxing/Unboxing allows value types to be treated a...
Read more