Interview Q&A

• The Composite Pattern can also be used in organizational structures, where

departments (composites) contain teams or employees (individuals), and both

can be treated as "components" with a common interface for operations like

calculating total salary or generating reports.

Improvement Suggestions:

Answer: The recursive structure makes it easy to manage hierarchical data. For example, when displaying the contents of a directory, you don’t need to worry about whether the child is a file or a subdirectory.

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 File class represents the leaf in the tree structure. It is an individual

component (a file) and implements the ShowInfo() method to display its

details.

public class File : IFileSystemComponent
{
private string _name;
public File(string name) => _name = name;
public void ShowInfo() => Console.WriteLine($"File: {_name}");
}

• You can combine multiple commands into a composite command. For

example, if the user performs a series of actions (like adding text, changing

fonts, and changing colors), you can encapsulate all of those actions into a

single composite command that can be undone in one step.

Real-Time Use Case Example:

The Command Pattern is often used in:

• Text Editors: For implementing undo/redo functionality and user interactions.
• Transaction Systems: Where each action can be encapsulated as a command, and

the entire system can be undone or redone.

• GUI Frameworks: Buttons, sliders, and menu items can be mapped to commands,

allowing for consistent handling of actions across the UI.

• Gaming Applications: Where player actions (e.g., moving, shooting) can be

encapsulated as commands and undone when necessary.

Follow:

Visual Diagram:

Here's a simple visual diagram to understand the Command Pattern:

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

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

| TextEditor | ---> | AddTextCommand | ---> |

Document |

| (Invoker) | | (Concrete Command) | |

(Receiver) |

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

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

| |

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

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

| Undo | |

AddText / RemoveText |

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

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

The Command Pattern provides a flexible and scalable way to handle requests in

object-oriented systems, especially when you need to manage complex workflows,

implement undo/redo functionality, or decouple senders from receivers.

Composite Pattern: Real-Time Example - Building a File System

Scenario:

The Composite Pattern is used when you need to treat individual objects and compositions

of objects uniformly. This is particularly useful when you have a hierarchical structure, like a

file system, where files and directories can be treated in a similar manner.

In a file system:

• Files are the individual objects (leaves).

Follow:

• Directories are composite objects that can contain files or other directories

(children).

This pattern helps to simplify the management of hierarchical structures, making it easier to

handle both individual items and collections of items in a unified way.

Code Explanation:

Answer: New types of loggers can be added in the future (e.g., DatabaseLogger, CloudLogger) by simply creating new factory subclasses without modifying existing client code.

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 TextEditor maintains a stack of executed commands. When the

Undo() method is called, it pops the most recent command from the stack

and calls its Undo() method, which reverts the action performed by the

command (removes the last added text).

Key Benefits of the Command Pattern:

• The AddTextCommand is a concrete implementation of the ICommand

interface. It encapsulates the request to add text to the document.

• The Execute() method adds the specified text to the document, and the

Undo() method removes that text.

public class AddTextCommand : ICommand
{
private readonly Document _document;
private readonly string _text;
public AddTextCommand(Document document, string text)
{
_document = document;
_text = text;
}
public void Execute() => _document.AddText(_text);
public void Undo() => _document.RemoveText(_text);
}

Answer: .LogMessage(...)). This continues until a handler processes the message or the chain is exhausted. Key Benefits of the Chain of Responsibility Pattern:

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 InfoLogger and ErrorLogger are concrete handlers that implement

the Logger class. Each handler checks if it can handle a particular log level

(e.g., Info or Error). If it can, it processes the log; otherwise, it passes it along

to the next handler in the chain.

public class InfoLogger : Logger
{

protected override bool CanHandle(LogLevel level) => level ==

LogLevel.Info;

protected override void Handle(string message) =>

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

}
public class ErrorLogger : Logger
{

protected override bool CanHandle(LogLevel level) => level ==

LogLevel.Error;

protected override void Handle(string message) =>

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

}

• Since each handler is responsible for a specific task (in this case, logging a

specific level of message), it’s easier to modify or extend the system. For

example, adding a new log level (e.g., Debug) would only require creating a

new handler for that level without affecting existing code.

• The Flyweight Pattern allows you to manage large quantities of similar objects

efficiently. You can still modify the extrinsic state (e.g., the character's

position) without impacting the shared intrinsic state.

Real-Time Use Case Examples:

• The IPizzaBuilder interface defines the steps for constructing a pizza. It

includes methods for setting the dough, sauce, and adding toppings, as well

as a Build() method to return the fully constructed pizza.

public interface IPizzaBuilder

void SetDough(string dough);

void SetSauce(string sauce);

void AddTopping(string topping);

Pizza Build();

Answer: The separation of concerns means that any changes to the rendering logic (e.g., upgrading the drawing API) do not affect the shape logic, and vice versa. This results in less risk of introducing bugs when making changes.

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 IDrawingAPI interface defines the drawing method (DrawCircle in

this case). Different concrete implementations of this interface will represent

various drawing styles or technologies.
public interface IDrawingAPI
{

void DrawCircle(double x, double y, double radius);

}

Follow:

This pattern provides a clean, reusable way to bridge the gap between incompatible

interfaces, making integration smoother and more manageable.

Bridge Pattern: Real-Time Example - Drawing Application with Multiple

Styles

Scenario:

Imagine you are building a drawing application that allows users to draw different shapes

(like circles) in various styles. The Bridge Pattern is a great solution when you want to

decouple the shape abstraction from the rendering logic, allowing both the shapes and the

drawing styles to vary independently.

