Design Patterns
Example 1: Constructor Injection
Constructor Injection is the most common form of DI, where dependencies are injected through a class constructor. Here's a practical example:
Service Interface
public interface ILogger
{
void Log(string message);
}
Concrete Logger Implementation
public class ConsoleLogger : ILogger
{
public void Log(string message)
{
Console.WriteLine($"Logging message: {message}");
}
}
Client Class with Constructor Injection
public class ClientService
{
private readonly ILogger _logger;
// Constructor Injection
public ClientService(ILogger logger)
{
_logger = logger;
}
public void Process(string data)
{
_logger.Log($"Processing data: {data}");
// Perform business logic
}
}
Dependency Injection Setup and Usage
class Program
{
static void Main(string[] args)
{
// Setup DI container (manually without a framework)
ILogger logger = new ConsoleLogger();
ClientService clientService = new ClientService(logger);
// ClientService is now ready to use with injected ILogger
clientService.Process("Sample data");
}
}
General Tips!
- Identify Common Problems: Recognize recurring problems in your code to determine which design pattern can provide a solution.
- Understand the Principles: Familiarize yourself with SOLID principles as they often align with the motivations behind design patterns.
- Use Patterns Judiciously: Avoid overusing patterns; apply them only when they provide a clear benefit.
- Learn by Example: Study real-world examples of design patterns to see how they are implemented in practice.
- Refactor When Necessary: Don’t force a pattern from the start; refactor your code to introduce patterns when a need becomes apparent.
- Stay Flexible: Patterns are guidelines, not strict rules. Adapt them to fit your specific context.
- Document Your Design: Clearly document the use of design patterns to help future maintainers understand your design decisions.