Interview Q&A

• The pattern can be easily extended to include more handlers, which means it

can scale well as the number of log levels (or other request types) grows.

Improvement Suggestions:

• Add More Log Levels:

Follow:

• You could add additional log levels such as Warning, Debug, or Fatal,

each handled by its own specific logger. You would just need to create new

concrete handlers for these levels.

• Logging to Different Destinations:
• Each logger could be extended to not just print to the console, but also log to

files, databases, or remote servers. This way, the Chain of Responsibility

could support more complex logging systems with different outputs for each

level.

• Adding a Default Handler:
• If no handler in the chain can process a message, it might be useful to have a

default handler (such as a DefaultLogger) that logs an unknown

message or performs some fallback action.

Real-Time Use Case Example:

The Chain of Responsibility Pattern is often used in real-time systems like:

• Logging systems, where you need to handle messages at various levels (Info,

Error, Warning).

• Event handling systems, where each handler deals with different types of events

and either processes or passes them on.

• Request handling pipelines in web servers, where requests pass through multiple

stages, and each stage processes the request in a specific way (e.g., authentication,

authorization, logging, validation).

Visual Diagram:

Here’s a simple visual diagram to understand the Chain of Responsibility Pattern:

+------------------+

| InfoLogger | <-- Handles LogLevel.Info

+------------------+

Follow:

+------------------+

| ErrorLogger | <-- Handles LogLevel.Error

+------------------+

(End of Chain)

The Chain of Responsibility Pattern is a powerful way to handle requests that need to be

processed by multiple handlers, each responsible for a specific part of the process. It is

especially useful when you have a sequence of operations (like logging, event handling, or

request processing) that may vary based on context.

Command Pattern: Real-Time Example - Undo Functionality in a Text

Editor

Scenario:

In a text editor, you often need the ability to undo actions (like adding or removing text) to

revert the document to its previous state. The Command Pattern is an excellent choice for

implementing undo functionality. This pattern encapsulates requests as objects, allowing for

parameterization of clients with queues, requests, and operations. It decouples the sender of

the request from the object that processes the request, making it easier to manage actions

and undo operations.

Code Explanation:

• You don’t need to re-implement the drawing logic for each new shape.

Instead, you can simply reuse the same drawing API for multiple shapes.

Follow:

Improvement Suggestions:

• Add More Shapes:
• To extend the pattern, you can introduce additional shape classes like

Rectangle or Triangle, and have them use the same drawing API to

render their specific shapes.

• Introduce More Drawing APIs:
• As the application grows, you could add more concrete implementations of

IDrawingAPI for different rendering libraries, allowing the user to select their

preferred drawing style or technology.

• Performance Optimization:
• If your drawing application needs to optimize performance (e.g., when

rendering complex or large scenes), you could implement caching strategies

in your drawing APIs or leverage lazy initialization.

Real-Time Use Case Example:

The Bridge Pattern is particularly useful when building graphics software, drawing

applications, or game engines where you may need to render shapes in various styles. For

instance:

• A drawing application that supports multiple rendering backends (e.g., OpenGL,

DirectX, or HTML Canvas).

• A game engine where you have various game objects (e.g., players, enemies) that

need to be drawn using different rendering techniques.

Visual Diagram:

Here’s a simple visual diagram to understand the Bridge Pattern:

Abstraction (Shape) --> IDrawingAPI (Implementation)

| |

v v

Follow:

Refined Abstraction (Circle) --> Concrete Implementations

(DrawingAPI1, DrawingAPI2)

Builder Pattern: Real-Time Example - Building a Custom Pizza

Scenario:

Imagine you're building a pizza ordering system that allows customers to customize their

pizzas with different dough types, sauces, and toppings. The Builder Pattern is a perfect fit

for such use cases where you need to create complex objects step by step, each with

various configurations or options.

The Builder Pattern separates the construction of an object from its representation. This

means the same construction process can create different variations of an object. In this

case, the pattern allows for building different types of pizzas (e.g., Margherita, Pepperoni,

Veggie) with various ingredients.

Code Explanation:

user interface.

Visual Diagram:

+------------------+ +-------------------+

| NewsPublisher |-------| NewsSubscriber |

| (Subject) | | (Observer) |

+------------------+ +-------------------+

| |

| Subscribe/Unsubscribe | Update

v v

+------------------+ +-------------------+

| NewsPublisher | | NewsSubscriber |

| (Subject) |-------| (Observer) |

+------------------+ +-------------------+

Conclusion:

The Observer Pattern is a powerful and flexible design pattern for building systems where

objects need to be notified of changes to another object's state. It's particularly useful in

event-driven architectures, where one action (such as publishing an article, changing a stock

price, or a weather update) triggers multiple reactions (notifications to subscribers). The

pattern promotes loose coupling and ensures that your system remains scalable,

maintainable, and responsive to changes in state.

Prototype Pattern: Cloning Complex Objects

Definition:

The Prototype Pattern is a creational design pattern that allows you to create new objects

by copying an existing object, known as the "prototype." This pattern is particularly useful

when the cost of creating an object from scratch is expensive or complex, and you want to

