Technical interview Q&A plus 100+ career & HR questions—notice period, salary negotiation, resume, LinkedIn, freelancing, AI careers, and behavioral interviews with detailed, real-world answers.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
It calls GatherIngredients, Prepare, CookMethod, and Serve in a fixed
order. The first three steps are abstract and need to be implemented by
subclasses, while the Serve method is concrete and always works the same
way.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
is shared across multiple instances (the character symbol, in this case), and it
provides a Display method to show the character's symbol at a particular
coordinate.
public class Character
{
private readonly char _symbol;
public Character(char symbol) => _symbol = symbol;
public void Display(int x, int y) =>Console.WriteLine($"Character: {_symbol} at ({x}, {y})");
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
is shared across all instances. This makes it an ideal candidate for the
Flyweight Pattern because multiple characters (e.g., 'H', 'e', 'l') may appear
many times in the same text, but they only need one Character object for
the symbol.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
performed on the IShoppingCartElement objects. In this case, the visitor defines
Visit(Book book) and Visit(Fruit fruit) methods for different product
types.
public interface IShoppingCartVisitor
{void Visit(Book book);
void Visit(Fruit fruit);
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
scores). Using the Flyweight Pattern, you can optimize memory usage by
reusing the same Character objects for common letters or symbols, rather
than creating a new object for each instance.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The pattern enforces a rigid structure for the algorithm, meaning that subclasses cannot change the overall order or flow of steps. If you need to adjust the structure of the algorithm, it may require changes to the base class.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
CharacterFactory can implement cache management strategies like
LRU (Least Recently Used) or FIFO (First In, First Out) to evict older or
unused objects and maintain memory efficiency.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The IExpression interface defines the contract for all expressions in the grammar, allowing them to be interpreted (evaluated). Every class that implements this interface will provide its own interpretation logic.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
some of the steps need to be customized for different situations. For example,
when creating frameworks for processes like data parsing, game initialization,
or file handling.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The common structure of the algorithm is defined in the abstract class, so subclasses don't have to repeat the same steps. Only the details of specific steps need to be implemented in each subclass.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
use based on external configurations, like settings or environment variables.
This would enable the system to switch between different logging
mechanisms or database connections without recompiling the application.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The Interpreter Pattern is ideal for scenarios where the grammar is complex and subject to change. By defining expressions as objects, it’s easy to extend or modify the grammar without affecting other parts of the system.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
skeleton. It delegates the implementation of specific steps (GatherIngredients,
Prepare, and CookMethod) to subclasses by making them abstract. The Serve
method is concrete and always executes the same way for all recipes.
public abstract class Recipe
{
public void Cook()
{GatherIngredients();
Prepare();
CookMethod();
Serve();
}protected abstract void GatherIngredients();
protected abstract void Prepare();
protected abstract void CookMethod();
private void Serve() => Console.WriteLine("Serving the dish.");
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
expressions like 5 + 3 * 2 can leverage the Interpreter Pattern to handle
different operators and operands. Each part of the expression (numbers,
operators) is represented as an object that can be evaluated.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: For more complex grammars, the interpreter may become inefficient. Optimizations such as memoization (caching results) can be used to avoid redundant evaluations, particularly for recursive expressions.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: Use the Strategy Pattern when you have multiple algorithms for a specific task and want to switch between them easily (e.g., sorting, encryption, compression).
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The IIterator<T> interface defines the contract for all iterators. It ensures that all iterators implement the basic functionality of checking for the next element (HasNext()) and returning the next element (Next()).
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
code more flexible. You can add new sorting algorithms without changing the
context class, thus adhering to the Open/Closed Principle (open for
extension, closed for modification).
Gang of Four Patterns Design Patterns in C# · GoF Patterns
swapped in and out. The context (Sorter) doesn't need to know the specifics
of the algorithm; it only knows that it can call the Sort method on any
strategy that implements this interface.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
llow users to redo the previous undo operation.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: ICoffee defines the basic methods that any coffee type must implement. This allows the decorators to work with any class that implements this interface, providing flexibility to decorate any coffee object.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
mplifier:
public class Amplifier
{
public void On() => Console.WriteLine("Amplifier is on.");
public void Off() => Console.WriteLine("Amplifier is off.");
}DVDPlayer:
public class DVDPlayer
{
public void Play(string movie) => Console.WriteLine($"Playing{movie}.");
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
customers can customize their coffee with various add-ons (milk, sugar,
whipped cream, flavor syrups, etc.). Each add-on is a decorator that adds a
cost and modifies the description of the order without modifying the core
coffee object.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: nd Description() that every coffee component will implement. public interface ICoffee { double Cost(); string Description(); }
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: You could introduce more decorators, such as WhippedCreamDecorator, ChocolateDecorator, or CaramelDecorator, for a richer coffee experience.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: nd subdirectories, and those subdirectories can contain further files or subdirectories. The Composite Pattern allows for easy traversal and management of this hierarchical structure.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: These classes encapsulate the complex functionality of the system. For instance, turning the amplifier on or off, or playing a movie in the DVD player. These actions are usually cumbersome for the user to manage directly.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: By providing a unified interface, the Facade Pattern simplifies the interaction with complex subsystems. The user only needs to interact with a few high-level methods, making the system easier to use.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
strategies must implement. This allows clients (in this case, the Sorter class) to
work with any strategy that implements this interface.
public interface ISortStrategy
{void Sort(List<int> list);
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
player, and projector can be tedious. A Facade Pattern can simplify this into
a single button or command (like WatchMovie()), where the user only
needs to press one button to turn everything on.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: dd text to the document as an object. This allows for parameterization of the command with different requests (e.g., adding different text) while decoupling the sender (the TextEditor) from the receiver (Document).
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: If the home theater system grows, you can easily add more components (e.g., projector, lights, sound system) to the facade without modifying the client code. This extends the flexibility of the facade as the system becomes more complex.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: This interface defines the common method Log that will be implemented by all types of loggers (e.g., file, console). public interface ILogger void Log(string message);
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: pplication does not need to know about the specific UI components; it simply relies on the factory to provide them.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The LoggerFactory class defines a factory method CreateLogger that returns an ILogger object. This is a generic interface for creating various logger types without specifying the concrete class directly.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: While adding new operations is easy, adding new element types can be challenging. Every new element requires modifying all existing visitor classes to implement the new Visit method.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
different log outputs. For example, a logging framework can provide loggers
that write to the console, files, databases, or cloud services, with the user
choosing the appropriate logger type via a factory.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
instance of it throughout the application.
ensuring that it's only created once and then reused.
public class ConfigurationManager
{
private static ConfigurationManager _instance;
private static readonly object _lock = new object(); // Lock
for thread safety
private ConfigurationManager() { } // Private constructor toprevent instantiation
public static ConfigurationManager Instance
{get
{lock (_lock) // Ensure thread safety
{
return _instance ??= new ConfigurationManager(); //Lazy initialization
}
}
}
public string GetSetting(string key) => "some value"; // Examplemethod to return a setting
}directly. This ensures that the class cannot be instantiated more than once.
ConfigurationManager. It uses lazy initialization to create the instance
only when it's first needed.
thread-safe, preventing multiple threads from creating multiple instances at
the same time in a multithreaded environment.
ensuring that the instance is created only once and reused thereafter.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
types like buttons and checkboxes. This ensures that every concrete factory
will implement the same methods, but each will provide platform-specific
products.
public interface IUIFactory
{IButton CreateButton();
ICheckbox CreateCheckbox();
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
observers. The subject manages a list of observers and notifies them when there is
an update.
public interface INewsPublisher
Follow:
void Subscribe(IObserver observer);
void Unsubscribe(IObserver observer);
void Notify(string news);
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: When there is a need to store and share global configuration settings across the application (e.g., database connection strings, file paths, API keys).
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The NewsPublisher class acts as the subject in the Observer Pattern. It maintains a list of IObserver instances (subscribers) and provides methods to add (Subscribe), remove (Unsubscribe), and notify them (Notify).
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
provides a global access point to that instance. This is especially useful when
managing resources that should be shared across the application, such as
configuration settings, logging, or database connections.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: If the object being cloned is very large or complex, cloning might introduce performance overhead. You should evaluate the cost-benefit ratio of cloning versus object creation. Real-Time Use Case Examples:
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: A news website where multiple users subscribe to receive notifications when new articles or breaking news are published.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The Singleton class (ConfigurationManager) only allows one instance to be created. The instance is stored in the static _instance field, ensuring that only one object exists.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
to undo the most recent changes. Each time the user types, the editor saves
a snapshot of the text as a Memento. Pressing Ctrl + Z restores the text to its
previous state.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: This interface defines the Clone() method that will be used to create a copy of an object. Any class that needs to be cloned must implement this interface.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: A virtual proxy can be used to load large images or videos on-demand, especially when dealing with high-resolution media files that could be costly to load upfront.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: Cloning objects is often more efficient than creating new ones from scratch, especially when the object is complex or expensive to create. This can be particularly useful in performance-sensitive applications like games or simulations.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
properties are copied. If the object contains references to other objects (e.g.,
arrays, lists), you may need to implement deep cloning to ensure that
referenced objects are also cloned, not just referenced.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: Used to delay the creation or initialization of an expensive object until it is actually needed, like the ProxyImage example above.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: This is the common interface that both the real object (RealImage) and the proxy object (ProxyImage) implement. It defines the method Display() that both concrete classes must implement. public interface IImage { void Display(); }
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The client interacts with the proxy (ProxyImage), which implements the same interface (IImage) as the real subject (RealImage).
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The instance is created only when needed, reducing the overhead of initialization when the object is not used. This ensures that resources are used efficiently.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: A classic example of the Mediator Pattern is a chat application, where the mediator is responsible for sending messages between users. It ensures that messages are routed correctly without the users needing to know about each other.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
customer lists, or any other collection where you need to iterate over items
sequentially. For instance, in an e-commerce application, you might use an
iterator to list products, iterate through available categories, or paginate
results.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The State Pattern introduces a separate class for each state, which can lead to an increase in the number of classes in the system. For systems with many states, this can cause complexity.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The Iterator Pattern can be extended to support reverse iteration or provide additional functionality like removing items during iteration.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
■ SendMessage(string message, User user): Sends a
message from a user to all other registered users.
■ RegisterUser(User user): Registers users with the mediator so
they can send and receive messages.
public interface IChatMediator
{void SendMessage(string message, User user);
void RegisterUser(User user);
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: When you have an object that can be in multiple predefined states and its behavior depends on the current state (e.g., traffic lights, order processing systems).
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
of all users and broadcasts messages to all other users when one user sends
a message.
loose coupling.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
observers. The subject does not know about the specific observers, only that
they implement the IObserver interface. This makes the system more
flexible and easier to maintain.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The ITrafficLightState interface defines a method (Change) that allows the traffic light to transition between states (Red, Green, Yellow).
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The elements in the object structure (Book, Fruit) implement the Accept method, which is designed to accept a visitor. This method typically calls the appropriate visit method (Visit(Book book) or Visit(Fruit fruit)) on the visitor.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
state to transition to another state. The method accepts a TrafficLight object as
a parameter to facilitate the state change.
public interface ITrafficLightState
void Change(TrafficLight light);
the specific behavior of the traffic light for that state.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
critical part of the system. If the mediator fails, the entire communication
system breaks down. This could be mitigated by introducing fault tolerance or
redundancy in the mediator.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
the state (the text content) and doesn’t allow direct manipulation of that state.
public class TextMemento
public string Text { get; }
public TextMemento(string text) => Text = text;
Follow:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The TextEditor is the originator of the state. It holds the text that changes over time and can save and restore its state using mementos.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The Singleton can act as a global variable, which may make it harder to track state changes and can lead to issues with dependencies.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
in the Memento object, and the TextEditor is not exposed to direct
manipulation of its internal state. The only way to change or access the state
is through well-defined methods (Save and Restore).
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: If the object’s state is large or changes frequently, the Memento Pattern can result in significant memory usage, as you need to store many copies of the state (each memento).
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
thread safety without locking. However, it may have a slight performance
overhead due to the instance being created regardless of whether it is
needed.
public class Singleton
{
private static readonly Singleton _instance = new Singleton();
private Singleton() { }
public static Singleton Instance => _instance;
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: Both File and Directory implement the IFileSystemComponent interface, which defines the common method ShowInfo(). This allows us to treat both files and directories uniformly.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
file systems. A file system is inherently hierarchical: directories contain files
and subdirectories, and those subdirectories can contain further files or
subdirectories. The Composite Pattern allows for easy traversal and
management of this hierarchical structure.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: n update. public interface INewsPublisher { void Subscribe(IObserver observer); void Unsubscribe(IObserver observer); void Notify(string news); }
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
handling log messages. It includes a reference to the next logger in the chain
(NextLogger) and a method (LogMessage) to process a message. If the
current handler cannot handle the message, it passes the request along to
the next handler in the chain.
public abstract class Logger
{protected Logger NextLogger;
public void SetNext(Logger nextLogger) => NextLogger =nextLogger;
public void LogMessage(string message, LogLevel level)
{
if (CanHandle(level))
{Handle(message);
}else
{NextLogger?.LogMessage(message, level);
}
}protected abstract bool CanHandle(LogLevel level);
protected abstract void Handle(string message);
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
lgorithms is small, using the Strategy Pattern might be over-engineering.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
nd makes the system easier to maintain.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
IDrawingAPI and delegates the drawing task to it. It defines the common
interface Draw() that all shapes must implement.
public abstract class Shape
{protected IDrawingAPI _drawingAPI;
protected Shape(IDrawingAPI drawingAPI) => _drawingAPI =
drawingAPI;
public abstract void Draw();
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: Both files and directories are treated the same, as they implement the IFileSystemComponent interface. This makes it easier to manage a mixed structure of individual and composite objects.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The sender (the TextEditor) is decoupled from the receiver (Document). The TextEditor only knows how to invoke commands but does not need to understand the details of the operations (e.g., how the text is added or removed).
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: rrays, lists), you may need to implement deep cloning to ensure that referenced objects are also cloned, not just referenced.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: nd subject to change. By defining expressions as objects, it’s easy to extend or modify the grammar without affecting other parts of the system.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The Adapter pattern allows you to integrate existing systems or third-party libraries without modifying their code. It enables compatibility between incompatible interfaces.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: message. This keeps the users from directly knowing about each other, thus promoting loose coupling.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The Bridge pattern allows you to modify the abstraction (shapes) and the implementation (drawing API) independently, providing a cleaner and more modular design.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
ttributes (e.g., health, attack power) to create new characters or enemies.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
dditional functionality like removing items during iteration.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
parameter to facilitate the state change.
public interface ITrafficLightState
{void Change(TrafficLight light);
}the specific behavior of the traffic light for that state.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Dough, Sauce, and a list of Toppings. The ToString() method is
overridden to provide a string representation of the pizza.
public class Pizza
{
public string Dough { get; set; }
public string Sauce { get; set; }
public List<string> Toppings { get; } = new List<string>();
public override string ToString() =>$"Pizza with {Dough} dough, {Sauce} sauce and toppings:
{string.Join(", ", Toppings)}";
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: You can extend the system by adding redo functionality. After an undo operation, you could store the undone command in a separate stack and allow users to redo the previous undo operation.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The Builder Pattern separates the construction of a complex object from its representation. You can change the construction process without changing the way the object is represented or structured.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: This is the base interface that defines a common method ShowInfo() that will be implemented by both leaf and composite components. public interface IFileSystemComponent { void ShowInfo(); }
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
ctually needed, like the ProxyImage example above.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The ITarget interface defines the expected interface that the client will use. It has a method Request() that the client expects to call. public interface ITarget { void Request(); }
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: single button or command (like WatchMovie()), where the user only needs to press one button to turn everything on.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The ICommand interface defines two methods: ■ Execute(): Executes the command. ■ Undo(): Reverts the command if the user wishes to undo the action. public interface ICommand { void Execute(); void Undo(); }
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: This is the base interface that defines the common methods for the Cost() and Description() that every coffee component will implement. public interface ICoffee double Cost(); string Description();
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
perform operations on them that vary.
complex hierarchy (like a shopping cart with various types of products), and
you need to add new behaviors without changing the objects themselves.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: ll types of loggers (e.g., file, console). public interface ILogger { void Log(string message); }
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: ppropriate visit method (Visit(Book book) or Visit(Fruit fruit)) on the visitor.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The Chain of Responsibility allows handlers to be decoupled from the client code. The client doesn’t need to know which handler will process the request, only that the request will eventually be processed by some handler in the chain.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
djust the structure of the algorithm, it may require changes to the base class.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: snapshot of the text as a Memento. Pressing Ctrl + Z restores the text to its previous state.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
SetNext() on the infoLogger and passing it the errorLogger. This
ensures that the InfoLogger will process log messages with the Info level,
while the ErrorLogger will handle Error level messages.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
add text to the document as an object. This allows for parameterization of the
command with different requests (e.g., adding different text) while decoupling
the sender (the TextEditor) from the receiver (Document).
Follow:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The Directory class currently only has an Add() method for adding components. It could be improved by adding a Remove() method to allow for the dynamic removal of files or subdirectories.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: By using the builder, you can add more ingredients or properties in a fluent manner (i.e., chaining method calls), which can make the code cleaner and more readable.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
mplifier or DVDPlayer, reducing tight coupling between them.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The client code doesn't need to know the internal implementation of the collection (e.g., whether it's a list or a tree). It can use the iterator interface to access the elements sequentially, leading to cleaner and more maintainable code.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: Each state (Red, Green, Yellow) implements the Change method differently, providing specific behaviors for each state and defining how the transition to the next state occurs.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
communication between different planes and the control tower. The control
tower acts as the mediator, relaying necessary information and ensuring that
planes don’t directly communicate with each other, reducing the chances of
collision or confusion.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
concrete class provides its own implementation of the Sort method.
public class BubbleSort : ISortStrategy
{
public void Sort(List<int> list)
{Console.WriteLine("Sorting using Bubble Sort");
// Implement the bubble sort algorithm here
}
}public class QuickSort : ISortStrategy
{
public void Sort(List<int> list)
{Console.WriteLine("Sorting using Quick Sort");
// Implement the quicksort algorithm here
}
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The chain of responsibility can be dynamically configured by adding or removing handlers at runtime. This makes it flexible to change the behavior of the system without modifying the request-handling code.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: When an object’s behavior changes significantly with each state, and transitioning between states needs to be managed cleanly and without complex conditionals.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: For multi-threaded environments, ensuring safe iteration over collections might require synchronized access to the collection. The iterator can be modified to handle concurrency issues.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: Each user communicates with the mediator, not with other users directly. When a user sends a message, the mediator handles the responsibility of broadcasting that message to other users.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: In graphical user interfaces (GUIs), iterating through a complex hierarchical menu structure can be achieved using the Iterator Pattern. Each menu can be an aggregate, and each menu item can be iterated over using an iterator.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
makes it easier to modify or extend how messages are passed. For example,
adding new features like message filtering or logging can be done in the
mediator without affecting the users.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: If the state machine is simple, using the State Pattern might be overkill. Sometimes, basic conditionals (e.g., if/else) might suffice, and the pattern may add unnecessary complexity.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The object’s behavior changes dynamically as it transitions between states. The client code doesn't need to manage state transitions; it's handled by the state objects themselves.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: When a log message is passed to the infoLogger, it checks if it can handle the message. If the message level is Info, it processes the message. If not, it passes the request to the next handler (errorLogger).
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: In large systems, managing many observers and keeping track of the relationships between subjects and observers can introduce complexity. It's important to manage subscription and unsubscription carefully to avoid memory leaks.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The proxy controls access to the real object, initializing it only when needed. This is known as lazy loading. For example, the large image is only loaded when the client requests it for the first time.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: the existing classes. This pattern allows you to keep your object classes stable and add functionality through new visitor classes.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: A proxy can control access to the real object, ensuring that actions like creation, deletion, or other operations are performed only when appropriate.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
object that we want to control access to. It contains the logic to load and display the
image.
public class RealImage : IImage
{
private readonly string _filename;
public RealImage(string filename) => _filename = filename;
public void Display() => Console.WriteLine($"Displaying{_filename}");
}This behavior can be resource-intensive, especially if the image is large.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: In graphical user interface (GUI) applications, prototypes could be used to clone UI components (e.g., buttons, text fields) with predefined styles or settings.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: Used to represent an object that is located on a different machine (e.g., over a network), and it handles communication between the client and the remote object.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The Prototype Pattern is best suited for cases where cloning makes sense. If object creation doesn't involve copying or if it requires significant setup, the pattern might not be appropriate.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
on the state of existing ones, without knowing the specific class of the object
you're cloning. This can be useful for creating different variations of an object
without manually specifying each one.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The pattern separates the algorithm (e.g., calculating total with discounts) from the objects on which it operates. This makes the object structure (elements) cleaner, as they are not responsible for the business logic.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: New platforms can be added by creating new concrete factories. The client code doesn’t need to change; just use the new factory.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The GameCharacter class is a concrete implementation of the ICloneable interface. It implements the Clone() method, which creates a new GameCharacter object with the same properties as the original.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: A remote proxy can be used to handle communication between a client and a remote server, managing the complexities of network protocols and making it seem as if the remote object is local.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: A weather station where multiple devices (like smartphones or weather dashboards) subscribe to receive updates on temperature, humidity, and other weather conditions.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The Instance property provides global access to the single instance of the class. This property ensures that no new instances are created, and the same instance is returned every time.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: For large systems with a high number of components, the mediator itself might become complex and difficult to maintain. It's essential to manage its complexity to avoid it becoming a bottleneck or overly complicated.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: Observers can be added or removed at runtime, allowing dynamic changes to the system based on user actions or conditions.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The NewsSubscriber class represents an observer. Each subscriber listens to the publisher and updates its state (in this case, by printing the news) when the publisher notifies them.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: When there’s a need for a global logging mechanism where all parts of the application log to the same destination (e.g., a log file or a central logging service). Follow:
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: This interface defines the Update() method, which will be implemented by concrete observers. Each observer will receive updates from the subject when the state changes. public interface IObserver { void Update(string news); }
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
chieved by selecting different algorithms.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: lgorithm. These algorithms can be tested, optimized, or replaced without ffecting the context or the other algorithms.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: In video games, the Memento Pattern can be used to save the game state (such as player position, inventory, etc.) so that the player can undo or restore their progress to a previous save point.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: You can easily add new shapes or drawing styles without changing existing classes. This is particularly useful in scenarios where the number of shapes or rendering methods can grow over time.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The Memento must contain only the necessary state of the object. If the state is complex (e.g., involving many interdependencies), it may be difficult to capture it in a Memento without violating encapsulation or increasing complexity.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The pattern is ideal for implementing undo functionality because it allows the system to keep a history of states and revert back to any previous state.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The TextMemento captures the state of the TextEditor object (in this case, the text content). It doesn't expose any internal details of the TextEditor, preserving encapsulation.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: Since the Singleton class is globally accessible, it can be difficult to mock or replace it in unit tests, leading to potential challenges in testing.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
actual state (the text) and provides methods to change the state, save the current
state to a Memento, and restore a previous state from a Memento.
editor.
public class TextEditor
private string _text;
public void Write(string text) => _text = text;
public TextMemento Save() => new TextMemento(_text);
public void Restore(TextMemento memento) => _text =
memento.Text;
public override string ToString() => _text;
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: pplication log to the same destination (e.g., a log file or a central logging service).
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
processes. For example, factories might create loggers with specific
configurations, such as log levels (e.g., INFO, ERROR, DEBUG) or custom
output formats, allowing even more flexibility in how objects are created.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
subclasses with different variations of steps, the code can become harder to
manage and maintain.
Conclusion:
The Template Method Pattern is a powerful way to define the structure of an algorithm
while allowing subclasses to customize specific steps. It's ideal when you want to reuse a
Follow:
common workflow while providing flexibility to modify particular steps. It is frequently used in
frameworks and libraries, where the overall process must remain consistent, but certain
aspects can be customized or extended. This pattern ensures that the general algorithm
remains the same while giving subclasses the freedom to tailor specific steps to their needs.
Visitor Pattern: Adding New Operations Without Modifying Object
Structures
Definition:
The Visitor Pattern separates an algorithm from the object structure on which it operates. It
allows you to add new operations to existing object structures without modifying the
structures themselves. Instead of embedding operations directly into the objects, you define
a visitor that knows how to operate on each type of object in the structure.
Use Case:
A typical use case for the Visitor Pattern is calculating taxes or discounts for different
product types in a shopping cart. Each product type (e.g., books, fruits, electronics) might
require different calculations, and the Visitor Pattern allows you to easily add new types of
operations (e.g., tax calculation, discount application) without altering the objects in the
shopping cart.
Code Breakdown:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
repeated elements (e.g., the same type of tiles or blocks). Using the Flyweight
Pattern, you can create a single object for each tile type and reuse it across
multiple grid locations, saving memory.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: For complex operations, you might want to implement batch command execution. Multiple commands can be grouped together, and executing or undoing the entire batch can be done in a single operation.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: In scenarios with many similar objects, the pattern helps minimize the overhead of object creation and garbage collection. This is particularly beneficial in performance-sensitive applications like games or graphical user interfaces.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
ccess the elements sequentially, leading to cleaner and more maintainable code.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
the element to accept a visitor. Each element (like Book, Fruit) will implement this
interface to allow a visitor to operate on it.
public interface IShoppingCartElement
{void Accept(IShoppingCartVisitor visitor);
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
high-level methods: WatchMovie() and EndMovie(). These methods
internally call the relevant methods on the subsystem components (e.g., On()
for the amplifier, Play() for the DVD player). The user doesn’t need to dealwith the details of how the components interact or manage their state.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
ny child components but implements the ShowInfo() method to display its name.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
multiple Character objects to save memory.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
n iterator for that collection.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The visitor interface defines a visit method for each type of element. Each Visit method encapsulates the operation to be performed on the corresponding element.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
ctual state (the text) and provides methods to change the state, save the current
state to a Memento, and restore a previous state from a Memento.
editor.
public class TextEditor
{
private string _text;
public void Write(string text) => _text = text;
public TextMemento Save() => new TextMemento(_text);
public void Restore(TextMemento memento) => _text =memento.Text;
public override string ToString() => _text;
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The pattern decouples the algorithm from the context that uses it. This means you can modify or extend the sorting algorithms without affecting the code that uses them.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
ctions without needing to track individual changes manually.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: You can add new operations (like taxes or shipping costs) by simply creating new visitor classes without needing to modify the existing elements (Book, Fruit). This makes it easier to extend functionality in the future.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: When managing database connections, ensuring that only one connection to the database is created and reused throughout the application. Types of Singleton Implementation:
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
group of shapes). Each shape (a circle, a rectangle, etc.) can be treated as
an individual object, while a group of shapes can be treated as a composite
object. The Composite Pattern makes it easier to manage complex graphical
objects that contain simple shapes.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: In e-commerce applications, a Facade can unify processes like checking out, payment, inventory management, and shipping. A single checkout process could internally handle all these complex operations.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The pattern introduces additional classes (visitors), which can make the system more complex, especially when the number of elements and visitors increases.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The concrete factories extend LoggerFactory and override the CreateLogger method to create specific logger types, such as FileLogger or ConsoleLogger. The subclass provides the implementation details for object creation.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
or a Shortcut class) to the system without affecting the existing code. As
long as the new class implements the IFileSystemComponent interface, it
will fit seamlessly into the existing structure.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
ccess to the shared flyweight objects.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: In a more advanced scenario, you could make the methods in the facade asynchronous, allowing components (like the DVD player) to load or process content in the background, improving user experience.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
of the steps defined in the abstract Recipe class. The steps like gathering
ingredients, preparing, and cooking are all tailored to pasta.
public class PastaRecipe : Recipe
{protected override void GatherIngredients()
{Console.WriteLine("Gathering pasta, sauce, and cheese.");
}protected override void Prepare()
{Console.WriteLine("Boiling pasta and preparing sauce.");
}protected override void CookMethod()
{Console.WriteLine("Cooking pasta with sauce.");
}
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: When an object's behavior changes dynamically, and the change can be achieved by selecting different algorithms.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: synchronous, allowing components (like the DVD player) to load or process content in the background, improving user experience.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The current implementation doesn't handle errors (e.g., invalid expressions). It’s advisable to add error-checking mechanisms (e.g., checking for division by zero, invalid operators, etc.) to make the interpreter more robust.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
decorate a button with additional features (like borders, shadows, or icons)
dynamically. You don't need to subclass the button every time you want to
add new functionality.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: n individual object, while a group of shapes can be treated as a composite object. The Composite Pattern makes it easier to manage complex graphical objects that contain simple shapes.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: Without the strategy pattern, you might need to use complex conditionals (like if-else or switch) to determine which algorithm to use. The strategy pattern eliminates this by encapsulating the algorithm in separate classes.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
in the number of classes in your application, which might not be desirable in
simpler systems.
Follow:
Conclusion:
The Strategy Pattern is an excellent choice for applications that need to support multiple
interchangeable algorithms. By encapsulating algorithms in separate strategy classes and
delegating the task to the context, you avoid conditional statements and make your code
more flexible, maintainable, and extensible. It's especially useful in scenarios like sorting,
different payment methods, or compression algorithms where the behavior of the object
varies based on the strategy being used.
Template Method Pattern: Defining the Skeleton of an Algorithm
Definition:
The Template Method Pattern defines the skeleton of an algorithm in a method, deferring
some steps to subclasses. This pattern lets subclasses redefine certain steps of an
algorithm without changing the overall structure of the algorithm. Essentially, the Template
Method sets the "template" or the common sequence of steps, while allowing subclasses to
provide specific implementations for some of the steps.
Use Case:
A typical use case for the Template Method Pattern is creating a framework for a
cooking recipe where every recipe follows a similar structure (e.g., gather ingredients,
prepare, cook, and serve), but the actual details of each step can vary depending on the
type of recipe.
Code Breakdown:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
The Interpreter Pattern can be used to build a query parser that interprets
the structure and conditions in the query, eventually transforming them into an
executable SQL statement.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: dding new features like message filtering or logging can be done in the mediator without affecting the users.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The pattern allows for recursive evaluation of expressions. Complex expressions can be broken down into simpler expressions, and the results of those can be combined to form more complex evaluations.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The TextEditor is responsible for executing the command. It calls the Execute() method of the command, which in turn delegates the action to the Document class (the receiver).
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: Subclasses, like PastaRecipe, implement the GatherIngredients, Prepare, and CookMethod methods. These methods contain the specific details of the recipe, such as the ingredients, preparation steps, and cooking process.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: If the coffee is highly customizable, you could add additional logic to the Cost() method to calculate discounts or offer combo prices (e.g., a discount when multiple ingredients are added).
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The Command Pattern is particularly useful for implementing undo/redo functionality. The stack of executed commands allows for easy reversion of actions without needing to track individual changes manually.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: If you are creating a framework where clients need to customize only certain steps of a predefined process, the Template Method Pattern allows them to override the necessary methods while ensuring the common workflow remains intact.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
should be taken to ensure thread safety. The flyweight factory could use a
concurrent dictionary or apply locking mechanisms to prevent concurrent
access to the shared flyweight objects.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: In addition to ShowInfo(), you could add other methods to traverse the structure in different ways, such as depth-first or breadth-first traversal.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
nd overriding the abstract steps. Benefits of the Template Method Pattern:
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
handler in the chain (i.e., by calling NextLogger?.LogMessage(...)).
This continues until a handler processes the message or the chain is
exhausted.
Key Benefits of the Chain of Responsibility Pattern:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The Sorter class is the context. It doesn't perform the sorting itself but delegates it to whatever strategy is currently set. The client can change the strategy dynamically, making the system flexible and extensible.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: in an object structure. The visitor pattern is particularly useful when operations are performed on different types of objects, and each type requires specific behavior. Drawbacks of the Visitor Pattern:
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: nd calls its Undo() method, which reverts the action performed by the command (removes the last added text). Key Benefits of the Command Pattern:
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: bstract class. Additionally, the order and structure of steps remain consistent cross different subclasses.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: re abstracted into a simplified process, allowing users to perform transactions without understanding the underlying complexities.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
ltering or subclassing the core class.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: llow for customization in certain steps. For example, when implementing generic frameworks for various kinds of workflows, like validation, report generation, or business processes. Drawbacks of the Template Method Pattern:
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: nd ConsoleLogger. These classes define how the log message will be handled, either by writing to a file or outputting to the console.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: By avoiding the creation of heavy objects until they're needed, proxies can improve the performance of applications, especially in cases of large datasets or expensive operations (like network calls or file loading).
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: Controls access to a resource by adding authorization checks before access is allowed. It can act as a gatekeeper for resources.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
bout whether the child is a file or a subdirectory.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
re logged (either to a file or the console).
FileLogger:
public class FileLogger : ILogger
{
public void Log(string message) => Console.WriteLine($"Loggingto file: {message}");
}ConsoleLogger:
public class ConsoleLogger : ILogger
{
public void Log(string message) => Console.WriteLine($"Loggingto console: {message}");
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: nd maintain since objects can rely on the Singleton without explicitly passing it.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
SetStrategy that allows clients to set the desired sorting strategy dynamically. The
Sort method delegates the sorting task to the currently set strategy.
public class Sorter
{
private ISortStrategy _strategy;
public void SetStrategy(ISortStrategy strategy) => _strategy =strategy;
public void Sort(List<int> list) => _strategy.Sort(list);
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
lso create a dependency on the mediator itself. Over-reliance on the
mediator can lead to issues if the mediator needs to change.
Visual Diagram:
+----------------------+
| IChatMediator |
| (Mediator Interface) |
+----------------------+
+------------------------------------+
| |
+------------------+ +------------------+
| ChatMediator | | User |
| (Concrete Mediator) | (Colleague) |
+------------------+ +------------------+
| |
+-------------------+ +------------------+
| RegisterUser(User)| | Send(string) |
| SendMessage(...) | | Receive(string) |
+-------------------+ +------------------+
Conclusion:
The Mediator Pattern is an excellent solution for managing complex interactions between
objects in a system, particularly when those objects don’t need to know about each other
directly. It reduces dependencies, simplifies communication, and centralizes control, making
it easier to manage interactions. However, it should be used judiciously, as a poorly
implemented mediator can become a bottleneck or a single point of failure in the system.
Memento Pattern: Real-Time Example - Undo Feature in a Text Editor
Definition:
The Memento Pattern is used to capture and externalize an object's internal state without
violating encapsulation. This allows the object to be restored to this state later. It’s commonly
used in situations where an object's state changes over time and you may need to revert to
previous states, such as an undo feature.
Use Case:
The Memento Pattern is widely used in scenarios where you want to implement an undo or
restore functionality, such as in a text editor. In this case, the pattern allows the editor to
save versions of the text and restore them when the user requests an undo.
Code Breakdown:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
track down state-related bugs, especially in more complex systems.
Conclusion:
The State Pattern is an excellent choice when an object's behavior is contingent on its state,
and you need to manage the transitions between states in a clean, maintainable way. It's
ideal for situations like traffic lights, game characters, or process workflows, where the object
changes its behavior dynamically. By encapsulating the behavior of each state in separate
classes, you can avoid complex conditionals and promote better code organization and
flexibility.
Strategy Pattern: Encapsulating Algorithms for Interchangeability
Definition:
The Strategy Pattern defines a family of algorithms, encapsulates each one, and makes
them interchangeable. This pattern allows an algorithm to vary independently from clients
Follow:
that use it. It is particularly useful when you want to choose between different algorithms
dynamically at runtime, without altering the code that uses them.
Use Case:
A typical use case for the Strategy Pattern is sorting. Instead of implementing multiple
sorting algorithms directly in the client code, you can use the strategy pattern to choose
which sorting algorithm to apply (e.g., QuickSort, BubbleSort, MergeSort) depending on the
context or runtime conditions.
Code Breakdown:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: ctions. The TextEditor focuses only on managing and modifying the content, nd the Memento class simply holds the state. This separation of concerns makes the system more modular and easier to maintain.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: nd labels. For example, clicking a button might update a text field, and the mediator ensures that these updates are propagated correctly.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: If you find yourself writing long if/else or switch statements to select algorithms, the Strategy Pattern can help simplify and modularize your code.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The pattern eliminates the need for complex conditional logic (e.g., if or switch statements) in the context class. Each state class defines its own behavior, and the context class only delegates the work.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
the Cook method) while customizing certain steps in different subclasses.
This makes it easy to add new recipes by simply extending the Recipe class
and overriding the abstract steps.
Benefits of the Template Method Pattern:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
allow for customization in certain steps. For example, when implementing
generic frameworks for various kinds of workflows, like validation, report
generation, or business processes.
Drawbacks of the Template Method Pattern:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The TrafficLight class holds the current state and delegates behavior to the state object. The context can change its state by calling the SetState method, which updates the current state reference.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: It can lead to hidden dependencies, making the code harder to understand and maintain since objects can rely on the Singleton without explicitly passing it.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
IShoppingCartElement interface. Each class has a price and the Accept
method that allows the visitor to perform an operation on it.
public class Book : IShoppingCartElement
{
public double Price { get; }
public Book(double price) => Price = price;
public void Accept(IShoppingCartVisitor visitor) =>visitor.Visit(this);
}
public class Fruit : IShoppingCartElement
{
public double Price { get; }
public Fruit(double price) => Price = price;
public void Accept(IShoppingCartVisitor visitor) =>visitor.Visit(this);
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: In web applications or forms, the Memento Pattern can be used to save the state of form inputs at various stages. This allows users to undo their changes or restore the form to a previous valid state.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
only once, even when multiple threads access the Instance property
concurrently. This is important in multi-threaded applications where race
conditions could otherwise cause multiple instances to be created.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: As shown in the example, lazy initialization is used to create the instance only when needed, with thread safety ensured by locking.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
nd you need to manage the transitions between states in a clean, maintainable way. It's
ideal for situations like traffic lights, game characters, or process workflows, where the object
changes its behavior dynamically. By encapsulating the behavior of each state in separate
classes, you can avoid complex conditionals and promote better code organization andflexibility.
Strategy Pattern: Encapsulating Algorithms for Interchangeability
Definition:
The Strategy Pattern defines a family of algorithms, encapsulates each one, and makes
them interchangeable. This pattern allows an algorithm to vary independently from clients
that use it. It is particularly useful when you want to choose between different algorithms
dynamically at runtime, without altering the code that uses them.
Use Case:
typical use case for the Strategy Pattern is sorting. Instead of implementing multiple
sorting algorithms directly in the client code, you can use the strategy pattern to choose
which sorting algorithm to apply (e.g., QuickSort, BubbleSort, MergeSort) depending on the
context or runtime conditions.
Code Breakdown:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
nd the interpreter evaluates these statements to execute the program.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The concrete visitor implements the visitor interface and defines the specific logic for each element. In this case, the ShoppingCart visitor calculates the total price, applying discounts where necessary.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: Operations are centralized in the visitor, which makes it easier to manage complex operations. If multiple operations are performed on the same structure, they can be handled by different visitors.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: For managing global caching mechanisms, where there’s a single shared cache used by the entire application.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
the element classes, you still need to ensure that visitors and elements are
compatible. This can lead to some level of coupling between visitors and
element classes.
Conclusion:
The Visitor Pattern is an excellent choice when you need to separate the operations
performed on a structure from the structure itself, particularly in cases where the structure is
complex and may evolve over time. It allows you to introduce new operations without
modifying existing object classes. However, it can become difficult to manage when you
need to add new element types, as every visitor must be updated to handle the new type.
This pattern is often used in scenarios like processing different kinds of products in a
shopping cart, applying various types of discounts or taxes, or performing different
transformations on elements of a composite structure.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
lgorithms, the Strategy Pattern can help simplify and modularize your code.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
dapted to the same target interface. Each adapter can map different
methods and behaviors from the adaptees.
complex systems. Each adapter could transform data in a specific way to fit
the final target.
dapter respects type constraints and offers clear type mappings between the
daptee and the target.
Real-Time Use Case Example:
The Adapter Pattern is often used when integrating third-party libraries into existing
pplications. For example:
specific interface.
your new system architecture.
Visual Diagram:
Here’s a simple illustration of how the Adapter Pattern works:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The Singleton Pattern can be implemented in a thread-safe manner, ensuring that in multi-threaded applications, only one instance is created even when multiple threads try to access it concurrently.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: s 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(); }
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
complex character (e.g., with styling information) could consist of several
flyweight components (like the base character, font style, size, etc.).
Visual Diagram:
+---------------------------+
| CharacterFactory |
| (Flyweight Factory) |
+---------------------------+
+---------------------------------------------+
| |
+------------------+
+------------------+
| Character | | Character
| <--- Flyweight Objects
| (Intrinsic State)| | (Intrinsic
State)|
+------------------+
+------------------+
| |
| * Shared across all objects |
+--------------------------------------------------->+
(Position, Size, Text displayed are external/unique)
(Memory saved by sharing the intrinsic state)
Conclusion:
The Flyweight Pattern provides a powerful way to manage large numbers of similar objects
efficiently by sharing common state and minimizing memory usage. It’s particularly beneficial
in scenarios like text rendering, game graphics, or large-scale simulations where creating
numerous identical objects would be costly in terms of memory and performance. By
pplying this pattern, you can significantly reduce the memory footprint and improve the
performance of your application while maintaining flexibility in managing the objects' unique
properties.
Interpreter Pattern: Real-Time Example - Parsing and EvaluatingMathematical Expressions
Definition:
The Interpreter Pattern defines a representation for a grammar along with an interpreter to
interpret sentences in that grammar. It is used to evaluate expressions or interpret complexlanguages by breaking them down into simpler components that can be recursively
evaluated.
Use Case:
typical use case for the Interpreter Pattern is parsing and evaluating mathematical
expressions, like addition, subtraction, multiplication, or division. It allows for flexible and
dynamic evaluation of complex expressions.
Code Explanation:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
formats, such as PDF, Word, or HTML. A Factory Method can be used tocreate the appropriate document generator based on user input, allowing for
flexible document creation without hardcoding the specific document format
classes.Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The original SimpleCoffee class remains unchanged, which means you don’t need to touch existing code. The new functionality is added without altering or subclassing the core class.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: In text editors, the Decorator Pattern could be used for adding formatting options to text (bold, italic, underline) dynamically, without needing separate classes for each combination of formatting.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
object. For instance, you could add a feature to customize the size of the
coffee (Small, Medium, Large) which would change both the cost and
description.
Visual Diagram:
+-------------------------+
| ICoffee | <-- Component Interface
+-------------------------+
/ \
+-------------------------+
| SimpleCoffee | <-- Concrete Component (Core Coffee)
+-------------------------+
+---------------------+ +----------------------+
| CoffeeDecorator |<--- | MilkDecorator |
+---------------------+ +----------------------+
| |
Follow:
+---------------------+ +----------------------+
| SugarDecorator | <-- | WhippedCreamDecorator |
+---------------------+ +----------------------+
SimpleCoffee.
Conclusion:
The Decorator Pattern provides a powerful and flexible way to extend the functionality of
objects at runtime. In real-time applications like customizing a coffee order, decorating UI
elements, or adding functionality to text, this pattern helps in achieving clean, modular, and
extensible code. You can add or remove features dynamically, ensuring that your base
classes remain unaltered and your system remains flexible for future extensions.
Facade Pattern: Real-Time Example - Simplifying a Home Theater
System
Definition:
The Facade Pattern provides a simplified interface to a complex subsystem, making it
easier for clients to interact with multiple components. It hides the complexity of the
subsystem and exposes only what is necessary, offering a higher-level interface to users.
Use Case:
A common example is a home theater system, where the user needs to interact with
multiple components like an amplifier, DVD player, or projector. The Facade Pattern
simplifies the process by providing a unified interface to these various components, making
the system easier to use.
Code Explanation:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
unified interface for the user. It wraps the complex subsystem and provides
higher-level methods that internally call the appropriate subsystem methods.
public class HomeTheaterFacade
{
private readonly Amplifier _amplifier;
private readonly DVDPlayer _dvdPlayer;
public HomeTheaterFacade(Amplifier amplifier, DVDPlayerdvdPlayer)
{
_amplifier = amplifier;
_dvdPlayer = dvdPlayer;
}
public void WatchMovie(string movie)
{_amplifier.On();
_dvdPlayer.Play(movie);
}
public void EndMovie()
{_amplifier.Off();
}
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
the HomeTheaterFacade), which internally delegates tasks to the complex
subsystem classes. This makes the system much easier to use while hiding
unnecessary complexity.
Key Benefits of the Facade Pattern:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The Facade makes the system more readable. If the subsystem's complexity changes, the facade can be updated without affecting the client code.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
operations like credit checks, account updates, and transaction processing
are abstracted into a simplified process, allowing users to perform
transactions without understanding the underlying complexities.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
component fails (e.g., DVD player is missing), the facade could display a
user-friendly message or take an appropriate action.
Visual Diagram:
+-------------------------------------+
| HomeTheaterFacade | <-- Facade
(Simplified Interface)
+-------------------------------------+
/ \
/ \
+---------------+ +---------------+
| Amplifier | | DVD Player | <-- Subsystem
Classes
+---------------+ +---------------+
| |
(turn on, play movie) (play movie, etc.)
EndMovie()) to the user.
desired result.
Conclusion:
Follow:
The Facade Pattern is highly effective for simplifying complex systems by providing a
unified interface. In the case of a home theater system, it reduces the complexity of
managing multiple components and makes the system more user-friendly. Whether it’s home
entertainment, e-commerce systems, or banking software, the Facade Pattern is a valuable
design pattern for hiding complexity and improving usability.
Factory Method Pattern: Real-Time Example - Logging Framework
Definition:
The Factory Method Pattern defines an interface for creating objects, but allows
subclasses to alter the type of objects that will be created. This provides flexibility in creating
different types of objects while adhering to the same interface.
Use Case:
A common use case for the Factory Method Pattern is in logging frameworks. Such
frameworks can log messages to various destinations, like files, databases, or consoles. The
Factory Method allows the system to choose the appropriate logging mechanism
dynamically, based on configuration or user preferences, without tightly coupling the client
code to specific classes.
Code Explanation:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Follow:
are logged (either to a file or the console).
FileLogger:
public class FileLogger : ILogger
public void Log(string message) => Console.WriteLine($"Logging
to file: {message}");
ConsoleLogger:
public class ConsoleLogger : ILogger
public void Log(string message) => Console.WriteLine($"Logging
to console: {message}");
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The ILogger interface is implemented by the concrete classes FileLogger and ConsoleLogger. These classes define how the log message will be handled, either by writing to a file or outputting to the console.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
(MilkDecorator, SugarDecorator) extend this class. The decorator
wraps the SimpleCoffee object (or other decorated objects) and enhances
or alters its behavior, like adding extra cost or modifying the description.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
use dependency injection to pass the correct factory implementation into
the client code. This would make the code even more flexible and testable.
Visual Diagram:
+---------------------+
| LoggerFactory | <--- Abstract Factory
(Factory Method)
+---------------------+
+--------------------------+
| |
+-------------------+ +-------------------+
| FileLoggerFactory | | ConsoleLoggerFactory | <--- Concrete
Factories
+-------------------+ +-----------------------+
| |
+---------------+ +----------------+
| FileLogger | | ConsoleLogger | <--- Concrete
Products
Follow:
+---------------+ +----------------+
\ /
\ Client Code /
\_____________________/
Factory Interaction
factory (LoggerFactory), which then returns the appropriate logger (FileLogger
or ConsoleLogger).
Conclusion:
The Factory Method Pattern offers a flexible and extensible solution for object creation,
especially in scenarios where the type of object to be created is determined at runtime. It
decouples the client code from specific classes, making it easier to extend and maintain.
Whether it's for logging systems, database connections, or UI components, this pattern
allows developers to create objects in a controlled and predictable manner, improving
scalability and maintainability.
Flyweight Pattern: Real-Time Example - Managing Graphic Objects in a
Game
Definition:
The Flyweight Pattern is designed to reduce the cost of creating and manipulating a large
number of similar objects. By sharing common parts of an object between multiple instances,
it saves memory and improves performance.
Use Case:
A typical use case for the Flyweight Pattern is in applications like games or text editors
that need to handle a large number of similar objects. For example, in a game with many
characters displayed on the screen, each character might be similar but would take up
unnecessary memory if each instance stored its own version of a character object. The
Flyweight pattern can be used to share the common properties (like the character symbol)
and only store unique ones (like the position).
Code Explanation:
Follow:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The factory manages the extrinsic state (e.g., the position where the character is rendered) separately. It ensures that intrinsic state (the symbol) is shared between all instances, preventing the creation of duplicate objects.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
World", the CharacterFactory checks if the character already exists. If it
does, the existing object is reused; otherwise, a new Character object is
created.
common objects.
Key Benefits of the Flyweight Pattern:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: GUI frameworks that display multiple similar graphical elements (e.g., buttons, labels, icons) can use the Flyweight Pattern to reuse common elements while only storing the unique aspects (such as position, text, or color).
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
where each flyweight can contain references to other flyweights. For example,
a complex character (e.g., with styling information) could consist of several
flyweight components (like the base character, font style, size, etc.).
Visual Diagram:
+---------------------------+
| CharacterFactory |
| (Flyweight Factory) |
+---------------------------+
+---------------------------------------------+
| |
+------------------+
+------------------+
| Character | | Character
| <--- Flyweight Objects
| (Intrinsic State)| | (Intrinsic
State)|
+------------------+
+------------------+
| |
| * Shared across all objects |
Follow:
+--------------------------------------------------->+
(Position, Size, Text displayed are external/unique)
(Memory saved by sharing the intrinsic state)
Conclusion:
The Flyweight Pattern provides a powerful way to manage large numbers of similar objects
efficiently by sharing common state and minimizing memory usage. It’s particularly beneficial
in scenarios like text rendering, game graphics, or large-scale simulations where creating
numerous identical objects would be costly in terms of memory and performance. By
applying this pattern, you can significantly reduce the memory footprint and improve the
performance of your application while maintaining flexibility in managing the objects' unique
properties.
Interpreter Pattern: Real-Time Example - Parsing and Evaluating
Mathematical Expressions
Definition:
The Interpreter Pattern defines a representation for a grammar along with an interpreter to
interpret sentences in that grammar. It is used to evaluate expressions or interpret complex
languages by breaking them down into simpler components that can be recursively
evaluated.
Use Case:
A typical use case for the Interpreter Pattern is parsing and evaluating mathematical
expressions, like addition, subtraction, multiplication, or division. It allows for flexible and
dynamic evaluation of complex expressions.
Code Explanation:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The Number class is a terminal expression that holds a single value. When the Interpret method is called, it returns the value of the number. Terminal expressions represent the simplest elements in the language or grammar.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: New operations (e.g., subtraction, multiplication, etc.) can be added easily by creating new non-terminal expression classes (e.g., Subtract, Multiply). This makes the pattern highly extendable.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
domain-specific languages (DSLs) or simple programming languages. Each
statement or expression in the language can be represented as an object,
and the interpreter evaluates these statements to execute the program.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The Interpreter Pattern can be extended to support more complex grammars. For example, adding new operations like subtraction or division can be easily done by introducing new non-terminal expressions (e.g., Subtract, Divide).
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
returns an iterator instance. Any class that represents a collection shouldimplement this interface to provide an iterator.
public interface IAggregate<T>
{IIterator<T> CreateIterator();
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: .LogMessage(...)). This continues until a handler processes the message or the chain is exhausted. Key Benefits of the Chain of Responsibility Pattern:
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
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();
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
look and feel, as each factory provides platform-specific products.
Improvement Suggestions:
dialogs) to your abstract factory. This would allow for more complex UI
systems that adapt to various platforms.
product creation methods (e.g., create UI components only when needed).
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:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
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.");
Gang of Four Patterns Design Patterns in C# · GoF Patterns
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:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
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);
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
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.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
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();
Gang of Four Patterns Design Patterns in C# · GoF Patterns
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:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
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.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
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}");
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
to the RealImage. It is responsible for lazy loading the real image only when needed
(i.e., the first time Display() is called).
public class ProxyImage : IImage
{
private readonly string _filename;
private RealImage _realImage;
public ProxyImage(string filename) => _filename = filename;
public void Display()
{
if (_realImage == null)
{
_realImage = new RealImage(_filename);
}_realImage.Display();
}
}Display() method is called for the first time. This delays the loading of the
image, making it more efficient if the Display() method is not called
frequently.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
interface. It encapsulates the request to add text to the document.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);
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
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:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
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.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
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:
the entire system can be undone or redone.
allowing for consistent handling of actions across the UI.
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:
Follow:
(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:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
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}");
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
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.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
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:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: You can extend the file system to support additional metadata for each file or directory, such as size, creation date, and file type. This could be added as properties in the File and Directory classes.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: SimpleCoffee is the core object that implements ICoffee. It has a fixed price and a basic description. This is the base coffee that we will add features to dynamically.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: All observers receive the update from the subject automatically, ensuring that they all stay in sync with the subject’s state.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
to manage interactions between various components like buttons, text fields,
and labels. For example, clicking a button might update a text field, and the
mediator ensures that these updates are propagated correctly.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
also create a dependency on the mediator itself. Over-reliance on the
mediator can lead to issues if the mediator needs to change.
Visual Diagram:
+----------------------+
| IChatMediator |
| (Mediator Interface) |
+----------------------+
+------------------------------------+
| |
+------------------+ +------------------+
| ChatMediator | | User |
| (Concrete Mediator) | (Colleague) |
+------------------+ +------------------+
| |
+-------------------+ +------------------+
| RegisterUser(User)| | Send(string) |
| SendMessage(...) | | Receive(string) |
+-------------------+ +------------------+
Follow:
Conclusion:
The Mediator Pattern is an excellent solution for managing complex interactions between
objects in a system, particularly when those objects don’t need to know about each other
directly. It reduces dependencies, simplifies communication, and centralizes control, making
it easier to manage interactions. However, it should be used judiciously, as a poorly
implemented mediator can become a bottleneck or a single point of failure in the system.
Memento Pattern: Real-Time Example - Undo Feature in a Text Editor
Definition:
The Memento Pattern is used to capture and externalize an object's internal state without
violating encapsulation. This allows the object to be restored to this state later. It’s commonly
used in situations where an object's state changes over time and you may need to revert to
previous states, such as an undo feature.
Use Case:
The Memento Pattern is widely used in scenarios where you want to implement an undo or
restore functionality, such as in a text editor. In this case, the pattern allows the editor to
save versions of the text and restore them when the user requests an undo.
Code Breakdown:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: The Caretaker is responsible for managing the saved states (mementos). It can undo changes by restoring the TextEditor to its previous state stored in the mementos stack.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: Instead of having complex direct interactions between objects (users in this case), the mediator simplifies the process, as objects only need to communicate with the mediator.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
sophisticated memento management (e.g., limiting the number of mementos
kept in memory or implementing a more efficient undo/redo system).
Real-Time Use Case Examples:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
maintains a list of observers and provides methods to subscribe, unsubscribe, and
notify them when a new news article is available.
public class NewsPublisher : INewsPublisher
{
private readonly List<IObserver> _observers = new
List<IObserver>();
public void Subscribe(IObserver observer) =>_observers.Add(observer);
public void Unsubscribe(IObserver observer) =>_observers.Remove(observer);
public void Notify(string news)
{
foreach (var observer in _observers)
{observer.Update(news);
}
}
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: Users don’t need to know the identities of other users or how to reach them. The mediator centralizes communication, and the users only rely on the mediator to send and receive messages. Benefits of the Mediator Pattern:
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: When the publisher publishes new news via the Notify() method, each observer’s Update() method is called, and the news is sent to all registered subscribers. Benefits of the Observer Pattern:
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
IChatMediator. It manages a list of users and is responsible for
broadcasting messages to all registered users, except the one who sent the
message.
to know about each other's existence.
public class ChatMediator : IChatMediator
{
private readonly List<User> _users = new List<User>();
public void RegisterUser(User user) => _users.Add(user);
public void SendMessage(string message, User user)
{
foreach (var u in _users)
{// Message should not be sent to the user who sent it
if (u != user)
{u.Receive(message);
}
}
}
}Gang of Four Patterns Design Patterns in C# · GoF Patterns
efficiently (e.g., lazy loading or batching) can improve performance.
Visual Diagram:
Follow:
+---------------------------+
| IIterator<T> |
| (Iterator Interface) |
+---------------------------+
+---------------------------+
| |
+-----------------+ +------------------+
| ProductIterator| | ProductCollection|
| (Concrete Iterator) | (Concrete Aggregate)|
+-----------------+ +------------------+
| |
+--------------+ +--------------+
| HasNext() | | Add() |
| Next() | | Count |
| | | CreateIterator() |
+--------------+ +--------------+
Conclusion:
The Iterator Pattern is a powerful design pattern for accessing elements of a collection
sequentially, encapsulating the iteration logic in a separate object. This allows for greater
flexibility and maintainability by decoupling the collection's internal representation from the
client code.
Mediator Pattern: Real-Time Example - Chat Application
Definition:
The Mediator Pattern defines an object that encapsulates how a set of objects interact. It
promotes loose coupling by preventing objects from referring to each other explicitly,
allowing them to communicate indirectly through the mediator. This pattern is useful when
you need to manage complex interactions between multiple objects, without them needing to
know about each other.
Use Case:
Follow:
A chat application is a perfect example of where the Mediator Pattern can be applied. In a
chat app, users (colleagues) need to communicate, but rather than each user being directly
aware of the others, a mediator handles all the communication between users.
Code Explanation:
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: Care should be taken to avoid circular dependencies, where observers depend on each other in a way that could create an infinite loop or inconsistent states. Real-Time Use Case Examples:
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
collection (like a list of rows). The Iterator Pattern is used to iterate over
these rows to access the data, rather than exposing the internal structure of
how the data is retrieved from the database.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: In social media platforms, followers (observers) are notified when the user they follow (subject) posts new updates or content.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: Once the real object is initialized, the proxy delegates the call to the real object. In our example, after the image is loaded by the proxy, it delegates the Display() method to the RealImage class. Benefits of the Proxy Pattern:
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: If an object is very complex and its construction requires a lot of steps, the Prototype Pattern allows you to avoid duplicating these steps by cloning an existing object and modifying only the necessary parts. Considerations:
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
from the client. The client interacts only with the iterator, which means that
changes to the underlying collection (e.g., changing it from a list to a linked
list) do not affect the client code.Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: For game characters or systems that can exist in different states, like a character having different behaviors when idle, walking, running, or jumping.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: In document editors, a document template (e.g., a "letter" prototype) can be cloned, and then the cloned document can be customized with specific content for each user.
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: When the Clone() method is called on an existing object (e.g., original), it returns a new instance of the same type (e.g., GameCharacter) with the same state (e.g., same Name and Health). Benefits of the Prototype Pattern:
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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.
Gang of Four Patterns Design Patterns in C# · GoF Patterns
Answer: ny component and let the pattern take care of the rest. Real-Time Use Case 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.
Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.