The Bridge Pattern separates the abstraction (the shape) from its implementation (the

drawing API), allowing you to modify the shape or the rendering technique without affecting

the other. This makes your code more flexible and maintainable.

Code Explanation:

• The Adaptee class is the existing class that has a different interface from the

one the client expects. In this case, it has a method SpecificRequest()

that performs some action, but it does not conform to the ITarget interface.

public class Adaptee

Follow:

public void SpecificRequest() => Console.WriteLine("Specific

request from Adaptee.");

• The pattern ensures that the UI components are consistent with the platform's

look and feel, as each factory provides platform-specific products.

Improvement Suggestions:

• Extendability:
• You can extend this pattern by adding more UI components (e.g., menus,

dialogs) to your abstract factory. This would allow for more complex UI

systems that adapt to various platforms.

• Lazy Initialization:
• For performance optimization, you could implement lazy initialization in the

product creation methods (e.g., create UI components only when needed).

• Factory Registration:
• Consider using a Factory Registry or Abstract Factory Locator pattern if

you need to dynamically select factories based on runtime conditions (e.g.,

based on user preferences or system environment).

Real-Time Use Case Example:

This pattern is extremely useful when building cross-platform desktop applications with a

consistent UI, like in Electron or Xamarin apps. It allows developers to write

Follow:

platform-agnostic code that automatically adapts to the underlying operating system's UI

conventions.

Adapter Pattern: Real-Time Example - Integrating Third-Party Libraries

Scenario:

You're working on a project where you need to integrate a third-party library with a

pre-existing system. However, the third-party library has a different interface than the one

your system expects. In such cases, the Adapter Pattern can be used to wrap the

third-party interface and make it compatible with your existing system.

The Adapter Pattern is a structural design pattern that allows incompatible interfaces to

work together. It "adapts" one interface to another by creating a wrapper class that translates

method calls between the two interfaces.

Code Explanation:

• The WindowsUIFactory and MacUIFactory are concrete implementations

of the IUIFactory interface. Each factory creates platform-specific objects

like buttons and checkboxes.

public class WindowsUIFactory : IUIFactory
{
public IButton CreateButton() => new WindowsButton();
public ICheckbox CreateCheckbox() => new WindowsCheckbox();
}
public class MacUIFactory : IUIFactory
{
public IButton CreateButton() => new MacButton();
public ICheckbox CreateCheckbox() => new MacCheckbox();
}

Answer: lways followed in the same sequence, regardless of the specific recipe. This prevents inconsistent workflows in different implementations. When to Use the Template Method Pattern:

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.

Answer: ction and then set the next state, allowing the traffic light to cycle through its states (Red → Green → Yellow → Red). Benefits of the State Pattern:

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.

dditional checks like authentication or caching.

Conclusion:

The Proxy Pattern is an excellent design pattern to control access to expensive or sensitive

objects. Whether it's controlling resource initialization (virtual proxy), managing remote

communication (remote proxy), or handling access control (protective proxy), proxies enable

efficient resource management and enhance security in an application.

Singleton Pattern: Ensuring a Single Instance

Definition:

The Singleton Pattern ensures that a class has only one instance throughout the lifetime of

n application and provides a global point of access to that instance. It's often used for

managing shared resources, like configuration settings, logging, or database connections.

Use Case:

The Singleton Pattern is useful when you need to control access to a shared resource or

configuration. For example, when managing global configuration settings or database

connections, it ensures that the configuration or connection is accessed by all parts of the

pplication via a single, consistent instance.

Code Breakdown:

Answer: ccess to the real object. For example, it could authenticate users before llowing access to a sensitive resource. Types of Proxy:

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.

nimals) can be cloned from a prototype, allowing for rapid creation of

multiple instances with different states.

Deep Cloning Example:

If you need to perform deep cloning, where not just the properties but also the referenced

objects are cloned, you can adjust the Clone() method to handle the deep copy:

public class GameCharacter : ICloneable
{
public string Name { get; set; }
public int Health { get; set; }
public List<string> Inventory { get; set; } = new
List<string>();
public ICloneable Clone()
{
var clone = new GameCharacter
{

Name = this.Name,

Health = this.Health,

Inventory = new List<string>(this.Inventory) // Deep

copy of the Inventory list

};

return clone;
}
}

In this case, the Inventory list will also be cloned to ensure that modifications to the

Inventory of the clone do not affect the original object.

Conclusion:

The Prototype Pattern is a powerful creational pattern that allows you to clone objects

instead of creating them from scratch. It's especially useful when dealing with complex

objects or systems where performance and resource management are important. By using

this pattern, you can quickly create new objects with similar attributes and save time and

resources that would otherwise be spent constructing them from scratch.

Proxy Pattern: Controlling Access to Expensive Resources

Definition:

The Proxy Pattern provides a surrogate or placeholder for another object to control access

to it. The proxy acts as an intermediary, enabling you to perform additional actions (e.g., lazy

loading, access control, logging) before or after delegating operations to the real object.

Use Case:

The Proxy Pattern is useful when you need to control access to an expensive or

resource-intensive object. A common use case is controlling access to resources like large

images, network connections, or database connections. Instead of creating the actual object

immediately, a proxy can delay its creation or manage its lifecycle efficiently.

Code Breakdown:

nd implements the Update() method to receive news updates from the publisher.

public class NewsSubscriber : IObserver
{
private readonly string _name;
public NewsSubscriber(string name) => _name = name;
public void Update(string news) => Console.WriteLine($"{_name}

received news: {news}");

}

Answer: re passed along the pipeline in a controlled and coordinated manner. Considerations and Drawbacks:

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.