Structural Design Patterns

The 7 Structural Design Patterns with:

• Definition

• Problem Statement

• UML Diagram

• Real-world Example

• Complete C# Console Application

• ASP.NET Core Example

• Advantages

• Disadvantages

• Best Practices

• Common Mistakes

• Interview Questions

Part 3.1 – Adapter Design Pattern

You'll learn:

• What is the Adapter Pattern?

• Why incompatible interfaces become a problem

• Object Adapter vs Class Adapter

• Adapter Pattern Structure

• UML Class Diagram

• Real-world Examples (Power Adapter, USB Adapter)

• Complete C# Console Application

• ASP.NET Core Example

• Advantages and Disadvantages

• Best Practices

• Common Mistakes

• Interview Questions

---

Part 3.2 – Bridge Design Pattern

Topics:

• What is the Bridge Pattern?

• Abstraction vs Implementation

• Composition over Inheritance

• UML Diagram

• Complete C# Example

• ASP.NET Core Example

• Real-world Examples

• Advantages

• Disadvantages

• Interview Questions

---

Part 3.3 – Composite Design Pattern

Topics:

• Tree Structures

• Parent–Child Relationships

• Composite vs Leaf Objects

• UML Diagram

• File System Example

• Organization Hierarchy Example

• C# Console Application

• ASP.NET Core Example

• Advantages

• Disadvantages

• Interview Questions

---

Part 3.4 – Decorator Design Pattern

Topics:

• Dynamic Behavior Addition

• Wrapper Objects

• Decorator vs Inheritance

• Coffee Shop Example

• Middleware Analogy in ASP.NET Core

• Complete C# Example

• UML Diagram

• Advantages

• Disadvantages

• Best Practices

• Interview Questions

---

Part 3.5 – Facade Design Pattern

Topics:

• Simplifying Complex Systems

• Wrapper APIs

• Banking System Example

• Home Theater Example

• ASP.NET Core Integration

• UML Diagram

• C# Console Example

• Advantages

• Disadvantages

• Interview Questions

---

Part 3.6 – Flyweight Design Pattern

Topics:

• Memory Optimization

• Shared Objects

• Intrinsic vs Extrinsic State

• Text Editor Example

• Game Development Example

• UML Diagram

• Complete C# Example

• ASP.NET Core Example

• Advantages

• Disadvantages

• Performance Considerations

• Interview Questions

---

Part 3.7 – Proxy Design Pattern

Topics:

• Virtual Proxy

• Remote Proxy

• Protection Proxy

• Smart Proxy

• Lazy Loading

• Entity Framework Core Proxy

• C# Example

• ASP.NET Core Example

• UML Diagram

• Advantages

• Disadvantages

• Interview Questions

---

What You'll Learn in Part 3

By the end of the Structural Design Patterns section, you'll understand:

• How to connect incompatible interfaces using Adapter.

• How to separate abstraction from implementation with Bridge.

• How to represent hierarchical tree structures using Composite.

• How to add functionality dynamically using Decorator.

• How to simplify complex subsystems with Facade.

• How to optimize memory usage using Flyweight.

• How to control access to objects using Proxy.

You'll also see how these patterns are applied in modern C# and ASP.NET Core applications, including Dependency Injection, middleware pipelines, Entity Framework Core, cloud integrations, and enterprise architectures.

---

Next Article

We'll begin Part 3.1 – Adapter Design Pattern, covering:

• What is the Adapter Pattern?

• Why incompatible interfaces become a problem

• Object Adapter vs. Class Adapter

• UML Class Diagram

• Complete C# Console Application

• ASP.NET Core implementation

• Real-world examples

• Advantages and disadvantages

• Best practices

• Common mistakes

• Interview questions

The Adapter Pattern is one of the most practical structural patterns and is widely used when integrating third-party libraries, legacy systems, external APIs, or services with incompatible interfaces. It provides a clean way to make otherwise incompatible components work together without modifying their existing code.

🧩 Façade Design Pattern in C# – Simplifying Complex Systems

🔍 What is the Façade Design Pattern?

The Façade Design Pattern is a structural design pattern that provides a simplified interface to a complex subsystem of classes, libraries, or frameworks.
In simple terms, it hides the complexity of multiple interdependent systems behind a single, easy-to-use interface.

Think of a hotel receptionist — you don’t directly talk to housekeeping, room service, or maintenance. The receptionist (Façade) takes your request and communicates with the right departments internally.

---

🧠 Intent of the Façade Pattern

• Simplify interaction between client and complex subsystems.

• Reduce dependencies between client and internal components.

