Code Anyway: Design Patterns: Common design patterns (Singleton, Factory, Observer, etc.) and their implementations in C#.

Saturday, June 22, 2024

Design Patterns: Common design patterns (Singleton, Factory, Observer, etc.) and their implementations in C#.

Design Patterns: Common design patterns and their implementations in C#

Design patterns are reusable solutions to common problems in software design. In this blog post, we will explore some of the most commonly used design patterns in C# and their implementations.

Singleton Pattern

The Singleton pattern ensures that a class has only one instance and provides a global point of access to that instance. Here is an example implementation in C#:


public class Singleton
{
    private static Singleton instance;

    private Singleton() { }

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

Usage:


Singleton singleton = Singleton.Instance;

Factory Pattern

The Factory pattern is used to create objects without exposing the instantiation logic to the client. Here is an example implementation in C#:


public interface IProduct
{
    void Operation();
}

public class ConcreteProduct : IProduct
{
    public void Operation()
    {
        Console.WriteLine("ConcreteProduct.Operation");
    }
}

public class Factory
{
    public IProduct CreateProduct()
    {
        return new ConcreteProduct();
    }
}

Usage:


Factory factory = new Factory();
IProduct product = factory.CreateProduct();
product.Operation();

Observer Pattern

The Observer pattern defines a one-to-many relationship between objects so that when one object changes state, all its dependents are notified and updated automatically. Here is an example implementation in C#:


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

public class ConcreteObserver : IObserver
{
    public void Update(string message)
    {
        Console.WriteLine("ConcreteObserver received message: " + message);
    }
}

public class Subject
{
    private List observers = new List();

    public void Attach(IObserver observer)
    {
        observers.Add(observer);
    }

    public void Notify(string message)
    {
        foreach (var observer in observers)
        {
            observer.Update(message);
        }
    }
}

Usage:


Subject subject = new Subject();
ConcreteObserver observer1 = new ConcreteObserver();
ConcreteObserver observer2 = new ConcreteObserver();

subject.Attach(observer1);
subject.Attach(observer2);

subject.Notify("Hello Observers!");

Common Use Cases

Design patterns are commonly used in software development to improve code quality, maintainability, and scalability. They provide solutions to recurring design problems and help in organizing code in a more structured and efficient manner.

Importance in Interviews

Understanding design patterns is crucial for software developers, especially in job interviews. Recruiters often ask questions related to design patterns to assess a candidate's problem-solving skills and knowledge of best practices in software design.

Conclusion

In this blog post, we explored some common design patterns and their implementations in C#. Design patterns play a crucial role in software development by providing reusable solutions to common design problems. By incorporating design patterns in your code, you can improve code quality, maintainability, and scalability.