reuse an existing object as the prototype to create new instances.

Use Case:

typical use case for the Prototype Pattern is cloning complex objects, such as game

characters with various attributes (e.g., health, weapons, inventory), where creating new

objects from scratch can be time-consuming. Instead of rebuilding objects from the ground

up, you can clone an existing object and modify it as necessary.

Code Breakdown:

nd Bob. The subscribers are subscribed to the publisher. When the publisher sends

out a notification (Notify()), all subscribers are automatically notified and updated

with the latest news.

class Program
{

static void Main()

{
var publisher = new NewsPublisher();
var subscriber1 = new NewsSubscriber("Alice");
var subscriber2 = new NewsSubscriber("Bob");

publisher.Subscribe(subscriber1);

publisher.Subscribe(subscriber2);

publisher.Notify("Breaking News: Observer Pattern in C#!");

}
}

Output:

lice received news: Breaking News: Observer Pattern in C#!

Bob received news: Breaking News: Observer Pattern in C#!

• How It Works:

llows us to add additional behavior to the coffee object, but we don't modify

the base class (SimpleCoffee).

public abstract class CoffeeDecorator : ICoffee
{

protected ICoffee _coffee;

protected CoffeeDecorator(ICoffee coffee) => _coffee = coffee;
public virtual double Cost() => _coffee.Cost();
public virtual string Description() => _coffee.Description();
}

ctual operations for adding and removing text from the document. The

ddText and RemoveText methods manipulate the internal content (a

StringBuilder).
public class Document
{
private readonly StringBuilder _content = new StringBuilder();
public void AddText(string text) => _content.Append(text);
public void RemoveText(string text) =>

_content.Remove(_content.Length - text.Length, text.Length);

public override string ToString() => _content.ToString();
}

• In GUI systems, UI components (like buttons or text boxes) can be

considered observers that listen to changes or events (like button clicks) from

a user interface.

Visual Diagram:

+------------------+ +-------------------+

| NewsPublisher |-------| NewsSubscriber |

| (Subject) | | (Observer) |

+------------------+ +-------------------+

| |

| Subscribe/Unsubscribe | Update

v v

+------------------+ +-------------------+

| NewsPublisher | | NewsSubscriber |

Follow:

| (Subject) |-------| (Observer) |

+------------------+ +-------------------+

Conclusion:

The Observer Pattern is a powerful and flexible design pattern for building systems where

objects need to be notified of changes to another object's state. It's particularly useful in

event-driven architectures, where one action (such as publishing an article, changing a stock

price, or a weather update) triggers multiple reactions (notifications to subscribers). The

pattern promotes loose coupling and ensures that your system remains scalable,

maintainable, and responsive to changes in state.

Prototype Pattern: Cloning Complex Objects

Definition:

The Prototype Pattern is a creational design pattern that allows you to create new objects

by copying an existing object, known as the "prototype." This pattern is particularly useful

when the cost of creating an object from scratch is expensive or complex, and you want to

reuse an existing object as the prototype to create new instances.

Use Case:

A typical use case for the Prototype Pattern is cloning complex objects, such as game

characters with various attributes (e.g., health, weapons, inventory), where creating new

objects from scratch can be time-consuming. Instead of rebuilding objects from the ground

up, you can clone an existing object and modify it as necessary.

Code Breakdown:

• The User class represents a user in the chat application. Each user has a

name and a reference to the mediator.

• When a user wants to send a message, they call Send() on the mediator,

which then sends the message to all other registered users.

• Users only interact with the mediator, and not with each other directly.

public class User
{
private readonly string _name;
private readonly IChatMediator _mediator;
public User(string name, IChatMediator mediator)
{
_name = name;
_mediator = mediator;

_mediator.RegisterUser(this); // Register the user with the

mediator

}
public void Send(string message) =>

_mediator.SendMessage(message, this);

public void Receive(string message) =>

Console.WriteLine($"{_name} received: {message}");

}

Answer: The Iterator Pattern provides a consistent and uniform way to access elements of the collection, regardless of the underlying structure of the collection. Real-Time Use Case Examples:

What interviewers expect

• A clear definition tied to GoF Patterns in Gang of Four Patterns projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Gang of Four Patterns application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Gang of Four Patterns architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

• The ProductIterator class implements the IIterator<Product>

interface and keeps track of the current position in the

ProductCollection. It knows how to traverse the collection, check if

there’s a next item (HasNext()), and return the next item (Next()).

Answer: The Add class is a non-terminal expression. It takes two other expressions (leftExpression and rightExpression) and computes their sum. Non-terminal expressions represent operations that combine multiple sub-expressions.

What interviewers expect

• A clear definition tied to GoF Patterns in Gang of Four Patterns projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Gang of Four Patterns application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Gang of Four Patterns architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

• In the client code, we create a CharacterFactory instance to manage the

characters. We then iterate over the text "Hello World", requesting a

Character object for each character.

• The flyweight objects are reused, reducing memory consumption.

