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.
Design Patterns & SOLID Design Patterns in C# · SOLID
The Singleton pattern ensures a class has only one instance and provides a global point of
ccess to it. It’s commonly used when exactly one object is needed to coordinate actions
cross the system, such as configuration settings, logging, or caching.
Design Patterns & SOLID Design Patterns in C# · SOLID
One common thread-safe implementation uses lazy initialization with Lazy<T>:
public sealed class Singleton
{
private static readonly Lazy<Singleton> instance = new
Lazy<Singleton>(() => new Singleton());
private Singleton() { }
public static Singleton Instance => instance.Value;
}This approach ensures thread safety and lazy initialization without locks.
Design Patterns & SOLID Design Patterns in C# · SOLID
concurrent environments.
Design Patterns & SOLID Design Patterns in C# · SOLID
Singletons can hinder unit testing because they introduce global state, making tests
dependent on a shared instance. This can cause tests to be flaky or order-dependent. To
mitigate this, use interfaces and dependency injection, or design the Singleton to allow
resetting its state for tests.
Design Patterns & SOLID Design Patterns in C# · SOLID
container, though generally discouraged.
In a production Design Patterns & SOLID 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.
Design Patterns & SOLID Design Patterns in C# · SOLID
It's simple but can waste resources if the instance is never used.
resources but requires careful implementation for thread safety.
Factory pattern Q&A
Design Patterns & SOLID Design Patterns in C# · SOLID
The Factory pattern is a creational design pattern that provides an interface for creating
objects but allows subclasses or implementations to decide which class to instantiate. It’s
used to encapsulate object creation, promoting loose coupling and flexibility when the exact
types of objects aren’t known until runtime.
Use case: When a class can’t anticipate the class of objects it needs to create, or when you
want to delegate responsibility for object creation to subclasses.
Design Patterns & SOLID Design Patterns in C# · SOLID
decide which class to instantiate. It uses inheritance and relies on subclass
overriding.
objects without specifying their concrete classes. It uses composition and is useful
when you need to create multiple related objects together.
Design Patterns & SOLID Design Patterns in C# · SOLID
A simple example of Factory Method:
// Product interface
public interface IAnimal
{void Speak();
}// Concrete Products
public class Dog : IAnimal
{
public void Speak() => Console.WriteLine("Woof");
}
public class Cat : IAnimal
{
public void Speak() => Console.WriteLine("Meow");
}// Factory
public class AnimalFactory
{
public static IAnimal CreateAnimal(string animalType)
{
return animalType.ToLower() switch
{"dog" => new Dog(),
"cat" => new Cat(),
_ => throw new ArgumentException("Invalid animal type")
};
}
}Usage:
var dog = AnimalFactory.CreateAnimal("dog");dog.Speak(); // Outputs: Woof
Design Patterns & SOLID Design Patterns in C# · SOLID
code.
concrete types.
Design Patterns & SOLID Design Patterns in C# · SOLID
Yes! Factory pattern can complement Dependency Injection (DI) by abstracting complex
object creation logic, especially when the creation involves runtime parameters or complex
setup that DI containers can’t handle easily.
Example: Imagine a service that needs different data repositories based on a runtime
parameter.
public interface IRepository { void Save(); }
public class SqlRepository : IRepository { public void Save() =>Console.WriteLine("Saving to SQL DB"); }
public class InMemoryRepository : IRepository { public void Save()
=> Console.WriteLine("Saving in Memory"); }
public interface IRepositoryFactory
{IRepository CreateRepository(string repoType);
}
public class RepositoryFactory : IRepositoryFactory
{
public IRepository CreateRepository(string repoType)
{
return repoType.ToLower() switch
{"sql" => new SqlRepository(),
"memory" => new InMemoryRepository(),
_ => throw new ArgumentException("Invalid repository
type")
};
}
}// Consumer class with DI
public class Service
{
private readonly IRepositoryFactory _repositoryFactory;
public Service(IRepositoryFactory repositoryFactory)
{
_repositoryFactory = repositoryFactory;
}
public void SaveData(string repoType)
{
var repo = _repositoryFactory.CreateRepository(repoType);repo.Save();
}
}Here, DI injects the IRepositoryFactory while the factory manages object creation
based on runtime input. This promotes loose coupling and flexibility.
Strategy Design Pattern
Design Patterns & SOLID Design Patterns in C# · SOLID
The Strategy pattern is a behavioral design pattern that defines a family of algorithms,
encapsulates each one, and makes them interchangeable at runtime.
It allows the algorithm to vary independently from clients that use it.
Problem it solves:
voids large if-else or switch statements when selecting behavior and promotes
flexibility by decoupling the algorithm from the client using it.
Design Patterns & SOLID Design Patterns in C# · SOLID
Example: Payment strategy selection
// Strategy Interface
public interface IPaymentStrategy
{void Pay(decimal amount);
}// Concrete Strategies
public class CreditCardPayment : IPaymentStrategy
{
public void Pay(decimal amount) => Console.WriteLine($"Paid{amount} using Credit Card");
}
public class PayPalPayment : IPaymentStrategy
{
public void Pay(decimal amount) => Console.WriteLine($"Paid{amount} using PayPal");
}// Context
public class PaymentContext
{
private IPaymentStrategy _paymentStrategy;
public PaymentContext(IPaymentStrategy paymentStrategy)
{
_paymentStrategy = paymentStrategy;
}
public void ExecutePayment(decimal amount)
{_paymentStrategy.Pay(amount);
}
}Usage:
var context = new PaymentContext(new PayPalPayment());context.ExecutePayment(200); // Outputs: Paid 200 using PayPal
Design Patterns & SOLID Design Patterns in C# · SOLID
Answer: Payment gateways (Credit Card, PayPal, UPI, etc.) Sorting algorithms (QuickSort, MergeSort, BubbleSort) Authentication strategies (OAuth, JWT, LDAP) Compression algorithms (ZIP, RAR, TAR) Loggers (FileLogger, ConsoleLogger, DatabaseLogger)
In a production Design Patterns & SOLID 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.
Design Patterns & SOLID Design Patterns in C# · SOLID
It promotes the Open/Closed Principle by allowing you to add new strategies (algorithms
or behaviors) without modifying the existing code.
The context class uses an interface for the strategy, so new behavior can be added just by
creating a new class that implements the interface—no need to touch existing logic.
Design Patterns & SOLID Design Patterns in C# · SOLID
Aspect Strategy Pattern State Pattern
Purpose Encapsulates interchangeable
behaviors (algorithms).
Encapsulates states and transitions
between them.
Client
Control
Client decides which strategy to use. Object changes its own state
internally.Behavior
Switch
Switched externally (e.g., passed as
parameter).
Switched internally (e.g., via
method call).
Example Payment method selection. Document lifecycle (Draft →
Published → Archived).
Repository Design Pattern
Design Patterns & SOLID Design Patterns in C# · SOLID
pplications?
The Repository pattern abstracts the data access layer from the business logic by providing
collection-like interface to access domain objects.
It helps keep data access logic centralized and makes the codebase easier to maintain,
test, and swap out data sources (e.g., switching from EF Core to Dapper or an API).
Design Patterns & SOLID Design Patterns in C# · SOLID
The Repository pattern abstracts the data access layer from the business logic by providing
a collection-like interface to access domain objects.
It helps keep data access logic centralized and makes the codebase easier to maintain,
test, and swap out data sources (e.g., switching from EF Core to Dapper or an API).
Design Patterns & SOLID Design Patterns in C# · SOLID
Here's a basic example:
// Entity
public class Product
{
public int Id { get; set; }
public string Name { get; set; }
}// Generic Repository Interface
public interface IRepository<T> where T : class
{Task<IEnumerable<T>> GetAllAsync();
Task<T> GetByIdAsync(int id);
Task AddAsync(T entity);
void Update(T entity);
void Delete(T entity);
Task SaveAsync();
}// EF Core implementation
public class Repository<T> : IRepository<T> where T : class
{
private readonly DbContext _context;
private readonly DbSet<T> _dbSet;
public Repository(DbContext context)
{
_context = context;
_dbSet = context.Set<T>();
}
public async Task<IEnumerable<T>> GetAllAsync() => await_dbSet.ToListAsync();
public async Task<T> GetByIdAsync(int id) => await_dbSet.FindAsync(id);
public async Task AddAsync(T entity) => await_dbSet.AddAsync(entity);
public void Update(T entity) => _dbSet.Update(entity);
public void Delete(T entity) => _dbSet.Remove(entity);
public async Task SaveAsync() => await_context.SaveChangesAsync();
}Design Patterns & SOLID Design Patterns in C# · SOLID
Answer: Separation of concerns between business and data access layers Improved testability (can mock repositories) Centralized query logic for maintainability Easier to switch persistence implementations Promotes cleaner and more organized code
In a production Design Patterns & SOLID 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.
Design Patterns & SOLID Design Patterns in C# · SOLID
IProductRepository)
public interface IProductRepository : IRepository<Product>
{Task<IEnumerable<Product>> GetProductsWithLowStockAsync(int
threshold);
}Design Patterns & SOLID Design Patterns in C# · SOLID
repository/unit-of-work pattern).
projections.
value.
Unit of Work
Design Patterns & SOLID Design Patterns in C# · SOLID
The Unit of Work pattern is a design pattern used to maintain a list of operations to be
performed within a single transaction. It ensures that all operations either succeed or fail
together, providing consistency and managing changes to multiple business objects during a
transaction. It coordinates the writing out of changes and resolves potential concurrency
issues.
Design Patterns & SOLID Design Patterns in C# · SOLID
The Repository pattern abstracts the data access layer, providing a simplified interface to
data operations. The Unit of Work pattern complements it by managing multiple repositories
nd ensuring that all changes made through these repositories are committed in a single
transaction. This combination separates concerns, promotes clean architecture, and
maintains transactional integrity across multiple operations.
Design Patterns & SOLID Design Patterns in C# · SOLID
In a .NET application (especially using Entity Framework), the Unit of Work is typically
implemented around the DbContext, as it already tracks changes and handles
transactions. Here's a simplified example:
// IUnitOfWork.cs
public interface IUnitOfWork : IDisposable
{IProductRepository Products { get; }
ICustomerRepository Customers { get; }
int Complete();
}// UnitOfWork.cs
public class UnitOfWork : IUnitOfWork
{
private readonly AppDbContext _context;
public IProductRepository Products { get; private set; }
public ICustomerRepository Customers { get; private set; }
public UnitOfWork(AppDbContext context)
{
_context = context;
Products = new ProductRepository(_context);
Customers = new CustomerRepository(_context);
}
public int Complete()
{
return _context.SaveChanges(); // All changes in onetransaction
}
public void Dispose()
{_context.Dispose();
}
}Then register it using Dependency Injection in Startup.cs or Program.cs:
services.AddScoped<IUnitOfWork, UnitOfWork>();
Design Patterns & SOLID Design Patterns in C# · SOLID
transaction.
(Complete()), improving control and readability.
instead of multiple repositories.
unnecessary database operations.
Design Patterns & SOLID Design Patterns in C# · SOLID
Yes, combining Unit of Work with Dependency Injection (DI) is a best practice in modern
.NET applications. DI allows the Unit of Work to be injected into services or controllers,
managing its lifecycle effectively. This improves modularity, promotes loose coupling, and
makes the application easier to maintain and test.
Example using constructor injection in a service:
public class OrderService
{
private readonly IUnitOfWork _unitOfWork;
public OrderService(IUnitOfWork unitOfWork)
{
_unitOfWork = unitOfWork;
}
public void PlaceOrder(Order order)
{_unitOfWork.Orders.Add(order);
_unitOfWork.Complete();
}
}Dependency Injection (DI)
Design Patterns & SOLID Design Patterns in C# · SOLID
Dependency Injection (DI) is a design pattern that allows an object to receive its
dependencies from an external source rather than creating them itself. This promotes loose
coupling, enhances testability, and simplifies code maintenance.
Benefits:
Principle)
Design Patterns & SOLID Design Patterns in C# · SOLID
.NET Core has a built-in DI container that's tightly integrated into the framework. When
you create a new ASP.NET Core project, DI is configured automatically and used in
controllers, middleware, services, etc. You register dependencies in the Program.cs or
Startup.cs file using IServiceCollection.
Design Patterns & SOLID Design Patterns in C# · SOLID
Services are registered in the Program.cs or Startup.cs file using the
IServiceCollection interface. Example:
builder.Services.AddTransient<IProductService, ProductService>();
builder.Services.AddScoped<IOrderService, OrderService>();
builder.Services.AddSingleton<ILoggingService, LoggingService>();
Design Patterns & SOLID Design Patterns in C# · SOLID
Lifetime Created Per Use Case
Transient Every injection Lightweight, stateless services
Scoped HTTP Request Web services handling per-request
data
Singleton App lifetime Logging, configuration, cache
Design Patterns & SOLID Design Patterns in C# · SOLID
Circular dependencies occur when two or more services depend on each other, creating an
infinite loop. To handle them:
Design Patterns & SOLID Design Patterns in C# · SOLID
Design Patterns & SOLID Design Patterns in C# · SOLID
Yes, DI can be implemented manually without using a DI container. You simply pass
dependencies through constructors or methods:
public class OrderService
{
private readonly IOrderRepository _repo;
public OrderService(IOrderRepository repo)
{
_repo = repo;
}
}// Manual injection
var repo = new OrderRepository();
var service = new OrderService(repo);This is suitable for small or simple applications, though not scalable for large apps.
Design Patterns & SOLID Design Patterns in C# · SOLID
Design Patterns & SOLID Design Patterns in C# · SOLID
Inversion of Control (IoC) is a broader principle where control over object creation and
dependency resolution is transferred from the class itself to an external framework or
container.
Dependency Injection is a specific implementation of IoC, where the dependencies are
injected into a class rather than the class creating them internally. So, DI is one way to
chieve IoC.
Single Responsibility Principle
(SRP)
Design Patterns & SOLID Design Patterns in C# · SOLID
The Single Responsibility Principle (SRP) states that a class should have only one
reason to change. In other words, it should have only one responsibility or job.
Each class should do one thing, and do it well.
For example, a class that handles user authentication should not also be responsible forlogging or sending emails.
Design Patterns & SOLID Design Patterns in C# · SOLID
You can identify SRP violations by asking questions like:
logic)?
ReportGeneratorAndPrinter.
Common signs:
Design Patterns & SOLID Design Patterns in C# · SOLID
Before (SRP Violation):
public class Invoice
{
public void GenerateInvoice() { /* logic */ }
public void SaveToDatabase() { /* logic */ }
public void SendEmail() { /* logic */ }
}This class has 3 responsibilities: generating, saving, and emailing.
fter (SRP-compliant):
public class InvoiceGenerator
{
public void Generate() { /* logic */ }
}
public class InvoiceRepository
{
public void Save(Invoice invoice) { /* logic */ }
}
public class EmailService
{
public void Send(Invoice invoice) { /* logic */ }
}Now each class has a single reason to change.
Design Patterns & SOLID Design Patterns in C# · SOLID
SRP improves maintainability by:
code are kept apart.
Ultimately, it leads to more modular, flexible, and robust code.
Design Patterns & SOLID Design Patterns in C# · SOLID
If a class has multiple responsibilities:Open/Closed Principle (OCP)
Design Patterns & SOLID Design Patterns in C# · SOLID
The Open/Closed Principle (OCP) states that:
Software entities (classes, modules, functions) should be open for
extension but closed for modification.
This means you should be able to add new behavior to a class without changing its
existing code, which helps avoid breaking existing functionality.
Design Patterns & SOLID Design Patterns in C# · SOLID
To design classes that follow OCP:
✅ Extend behavior through new classes rather than modifying existing code.
Design Patterns & SOLID Design Patterns in C# · SOLID
Several design patterns are built around the idea of making systems extensible without
modifying core logic:
Pattern How It Helps With OCP
Strategy Allows changing behavior by swapping strategies.
Decorator Adds new responsibilities dynamically without changing original code.
Template Method Allows subclasses to override certain steps in an algorithm.
Factory Method Makes it easy to introduce new types without altering existing logic.
Observer Extends behavior in reaction to events without altering the source.
Design Patterns & SOLID Design Patterns in C# · SOLID
Before (OCP Violation):
public class DiscountCalculator
{
public decimal CalculateDiscount(string customerType)
{
if (customerType == "Regular") return 10;
if (customerType == "Premium") return 20;
if (customerType == "VIP") return 30;
return 0;
}
}
If you need to support a new customer type, you must modify this method — violating OCP.fter (OCP Compliant):
public interface IDiscountStrategy
{decimal GetDiscount();
}
public class RegularCustomerDiscount : IDiscountStrategy
{
public decimal GetDiscount() => 10;
}
public class PremiumCustomerDiscount : IDiscountStrategy
{
public decimal GetDiscount() => 20;
}
public class VipCustomerDiscount : IDiscountStrategy
{
public decimal GetDiscount() => 30;
}Now you can add new customer types without modifying existing code — just create a new
strategy.
Design Patterns & SOLID Design Patterns in C# · SOLID
implement or inherit.
existing code.
introduce new behavior (via new implementations) while keeping the core logicunchanged.
✅ OCP encourages extending via new subclasses or interface implementations, not
modifying existing ones.
Liskov Substitution Principle (LSP)
Design Patterns & SOLID Design Patterns in C# · SOLID
The Liskov Substitution Principle (LSP) states that:
Subtypes must be substitutable for their base types without altering the
correctness of the program.
In other words, if class S is a subclass of class T, then objects of type T should be
replaceable with objects of type S without breaking the application.
This ensures that inheritance models is-a relationships correctly.
Design Patterns & SOLID Design Patterns in C# · SOLID
Violating LSP can lead to:
class.bstractions.
Essentially, it defeats the purpose of polymorphism.
Design Patterns & SOLID Design Patterns in C# · SOLID
Example (Violation of LSP):
public class Rectangle
{
public virtual int Width { get; set; }
public virtual int Height { get; set; }
public int Area() => Width * Height;
}
public class Square : Rectangle
{
public override int Width
{
set { base.Width = base.Height = value; }
}
public override int Height
{
set { base.Width = base.Height = value; }
}
}Now if you substitute Rectangle with Square:
Rectangle rect = new Square();
rect.Width = 5;
rect.Height = 10;Console.WriteLine(rect.Area()); // Outputs 100, but logically
expected 50
❌ The behavior is incorrect — this is a violation of LSP.
Design Patterns & SOLID Design Patterns in C# · SOLID
To ensure subclasses follow LSP:
base class.
class behavior.valid scenarios.
✅ Ask yourself: Can this subclass be used anywhere the base class is used — without
surprises?
Design Patterns & SOLID Design Patterns in C# · SOLID
LSP is fundamentally about correct use of inheritance. While inheritance allows code
reuse, LSP ensures that the behavior of subclasses remains consistent with that of the
base class.
If a subclass changes the meaning or violates the expectations of the base class’sbehavior, it's misusing inheritance.
Interface Segregation Principle (ISP)Design Patterns & SOLID Design Patterns in C# · SOLID
Answer: No client should be forced to implement methods it does not use. Break large interfaces into smaller, focused interfaces.
In a production Design Patterns & SOLID 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.
Design Patterns & SOLID Design Patterns in C# · SOLID
Small, specific interfaces:
In contrast, large interfaces force classes to implement methods they may not need —
leading to fragile and cluttered code.
Design Patterns & SOLID Design Patterns in C# · SOLID
ISP improves code flexibility by:
Smaller interfaces result in lower coupling and better maintainability.
Design Patterns & SOLID Design Patterns in C# · SOLID
Violation Example:
public interface IWorker
{void Work();
void Eat();
void Sleep();
}
public class Robot : IWorker
{
public void Work() { /* logic */ }
public void Eat() { throw new NotImplementedException(); }
public void Sleep() { throw new NotImplementedException(); }
}❌ Robot is forced to implement Eat() and Sleep(), which don’t make sense for it.
Design Patterns & SOLID Design Patterns in C# · SOLID
Refactored Using ISP:
public interface IWorkable
{void Work();
}
public interface IFeedable
{void Eat();
}
public interface ISleepable
{void Sleep();
}
public class Human : IWorkable, IFeedable, ISleepable
{
public void Work() { }
public void Eat() { }
public void Sleep() { }
}
public class Robot : IWorkable
{
public void Work() { }
}✅ Now each class implements only the interfaces it needs — in line with ISP.
Inversion Principle (DIP)
Design Patterns & SOLID Design Patterns in C# · SOLID
The Dependency Inversion Principle (DIP) states that:
High-level modules should not depend on low-level modules. Both should
depend on abstractions.
bstractions should not depend on details. Details should depend on
bstractions.
In other words:
bstract classes.
Design Patterns & SOLID Design Patterns in C# · SOLID
Aspect Dependency Inversion Principle (DIP) Dependency Injection (DI)
Definitio
design principle about depending on
bstractions
technique for passing
dependencies
Goal Decouple high-level logic from low-level
details
Provide dependencies to
objects
Relation DIP motivates the need for DI DI is a way to implement DIP
Focus What to depend on (abstractions) How dependencies are supplied
✅ DIP is a design principle, while DI is a design pattern/technique to implement that
principle.
Design Patterns & SOLID Design Patterns in C# · SOLID
Abstractions (e.g., interfaces or abstract classes):
Design Patterns & SOLID Design Patterns in C# · SOLID
❌ Without DIP (Tightly Coupled):
public class FileLogger
{
public void Log(string message) => Console.WriteLine("File log:" + message);
}
public class OrderService
{
private readonly FileLogger _logger = new FileLogger();
public void ProcessOrder()
{// Logic
_logger.Log("Order processed.");
}
}✅ With DIP (Loosely Coupled via Abstraction):
public interface ILogger
{void Log(string message);
}
public class FileLogger : ILogger
{
public void Log(string message) => Console.WriteLine("File log:" + message);
}
public class OrderService
{
private readonly ILogger _logger;
public OrderService(ILogger logger)
{
_logger = logger;
}
public void ProcessOrder()
{// Logic
_logger.Log("Order processed.");
}
}Now OrderService depends on the abstraction (ILogger), not the concrete
FileLogger. You can easily substitute with DatabaseLogger, ConsoleLogger, or a
mock in tests.
Design Patterns & SOLID Design Patterns in C# · SOLID
✅ Key Benefits:
ones
containers
dvanced & Scenario-Based
Questions
Design Patterns & SOLID Design Patterns in C# · SOLID
Design patterns provide structured, reusable solutions that embody SOLID principles. For
example, the Strategy pattern supports OCP by allowing behavior extension without
modifying existing code; Repository separates data access (SRP); Dependency Injection
supports DIP by decoupling high- and low-level modules. Using patterns helps keep code
clean, modular, and maintainable.
Design Patterns & SOLID Design Patterns in C# · SOLID
The Unit of Work coordinates multiple Repositories and commits changes in a single
transaction. For example:
public interface IUnitOfWork : IDisposable
{IProductRepository Products { get; }
IOrderRepository Orders { get; }
int Complete();
}
public class UnitOfWork : IUnitOfWork
{
private readonly DbContext _context;
public IProductRepository Products { get; }
public IOrderRepository Orders { get; }
public UnitOfWork(DbContext context)
{
_context = context;
Products = new ProductRepository(_context);
Orders = new OrderRepository(_context);
}
public int Complete() => _context.SaveChanges();
public void Dispose() => _context.Dispose();
}This ensures atomic commits across repositories.
Design Patterns & SOLID Design Patterns in C# · SOLID
Testing singletons/statics is tricky due to global state. Best practices include:
Design Patterns & SOLID Design Patterns in C# · SOLID
nd why?
The Mediator Pattern centralizes communication between components, preventing direct
dependencies and reducing complexity. It promotes loose coupling and simplifies
interactions. Alternatively, the Observer Pattern enables event-driven decoupling, andFacade Pattern provides a simplified interface to complex subsystems.
Design Patterns & SOLID Design Patterns in C# · SOLID
The Mediator Pattern centralizes communication between components, preventing direct
dependencies and reducing complexity. It promotes loose coupling and simplifies
interactions. Alternatively, the Observer Pattern enables event-driven decoupling, and
Facade Pattern provides a simplified interface to complex subsystems.
Design Patterns & SOLID Design Patterns in C# · SOLID
Define a common interface, e.g., IPaymentStrategy with a method Pay(). Implement
concrete strategies for each payment method (CreditCard, PayPal, etc.). Use a context class
to invoke the selected strategy at runtime, enabling easy extension without modifying
existing code.
Design Patterns & SOLID Design Patterns in C# · SOLID
DAO (Data Access Object) focuses on low-level database operations and CRUD, typically
mapping tables to objects.
Repository abstracts data access at the domain level, working with aggregates/entities and
encapsulating business logic. Repository often uses DAO internally but is more aligned with
domain-driven design.
Design Patterns & SOLID Design Patterns in C# · SOLID
Design Patterns & SOLID Design Patterns in C# · SOLID
Use AOP (Aspect-Oriented Programming) techniques or design patterns like Decorator
to separate cross-cutting concerns from business logic. In .NET, middleware, filters, or
interceptors can manage concerns like logging or authorization, keeping SRP intact.Design Patterns & SOLID Design Patterns in C# · SOLID
DI containers use reflection to inspect constructors of requested services, resolve
dependencies recursively from their registrations, apply lifecycle scopes (Singleton, Scoped,
Transient), and build the full object graph to return fully constructed instances.
Design Patterns & SOLID Design Patterns in C# · SOLID
Practical .NET Questions
Design Patterns & SOLID Design Patterns in C# · SOLID
ASP.NET Core MVC has built-in support for Dependency Injection.
IServiceCollection:
public void ConfigureServices(IServiceCollection services)
{services.AddControllersWithViews();
services.AddScoped<IProductService, ProductService>(); //
Example
}public class HomeController : Controller
{
private readonly IProductService _productService;
public HomeController(IProductService productService)
{
_productService = productService;
}
public IActionResult Index()
{
var products = _productService.GetAll();
return View(products);
}
}The framework resolves and injects dependencies automatically.
Design Patterns & SOLID Design Patterns in C# · SOLID
their lifetimes (Scoped, Transient, Singleton). It acts as a service registry.
registered services at runtime. It uses the registrations to create and inject
dependencies.
Design Patterns & SOLID Design Patterns in C# · SOLID
services.AddDbContext<AppDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConne
ction")));
on the DbContext:
public interface IUnitOfWork : IDisposable
{IProductRepository Products { get; }
int Complete();
}
public class UnitOfWork : IUnitOfWork
{
private readonly AppDbContext _context;
public IProductRepository Products { get; private set; }
public UnitOfWork(AppDbContext context)
{
_context = context;
Products = new ProductRepository(_context);
}
public int Complete() => _context.SaveChanges();
public void Dispose() => _context.Dispose();
}Register UnitOfWork in DI container as Scoped.
Design Patterns & SOLID Design Patterns in C# · SOLID
var mockRepo = new Mock<IProductRepository>();mockRepo.Setup(repo => repo.GetAll()).Returns(new List<Product> {
... });
var service = new ProductService(mockRepo.Object);// Act & Assert
Design Patterns & SOLID Design Patterns in C# · SOLID
decides to pass control or handle the request.
or after.
pipeline setup.
Design Patterns & SOLID Design Patterns in C# · SOLID
public interface ICacheStrategy
{void Cache(string key, object value);
object Retrieve(string key);
}DistributedCacheStrategy.
public class CacheContext
{
private readonly ICacheStrategy _cacheStrategy;
public CacheContext(ICacheStrategy cacheStrategy)
{
_cacheStrategy = cacheStrategy;
}
public void Cache(string key, object value) =>_cacheStrategy.Cache(key, value);
}This enables switching caching mechanisms without code changes.
Design Patterns & SOLID Design Patterns in C# · SOLID
without specifying concrete classes.
Example: Creating UI components for different OS (Windows, Mac).
representations.
Example: Building a complex House with various parts (walls, doors, roof).
Summary: Abstract Factory is about families of products, Builder is about complex
construction process.
Design Patterns & SOLID Design Patterns in C# · SOLID
classes.Design Patterns & SOLID Design Patterns in C# · SOLID
Design Patterns & SOLID Design Patterns in C# · SOLID
DIP by reducing direct dependencies.
modifying existing components.
Behavioral / Conceptual Questions
Design Patterns & SOLID Design Patterns in C# · SOLID
In a recent project, we had a monolithic service class handling multiple responsibilities,
making it hard to maintain and extend. By applying Single Responsibility Principle (SRP),
we split the class into focused services, each with a clear purpose. This drastically improved
readability, reduced bugs, and made it easier to add new features without risking
regressions. The project became more testable because each small class could be unit
tested independently.
Design Patterns & SOLID Design Patterns in C# · SOLID
Yes. In one project, a singleton was used without thread safety, causing race conditions
when accessed concurrently. This led to inconsistent state and application crashes. We
resolved it by implementing thread-safe lazy initialization using Lazy<T> in .NET, ensuring
the singleton instance was created safely once, even under heavy parallel access.
Design Patterns & SOLID Design Patterns in C# · SOLID
pplications?
Yes. In one project, a singleton was used without thread safety, causing race conditions
when accessed concurrently. This led to inconsistent state and application crashes. We
resolved it by implementing thread-safe lazy initialization using Lazy<T> in .NET, ensuring
the singleton instance was created safely once, even under heavy parallel access.
Design Patterns & SOLID Design Patterns in C# · SOLID
I prioritize YAGNI (You Aren’t Gonna Need It) to avoid over-engineering. SOLID principles
guide design for flexibility and maintainability, but I apply them pragmatically: start with
simple solutions and refactor as requirements evolve. Writing tests early helps identify pain
points justifying additional abstractions. Communication with the team ensures we don’t add
complexity prematurely but keep the codebase adaptable.
Design Patterns & SOLID Design Patterns in C# · SOLID
Challenges include:
performant.
Design Patterns & SOLID Design Patterns in C# · SOLID
I use a combination of:
Patterns”.
maintainability.
Bonus / Miscellaneous
Design Patterns & SOLID Design Patterns in C# · SOLID
properties from a parent class. It can lead to tight coupling and fragile hierarchies if
overused.
other classes and delegates behavior to them. It’s more flexible and promotes loose
coupling.
Design Patterns & SOLID Design Patterns in C# · SOLID
their interface. It wraps the original object to extend behavior.
or logging, without changing its interface.
Design Patterns & SOLID Design Patterns in C# · SOLID
Answer: Adapter converts the interface of a class into another interface clients expect, allowing incompatible interfaces to work together. It promotes Open/Closed Principle (OCP) by enabling new integrations without modifying existing code.
In a production Design Patterns & SOLID 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.
Design Patterns & SOLID Design Patterns in C# · SOLID
Answer: Use the Proxy or Virtual Proxy pattern where a placeholder object controls access to the real object and defers its creation until needed. In .NET, Lazy<T> provides built-in lazy loading.
In a production Design Patterns & SOLID 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.
Design Patterns & SOLID Design Patterns in C# · SOLID
explicitly.
Design Patterns & SOLID Design Patterns in C# · SOLID
Template Method defines the skeleton of an algorithm in a base class, deferring some steps
to subclasses. It allows subclasses to redefine parts of the algorithm without changing its
structure. It supports OCP by enabling extensions through inheritance.
Design Patterns & SOLID Design Patterns in C# · SOLID
SOLID promotes small, single-responsibility services (SRP), clear interfaces (ISP), loose
coupling (DIP), and extendable design (OCP). This aligns well with microservices by
encouraging modular, maintainable, and testable service boundaries.
Design Patterns & SOLID Design Patterns in C# · SOLID
Answer: The Command Pattern encapsulates requests as objects, allowing operations to be stored, undone, or redone by maintaining command history.
In a production Design Patterns & SOLID 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.
Design Patterns & SOLID Design Patterns in C# · SOLID
Answer: Use interfaces and abstractions (DIP). Apply Dependency Injection. Modularize code into bounded contexts or separate projects. Use events or messaging for decoupled communication. Avoid static state and global variables.
In a production Design Patterns & SOLID 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.
Design Patterns & SOLID Design Patterns in C# · SOLID
Answer: Encapsulates a request as an object with methods to execute and possibly undo the operation. The invoker calls commands without knowing the action details, supporting decoupling and flexible request handling.
In a production Design Patterns & SOLID 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.
Design Patterns & SOLID Design Patterns in C# · SOLID
means focused, well-defined responsibilities.
modules are independent and changes in one don’t affect others.
Design Patterns & SOLID Design Patterns in C# · SOLID
Answer: Use API contracts and versioning. Employ service discovery and load balancing. Prefer asynchronous messaging/event-driven architecture to reduce tight coupling. Apply circuit breakers and retries for fault tolerance.
In a production Design Patterns & SOLID 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.
Design Patterns & SOLID Design Patterns in C# · SOLID
Answer: Interfaces define contracts with no implementation, supporting ISP and DIP by llowing flexible implementations. Abstract classes provide a base implementation and shared code, useful for Template Method pattern and partial abstraction.
In a production Design Patterns & SOLID 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.
Design Patterns & SOLID Design Patterns in C# · SOLID
Builder separates complex object construction from its representation. For example, building
n HttpRequest with optional headers, query params, and body:
public class HttpRequestBuilder
{
private HttpRequestMessage _request = new HttpRequestMessage();
public HttpRequestBuilder SetMethod(HttpMethod method)
{
_request.Method = method;
return this;
}
public HttpRequestBuilder AddHeader(string key, string value)
{_request.Headers.Add(key, value);
return this;
}
public HttpRequestMessage Build() => _request;
}llows building requests step-by-step fluently.
Design Patterns & SOLID Design Patterns in C# · SOLID
Answer: Observer supports SRP by separating notification logic from core business logic and DIP by depending on abstractions (observers). It fits DI because observers can be injected, allowing flexible runtime subscriptions and loose coupling.
In a production Design Patterns & SOLID 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 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
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
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
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 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
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
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
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
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
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
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
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
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
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
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
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
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
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: 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: 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: 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: 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: 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: 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: 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
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
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: 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
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: 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
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
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: 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
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
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: 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: 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: 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
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
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
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
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
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
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
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: 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: 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
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
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
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
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
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
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: 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: 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
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
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 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 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
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
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: 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: 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: 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: 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
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
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: 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
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
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 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
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
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 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: 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
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
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
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
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
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
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
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
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
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: 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
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
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
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
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: 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
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: 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
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: 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: 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
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
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
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
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: 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
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
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
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: 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
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: 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: 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
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
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: 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: 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
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 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
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: 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
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
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: 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
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: 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
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: 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
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: 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
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: 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 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: 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: 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
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: 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: 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
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
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: 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: 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: 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: 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: 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
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 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
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: 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
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
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
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
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
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 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
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
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: 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: 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
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 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
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: 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
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
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: 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
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: 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: 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
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
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
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
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
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: 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
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 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: 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: 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: 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
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.