• Make the system easier to use and maintain.

---

🧩 Structure (UML Conceptually)

Client → Facade → SubsystemA
                 → SubsystemB
                 → SubsystemC

The Client interacts with the Facade, which delegates calls to one or more Subsystems.

---

💻 C# Example: Home Theater System

Let’s say you’re building a Home Theater Application that involves multiple components:

• DVD Player

• Projector

• Sound System

• Lights

Instead of the client calling all these subsystems directly, we can use a Facade class to control them with a single method call.

✅ Step 1: Subsystems

public class DVDPlayer
{
    public void On() => Console.WriteLine("DVD Player On");
    public void Play(string movie) => Console.WriteLine($"Playing '{movie}'");
    public void Off() => Console.WriteLine("DVD Player Off");
}

public class Projector
{
    public void On() => Console.WriteLine("Projector On");
    public void SetInput(string source) => Console.WriteLine($"Projector input set to {source}");
    public void Off() => Console.WriteLine("Projector Off");
}

public class SoundSystem
{
    public void On() => Console.WriteLine("Sound System On");
    public void SetVolume(int level) => Console.WriteLine($"Volume set to {level}");
    public void Off() => Console.WriteLine("Sound System Off");
}

public class Lights
{
    public void Dim(int level) => Console.WriteLine($"Lights dimmed to {level}%");
}

✅ Step 2: Façade Class

public class HomeTheaterFacade
{
    private readonly DVDPlayer dvd;
    private readonly Projector projector;
    private readonly SoundSystem sound;
    private readonly Lights lights;

    public HomeTheaterFacade(DVDPlayer dvd, Projector projector, SoundSystem sound, Lights lights)
    {
        this.dvd = dvd;
        this.projector = projector;
        this.sound = sound;
        this.lights = lights;
    }

    public void WatchMovie(string movie)
    {
        Console.WriteLine("Get ready to watch a movie...");
        lights.Dim(10);
        projector.On();
        projector.SetInput("DVD Player");
        sound.On();
        sound.SetVolume(5);
        dvd.On();
        dvd.Play(movie);
    }

    public void EndMovie()
    {
        Console.WriteLine("Shutting down the home theater...");
        dvd.Off();
        sound.Off();
        projector.Off();
        lights.Dim(100);
    }
}

✅ Step 3: Client Code

class Program
{
    static void Main()
    {
        var dvd = new DVDPlayer();
        var projector = new Projector();
        var sound = new SoundSystem();
        var lights = new Lights();

        var homeTheater = new HomeTheaterFacade(dvd, projector, sound, lights);

        homeTheater.WatchMovie("Avengers: Endgame");
        Console.WriteLine("\n--- Movie Finished ---\n");
        homeTheater.EndMovie();
    }
}

🧾 Output:

Get ready to watch a movie...
Lights dimmed to 10%
Projector On
Projector input set to DVD Player
Sound System On
Volume set to 5
DVD Player On
Playing 'Avengers: Endgame'

--- Movie Finished ---

Shutting down the home theater...
DVD Player Off
Sound System Off
Projector Off
Lights dimmed to 100%

---

🚀 Real-Time Use Cases of Façade Pattern

Scenario	How Façade Helps
Banking Systems	Simplifies complex operations like fund transfers by combining multiple services (accounts, validation, notification) into one interface.
E-commerce Checkout	Combines inventory, payment, and order services into one checkout process.
Hotel Booking APIs	Wraps flight, hotel, and transport systems behind a single booking interface.
Logging or Notification Systems	Provides one class to log to multiple targets (database, file, email).
Azure / AWS SDK Wrappers	Developers use simplified API wrappers to avoid dealing with multiple low-level SDK services.

---

⚖️ Advantages of the Façade Pattern

✅ Simplifies complex systems for clients
✅ Reduces coupling between client and subsystems
✅ Improves code readability and maintenance
✅ Makes the system more modular

---

⚠️ Disadvantages

❌ Overuse may hide useful functionality from the client
❌ Can become a "God Object" if it grows too large
❌ Difficult to maintain if subsystems frequently change

---

💡 Best Practices

• Use when you have a complex system with multiple dependencies.

• Keep the Facade thin — it should only simplify, not duplicate logic.

• Combine with Singleton pattern for global access if needed.

• Avoid making it responsible for business rules — just coordination.

---

🧭 Conclusion

The Façade Design Pattern acts like a front desk for your codebase — it hides unnecessary complexity and makes client interactions smooth and simple.
When used properly, it makes large systems more maintainable, readable, and user-friendly.