C# Design Patterns

Design patterns are proven solutions to recurring software design problems, offering developers a blueprint for creating elegant, flexible, and maintainable code. Moreover, in C#, various design patterns help streamline development and enhance code efficiency. For example, some popular design patterns include Singleton, Factory, Observer, and more.

Design patterns in C# are not just theoretical concepts; instead, they can be implemented to solve real-world coding challenges effectively.

Example: Singleton Design Pattern

private Singleton() { }

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

Example: Factory Design Pattern

public class Dog : IAnimal
{
public void Speak()
{
Console.WriteLine(“Woof!”);
}
}

public class Cat : IAnimal
{
public void Speak()
{
Console.WriteLine(“Meow!”);
}
}

public class AnimalFactory
{
public IAnimal CreateAnimal(string animalType)
{
switch (animalType)
{
case “Dog”:
return new Dog();
case “Cat”:
return new Cat();
default:
throw new ArgumentException($”Animal type {animalType} is not supported.”);
}
}
}

In this example, we use the Factory design pattern to create different animal objects without exposing the object-creation logic to the client code.

Example: Observer Design Pattern

public class ConcreteObserver : IObserver
{
private string name;

public ConcreteObserver(string name)
{
this.name = name;
}

public void Update(string message)
{
Console.WriteLine($”{name} 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);
}
}
}

In this example, we implement the Observer design pattern, enabling multiple observers (ConcreteObservers) to receive updates from a subject (Subject) when changes occur. Additionally, this pattern enhances the decoupling of components, facilitating better code organization and maintenance.