class Program
{

static void Main()

{
var factory = new CharacterFactory();
string text = "Hello World";
foreach (var c in text)
{
var character = factory.GetCharacter(c);

character.Display(0, 0); // Simplified position for this

example

}
}
}

• This is an abstract class that declares the CreateLogger method, which is

intended to return an ILogger instance. The actual instantiation is delegated

to subclasses.

public abstract class LoggerFactory
{
public abstract ILogger CreateLogger();
}

• The CoffeeDecorator class is an abstract class that implements the

ICoffee interface and holds a reference to an ICoffee object. This class

allows us to add additional behavior to the coffee object, but we don't modify

the base class (SimpleCoffee).

public abstract class CoffeeDecorator : ICoffee

protected ICoffee _coffee;

protected CoffeeDecorator(ICoffee coffee) => _coffee = coffee;

public virtual double Cost() => _coffee.Cost();

public virtual string Description() => _coffee.Description();

• The Directory class is a composite node in the tree structure. It can

contain multiple IFileSystemComponent objects (both files and

subdirectories). The ShowInfo() method displays the directory’s name and

recursively calls ShowInfo() on its children (whether they are files or

subdirectories).

• The Document class represents the receiver of the command. It contains the

actual operations for adding and removing text from the document. The

AddText and RemoveText methods manipulate the internal content (a

StringBuilder).

public class Document

Follow:

private readonly StringBuilder _content = new StringBuilder();

public void AddText(string text) => _content.Append(text);

public void RemoveText(string text) =>

_content.Remove(_content.Length - text.Length, text.Length);

public override string ToString() => _content.ToString();

Answer: The LogLevel enum defines the different types of log messages (e.g., Info, Error). public enum LogLevel { Info, Error }

What interviewers expect

• A clear definition tied to GoF Patterns in Gang of Four Patterns projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Gang of Four Patterns application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Gang of Four Patterns architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

• The MargheritaPizzaBuilder is a concrete implementation of the

IPizzaBuilder interface. It builds a specific type of pizza (Margherita in

this case) by setting the dough, sauce, and adding toppings. The Build()

method returns the fully constructed pizza.

public class MargheritaPizzaBuilder : IPizzaBuilder
{
private Pizza _pizza = new Pizza();
public void SetDough(string dough) => _pizza.Dough = dough;
public void SetSauce(string sauce) => _pizza.Sauce = sauce;
public void AddTopping(string topping) =>

_pizza.Toppings.Add(topping);

public Pizza Build() => _pizza;
}

• The DrawingAPI1 and DrawingAPI2 are concrete implementations of the

IDrawingAPI interface. These classes implement the specific drawing logic

for rendering circles, but they could use different libraries or methods (e.g.,

OpenGL, DirectX, Canvas API).

public class DrawingAPI1 : IDrawingAPI
{
public void DrawCircle(double x, double y, double radius) =>

Console.WriteLine($"Drawing Circle at ({x}, {y}) with radius

{radius} using API 1.");

}
public class DrawingAPI2 : IDrawingAPI
{
public void DrawCircle(double x, double y, double radius) =>

Console.WriteLine($"Drawing Circle at ({x}, {y}) with radius

{radius} using API 2.");

}

• The Adapter class implements the ITarget interface, and it wraps an

instance of the Adaptee class. It delegates calls from Request() to the

SpecificRequest() method of the Adaptee, making the two interfaces

compatible.

public class Adapter : ITarget

private readonly Adaptee _adaptee;

public Adapter(Adaptee adaptee) => _adaptee = adaptee;

public void Request() => _adaptee.SpecificRequest();

• The IButton and ICheckbox interfaces define the general contract for

products. Each concrete product (e.g., WindowsButton, MacButton) will

implement the Render method to display platform-specific UI elements.

public interface IButton { void Render(); }
public interface ICheckbox { void Render(); }

Answer: other expressions. It leverages the recursive nature of the Interpreter Pattern to evaluate complex expressions.

What interviewers expect

• A clear definition tied to GoF Patterns in Gang of Four Patterns projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Gang of Four Patterns application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Gang of Four Patterns architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Follow:

What interviewers expect

• A clear definition tied to GoF Patterns in Gang of Four Patterns projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Gang of Four Patterns application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Gang of Four Patterns architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

nd undoing commands. When a command is executed, it’s pushed onto the

stack. The Undo() method pops the last executed command and undoes its

ction.

public class TextEditor
{
private readonly Stack<ICommand> _commandHistory = new

Stack<ICommand>();

public void ExecuteCommand(ICommand command)
{

command.Execute();

_commandHistory.Push(command);

}
public void Undo()
{
if (_commandHistory.Count > 0)
{
var command = _commandHistory.Pop();

command.Undo();

}
}
}

ppropriate methods on the builder. It then returns the final product.

public class PizzaDirector
{
private readonly IPizzaBuilder _builder;
public PizzaDirector(IPizzaBuilder builder) => _builder =

builder;

public Pizza ConstructMargheritaPizza()
{

_builder.SetDough("Thin Crust");

_builder.SetSauce("Tomato");

_builder.AddTopping("Mozzarella");

return _builder.Build();
}
}