Interview Q&A

Short answer: dditional checks like authentication or caching. Conclusion: The Proxy Pattern is an excellent design pattern to control access to expensive or sensitive objects.

Real-world example (ShopNest)

Use a GoF pattern in ShopNest only when it removes duplication or makes a change safer—explain the problem it solves in the interview.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

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

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: nimals) can be cloned from a prototype, allowing for rapid creation of multiple instances with different states.

Explain a bit more

Deep Cloning Example: If you need to perform deep cloning, where not just the properties but also the referenced objects are cloned, you can adjust the Clone() method to handle the deep copy: public class GameCharacter : ICloneable { public string Name { get; set; } public int Health { get; set; } public List<string> Inventory { get; set; } = new List<string>(); public ICloneable Clone() { var clone = new GameCharacter { Name = this.Name, Health = this.Health, Inventory = new List<string>(this.Inventory) // Deep copy of the Inventory list }; return clone; } } In this case, the Inventory list will also be cloned to ensure that modifications to the Inventory of the clone do not affect the…… public int Health { get; set; }

Example code

public List<string> Inventory { get; set; } = new
List<string>();
public ICloneable Clone()
{
var clone = new GameCharacter
{ Name = this.Name, Health = this.Health, Inventory = new List<string>(this.Inventory) // Deep copy of the Inventory list }; return clone;
}
} In this case, the Inventory list will also be cloned to ensure that modifications to the Inventory of the clone do not affect the original object. Conclusion: The Prototype Pattern is a powerful creational pattern that allows you to clone objects instead of creating them from scratch. It's especially useful when dealing with complex objects or systems where performance and resource management are important. By using this pattern, you can quickly create new objects with similar attributes and save time and resources that would otherwise be spent constructing them from scratch. Proxy Pattern: Controlling Access to Expensive Resources Definition: The Proxy Pattern provides a surrogate or placeholder for another object to control access to it. The proxy acts as an intermediary, enabling you to perform additional actions (e.g., lazy loading, access control, logging) before or after delegating operations to the real object. Use Case: The Proxy Pattern is useful when you need to control access to an expensive or resource-intensive object. A common use case is controlling access to resources like large images, network connections, or database connections. Instead of creating the actual object immediately, a proxy can delay its creation or manage its lifecycle efficiently. Code Breakdown:

Real-world example (ShopNest)

Use a GoF pattern in ShopNest only when it removes duplication or makes a change safer—explain the problem it solves in the interview.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: And implements the Update() method to receive news updates from the publisher.

Explain a bit more

public class NewsSubscriber : IObserver { private readonly string _name; public NewsSubscriber(string name) => _name = name; public void Update(string news) => Console.WriteLine($"{_name} received news: {news}"); } And implements the Update() method to receive news updates from the publisher. public class NewsSubscriber : IObserver { private readonly string _name; public NewsSubscriber(string name) => _name = name;

Example code

public void Update(string news) => Console.WriteLine($"{_name} received news: {news}"); }

Real-world example (ShopNest)

When order status changes, observers update email, SMS, and analytics without the Order class knowing each one.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

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

Real-world example (ShopNest)

Use a GoF pattern in ShopNest only when it removes duplication or makes a change safer—explain the problem it solves in the interview.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: s an expression, and the pattern allows for flexible and extensible parsing rules. Improvement Suggestions:

Real-world example (ShopNest)

Use a GoF pattern in ShopNest only when it removes duplication or makes a change safer—explain the problem it solves in the interview.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: ny component and let the pattern take care of the rest. Real-Time Use Case Example:

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: By adding new visitors (e.g., another visitor for tax calculation or shipping fees), you can introduce new operations on the same set of elements without modifying their classes. This is the key benefit of the Visitor Pattern. Benefits of the Visitor Pattern:

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: The concrete visitor ShoppingCart implements the IShoppingCartVisitor interface. It performs specific operations on each element, like calculating the total cost with any applicable discounts. For instance, it applies a 10% discount to books but no discount to fruits. public class ShoppingCart : IShoppingCartVisitor

Example code

{
private double _total;
public void Visit(Book book) => _total += book.Price * 0.9; // 10% discount on books public void Visit(Fruit fruit) => _total += fruit.Price; // No discount on fruits public double GetTotal() => _total;
}

Real-world example (ShopNest)

Use a GoF pattern in ShopNest only when it removes duplication or makes a change safer—explain the problem it solves in the interview.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: The template method ensures that the overall process (e.g., cooking) is always followed in the same sequence, regardless of the specific recipe. This prevents inconsistent workflows in different implementations. When to Use the Template Method Pattern:

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: When you have multiple classes implementing the same algorithm in slightly different ways, the Strategy Pattern can centralize and avoid code duplication. Drawbacks of the Strategy Pattern:

Real-world example (ShopNest)

Use a GoF pattern in ShopNest only when it removes duplication or makes a change safer—explain the problem it solves in the interview.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Each sorting algorithm can be tested independently. Since the algorithms are encapsulated in their own classes, you don't need to test them within the context class. When to Use the Strategy Pattern:

Real-world example (ShopNest)

Use a GoF pattern in ShopNest only when it removes duplication or makes a change safer—explain the problem it solves in the interview.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: The client (in the Main method) interacts with the Sorter object and can change the strategy at runtime. This makes the system adaptable to different sorting needs without changing the core structure. Benefits of the Strategy Pattern:

Real-world example (ShopNest)

Use a GoF pattern in ShopNest only when it removes duplication or makes a change safer—explain the problem it solves in the interview.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: The state-specific behavior is encapsulated within its corresponding class, making it easier to add or modify states without affecting the rest of the system. You can add new states without altering the existing code too much. When to Use the State Pattern:

Real-world example (ShopNest)

Use a GoF pattern in ShopNest only when it removes duplication or makes a change safer—explain the problem it solves in the interview.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Each time the Change method is called, the current state will perform its action and then set the next state, allowing the traffic light to cycle through its states (Red → Green → Yellow → Red). Benefits of the State Pattern:

Real-world example (ShopNest)

Use a GoF pattern in ShopNest only when it removes duplication or makes a change safer—explain the problem it solves in the interview.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: The Singleton Pattern makes it harder to extend or inherit the class due to its static nature.

Explain a bit more

Conclusion: The Singleton Pattern is a powerful tool for ensuring that a class has only one instance and provides a global access point to that instance.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: This is a more advanced form of lazy initialization that avoids the performance overhead of locking once the instance has been created. public class Singleton

Example code

{
private static Singleton _instance;
private static readonly object _lock = new object();
private Singleton() { }
public static Singleton Instance
{ get {
if (_instance == null)
{ lock (_lock) {
if (_instance == null)
{
_instance = new Singleton();
}
}
}
return _instance;
}
}
}

Real-world example (ShopNest)

Use a GoF pattern in ShopNest only when it removes duplication or makes a change safer—explain the problem it solves in the interview.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: The pattern provides a global access point to the instance, allowing all parts of the application to access the same object without the need for passing references. When to Use the Singleton Pattern:

Real-world example (ShopNest)

Use a GoF pattern in ShopNest only when it removes duplication or makes a change safer—explain the problem it solves in the interview.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: A proxy could manage the interaction with external web services, controlling when to send requests and how to handle responses.

Explain a bit more

It can also perform additional checks like authentication or caching.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Stores the results of expensive operations and returns cached results for subsequent requests, improving performance by avoiding redundant operations. Real-Time Use Case Examples:

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: In simulation software, objects representing physical entities (e.g., cars, animals) can be cloned from a prototype, allowing for rapid creation of multiple instances with different states.

Explain a bit more

Deep Cloning Example: If you need to perform deep cloning, where not just the properties but also the referenced objects are cloned, you can adjust the Clone() method to handle the deep copy: public class GameCharacter : ICloneable

Example code

{
public string Name { get; set; }
public int Health { get; set; }
public List<string> Inventory { get; set; } = new
List<string>();
public ICloneable Clone()
{
var clone = new GameCharacter
{ Name = this.Name, Health = this.Health, Inventory = new List<string>(this.Inventory) // Deep copy of the Inventory list }; return clone;
}
} In this case, the Inventory list will also be cloned to ensure that modifications to the Inventory of the clone do not affect the original object. Conclusion: The Prototype Pattern is a powerful creational pattern that allows you to clone objects instead of creating them from scratch. It's especially useful when dealing with complex objects or systems where performance and resource management are important. By using this pattern, you can quickly create new objects with similar attributes and save time and resources that would otherwise be spent constructing them from scratch. Proxy Pattern: Controlling Access to Expensive Resources Definition: The Proxy Pattern provides a surrogate or placeholder for another object to control access to it. The proxy acts as an intermediary, enabling you to perform additional actions (e.g., lazy loading, access control, logging) before or after delegating operations to the real object. Use Case: The Proxy Pattern is useful when you need to control access to an expensive or resource-intensive object. A common use case is controlling access to resources like large images, network connections, or database connections. Instead of creating the actual object immediately, a proxy can delay its creation or manage its lifecycle efficiently. Code Breakdown:

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: In stock trading applications, investors (observers) can subscribe to specific stock prices (subjects) to receive real-time updates whenever the stock price changes.

Real-world example (ShopNest)

Use a GoF pattern in ShopNest only when it removes duplication or makes a change safer—explain the problem it solves in the interview.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: The pattern is highly scalable. You can have multiple observers without significantly affecting performance, as the publisher simply iterates through the list of observers. Considerations:

Real-world example (ShopNest)

Use a GoF pattern in ShopNest only when it removes duplication or makes a change safer—explain the problem it solves in the interview.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: The NewsSubscriber class represents an observer. Each subscriber has a name and implements the Update() method to receive news updates from the publisher. public class NewsSubscriber : IObserver

Example code

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

Real-world example (ShopNest)

When order status changes, observers update email, SMS, and analytics without the Order class knowing each one.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.

Short answer: Spreadsheet applications like Excel often use the Memento Pattern to save different states of a spreadsheet, enabling the user to undo changes like deleting a cell or modifying a formula.

Explain a bit more

Visual Diagram: +----------------+ +--------------------+ | TextEditor | Save() | TextMemento | | (Originator) |------------>| (Memento) | +----------------+ +--------------------+ | ^ Write Text Restore | | v | +----------------+ +--------------------+ | Caretaker |<------------| TextMemento | | (History) | Undo() | (Memento) | +----------------+ +--------------------+ Conclusion: The Memento Pattern is a powerful design pattern for handling state restoration in software systems, especially when implementing undo functionality.

Say this in the interview

1. Define — one clear sentence (the short answer above).
2. Example — relate it to a project like ShopNest or your real work.
3. Trade-off — when you would not use it.