Overview
Design patterns are fundamental strategies for solving common software design problems. In object-oriented programming (OOP), patterns like Singleton, Factory, and Observer are crucial for creating flexible, reusable, and maintainable code. They help in solving specific design issues, reducing the overall coding effort, and improving code readability and scalability.
Key Concepts
- Singleton Pattern: Ensures a class has only one instance and provides a global point of access to it.
- Factory Pattern: Defines an interface for creating an object but lets subclasses alter the type of objects that will be created.
- Observer Pattern: Defines a dependency between objects so that when one object changes its state, all its dependents are notified and updated automatically.
Common Interview Questions
Basic Level
- What is the Singleton pattern and where would you use it?
- Can you explain the Factory Method pattern with an example?
Intermediate Level
- How does the Observer pattern facilitate loose coupling between objects?
Advanced Level
- Discuss the trade-offs between using the Singleton pattern versus Dependency Injection for managing single instances in an application.
Detailed Answers
1. What is the Singleton pattern and where would you use it?
Answer: The Singleton pattern ensures a class has only one instance and provides a global point of access to that instance. It is useful in scenarios where multiple objects need to access a shared resource, like a database connection or a configuration manager.
Key Points:
- Ensures one instance: Prevents the instantiation of more than one object.
- Global access: Provides a static method that returns the instance of the singleton class.
- Lazy initialization: The instance is created only when it is needed for the first time.
Example:
public class DatabaseConnection
{
private static DatabaseConnection _instance;
private static readonly object _lock = new object();
// Constructor is 'protected' to prevent instantiation outside the class.
protected DatabaseConnection() {}
public static DatabaseConnection GetInstance()
{
if (_instance == null)
{
lock (_lock)
{
if (_instance == null)
{
_instance = new DatabaseConnection();
}
}
}
return _instance;
}
public void Connect()
{
Console.WriteLine("Database Connected");
}
}
2. Can you explain the Factory Method pattern with an example?
Answer: The Factory Method pattern defines an interface for creating an object but allows subclasses to alter the type of objects that will be created. It is used when there is a need to delegate the instantiation logic to child classes.
Key Points:
- Promotes loose coupling by reducing the dependency of the client code on the concrete classes.
- Enhances flexibility by allowing new types to be introduced with minimal changes to existing code.
- Supports the Open/Closed principle by allowing the code to be open for extension but closed for modification.
Example:
public abstract class VehicleFactory
{
public abstract IVehicle CreateVehicle();
}
public class CarFactory : VehicleFactory
{
public override IVehicle CreateVehicle()
{
return new Car();
}
}
public interface IVehicle
{
void Drive();
}
public class Car : IVehicle
{
public void Drive()
{
Console.WriteLine("Driving a car");
}
}
// Usage
class Program
{
static void Main(string[] args)
{
VehicleFactory factory = new CarFactory();
IVehicle vehicle = factory.CreateVehicle();
vehicle.Drive();
}
}
3. How does the Observer pattern facilitate loose coupling between objects?
Answer: The Observer pattern allows objects (observers) to subscribe to event notifications from a subject. It promotes loose coupling because the subject doesn't need to know anything about the observers, beyond the fact that they implement a certain interface. This pattern is widely used in implementing distributed event handling systems, such as model-view-controller (MVC) architectures.
Key Points:
- Decouples the subject from its observers, allowing them to interact without being tightly bound.
- Enhances flexibility and reusability by allowing objects to be added or removed dynamically.
- Simplifies maintenance and evolution of the system by segregating the subject and observer roles.
Example:
public interface IObserver
{
void Update(string message);
}
public class Observer : IObserver
{
public void Update(string message)
{
Console.WriteLine($"Received message: {message}");
}
}
public class Subject
{
private List<IObserver> _observers = new List<IObserver>();
public void Attach(IObserver observer)
{
_observers.Add(observer);
}
public void Detach(IObserver observer)
{
_observers.Remove(observer);
}
public void Notify(string message)
{
foreach (var observer in _observers)
{
observer.Update(message);
}
}
}
// Usage
class Program
{
static void Main(string[] args)
{
Subject subject = new Subject();
IObserver observer = new Observer();
subject.Attach(observer);
subject.Notify("Hello World");
}
}
4. Discuss the trade-offs between using the Singleton pattern versus Dependency Injection for managing single instances in an application.
Answer:
Using the Singleton pattern directly within a class can make testing difficult due to its global state and the inability to mock or replace instances in tests. It also leads to tight coupling between the Singleton class and its consumers.
Dependency Injection (DI), on the other hand, allows for more flexible and testable design by decoupling the creation of the object from its consumption. It enables the management of single instances through DI containers, making it easier to replace instances for testing or during runtime.
Key Points:
- Singletons can lead to hidden dependencies, making code harder to read and maintain.
- DI promotes loose coupling and makes the system more modular and testable.
- While Singletons can be simpler to implement, DI provides a more scalable and flexible approach for managing single instances and dependencies.
Example: Not applicable as the answer discusses conceptual trade-offs rather than specific code implementations.
