Introduction to Design Patterns

Design patterns are reusable solutions to common problems in software design. They provide templates for solving problems and can streamline development, promote code reuse, and make code easier to maintain.

Design patterns are categorized into three main types:

1. Creational Patterns: Deal with object creation mechanisms.
2. Structural Patterns: Focus on the composition of classes and objects.
3. Behavioral Patterns: Concerned with communication between objects.

Why Use Design Patterns?

1. Reusability: Solving similar problems using proven solutions saves time and effort.
2. Maintainability: Patterns make your code more modular and easier to update.
3. Scalability: They provide a foundation for building complex systems that are easier to scale.
4. Readability: Patterns make the code more understandable, especially for teams familiar with them.

Commonly Used Design Patterns

1. Singleton Pattern (Creational)

Purpose: Ensures a class has only one instance and provides a global point of access to it.

Example (C#):

public class Singleton
{
    private static Singleton _instance;

    private Singleton() { }

    public static Singleton Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = new Singleton();
            }
            return _instance;
        }
    }
}

Usage: For scenarios like logging, configuration management, or database connections.

2. Factory Method (Creational)

Purpose: Creates objects without specifying the exact class of object to be created.

Example (C#):

public abstract class Product
{
    public abstract string GetName();
}

public class ConcreteProductA : Product
{
    public override string GetName() => "Product A";
}

public class ConcreteProductB : Product
{
    public override string GetName() => "Product B";
}

public abstract class Creator
{
    public abstract Product CreateProduct();
}

public class ConcreteCreatorA : Creator
{
    public override Product CreateProduct() => new ConcreteProductA();
}

public class ConcreteCreatorB : Creator
{
    public override Product CreateProduct() => new ConcreteProductB();
}

Usage: Useful when the client code needs to work with objects without knowing their concrete types.

3. Adapter Pattern (Structural)

Purpose: Converts an interface of a class into another interface that the client expects.

Example (C#):

public interface ITarget
{
    string GetRequest();
}

public class Adaptee
{
    public string GetSpecificRequest() => "Specific Request";
}

public class Adapter : ITarget
{
    private readonly Adaptee _adaptee;

    public Adapter(Adaptee adaptee)
    {
        _adaptee = adaptee;
    }

    public string GetRequest() => _adaptee.GetSpecificRequest();
}

Usage: When integrating with a legacy system or third-party library.

4. Observer Pattern (Behavioral)

Purpose: Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified.

Example (C#):

public interface IObserver
{
    void Update(string message);
}

public class ConcreteObserver : IObserver
{
    private readonly string _name;

    public ConcreteObserver(string name)
    {
        _name = name;
    }

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

public class Subject
{
    private readonly List<IObserver> _observers = new();

    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: Suitable for event-driven architectures, such as UI frameworks or notification systems.

Steps to Implement Design Patterns

1. Understand the Problem: Identify the scenario where the design pattern fits.
2. Select the Pattern: Choose a pattern based on its intent and application.
3. Implement the Pattern: Apply the pattern with customization for your specific problem.
4. Test the Solution: Ensure the implemented pattern meets the requirements and improves the design.

Resources for Learning More

1. Books: Design Patterns: Elements of Reusable Object-Oriented Software by the “Gang of Four” (GoF).
2. Websites:
   • Refactoring.Guru
   • TutorialsPoint
3. Courses: Look for Udemy or Pluralsight courses on design patterns.

By using design patterns in your projects, you can improve code quality and design. Start with the simpler patterns like Singleton and Factory, and as you gain confidence, explore more complex patterns like Command and Composite.