: +371-28328580

GoF design patterns

12 Jan

GoF design patterns

All

The Gang of Four (GoF) Design Patterns, introduced in the book “Design Patterns: Elements of Reusable Object-Oriented Software”, provide a set of best practices for solving common software design problems. These patterns are grouped into three categories: Creational, Structural, and Behavioral.

Here’s an overview of the GoF patterns and their implementation in .NET:

1. Creational Patterns

These deal with object creation mechanisms.

1.1 Singleton

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

.NET Example:

public sealed class Singleton
{
private static readonly Lazy<Singleton> _instance = new(() => new Singleton());
public static Singleton Instance => _instance.Value;
private Singleton() { }
}
  • Use Case: Logging, configuration management, or caching.

1.2 Factory Method

Defines an interface for creating objects but allows subclasses to alter the type of objects created.

.NET Example:

public abstract class Creator
{
public abstract IProduct FactoryMethod();
}
public class ConcreteCreator : Creator
{
public override IProduct FactoryMethod() => new ConcreteProduct();
}
public interface IProduct { }
public class ConcreteProduct : IProduct { }
  • Use Case: When the exact type of object isn’t known until runtime.

1.3 Abstract Factory

Provides an interface for creating families of related or dependent objects.

.NET Example:

public interface IUIFactory
{
IButton CreateButton();
ITextBox CreateTextBox();
}
public class WindowsUIFactory : IUIFactory
{
public IButton CreateButton() => new WindowsButton();
public ITextBox CreateTextBox() => new WindowsTextBox();
}
public interface IButton { }
public class WindowsButton : IButton { }
public interface ITextBox { }
public class WindowsTextBox : ITextBox { }
  • Use Case: Cross-platform UI libraries or themes.

1.4 Builder

Separates the construction of a complex object from its representation.

.NET Example:

public class Product
{
public string PartA { get; set; }
public string PartB { get; set; }
}
public interface IBuilder
{
void BuildPartA();
void BuildPartB();
Product GetResult();
}
public class ConcreteBuilder : IBuilder
{
private Product _product = new();
public void BuildPartA() => _product.PartA = "PartA";
public void BuildPartB() => _product.PartB = "PartB";
public Product GetResult() => _product;
}
  • Use Case: Constructing complex objects step by step.

1.5 Prototype

Creates new objects by copying an existing object.

.NET Example:

public abstract class Prototype
{
public abstract Prototype Clone();
}
public class ConcretePrototype : Prototype
{
public int Property { get; set; }
public override Prototype Clone() => (Prototype)this.MemberwiseClone();
}
  • Use Case: When object creation is expensive or complex.

2. Structural Patterns

These deal with the composition of classes or objects.

2.1 Adapter

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

.NET Example:

public interface ITarget
{
void Request();
}
public class Adaptee
{
public void SpecificRequest() { }
}
public class Adapter : ITarget
{
private readonly Adaptee _adaptee = new();
public void Request() => _adaptee.SpecificRequest();
}
  • Use Case: Integrating legacy systems.

2.2 Bridge

Separates an abstraction from its implementation so they can vary independently.

.NET Example:

public abstract class Shape
{
protected IRenderer Renderer;
protected Shape(IRenderer renderer) => Renderer = renderer;
public abstract void Draw();
}
public class Circle : Shape
{
public Circle(IRenderer renderer) : base(renderer) { }
public override void Draw() => Renderer.Render("Circle");
}
public interface IRenderer
{
void Render(string shape);
}
public class VectorRenderer : IRenderer
{
public void Render(string shape) => Console.WriteLine($"Drawing {shape} as lines.");
}
  • Use Case: Supporting multiple platforms.

2.3 Composite

Composes objects into tree structures to represent part-whole hierarchies.

.NET Example:

public interface IComponent
{
void Operation();
}
public class Leaf : IComponent
{
public void Operation() => Console.WriteLine("Leaf operation.");
}
public class Composite : IComponent
{
private readonly List<IComponent> _children = new();
public void Add(IComponent component) => _children.Add(component);
public void Operation()
  {
   foreach (var child in _children) child.Operation();
  }
}
  • Use Case: GUI hierarchies or organizational charts.

3. Behavioral Patterns

These deal with object communication.

3.1 Observer

Defines a dependency between objects so that when one object changes state, all dependents are notified.

.NET Example:

public class Subject
{
private readonly List<IObserver> _observers = new();
public void Attach(IObserver observer) => _observers.Add(observer);
public void Notify() => _observers.ForEach(o => o.Update());
}
public interface IObserver
{
void Update();
}
public class ConcreteObserver : IObserver
{
public void Update() => Console.WriteLine("Observer notified.");
}
  • Use Case: Event systems, real-time updates.

3.2 Strategy

Defines a family of algorithms, encapsulates each one, and makes them interchangeable.

.NET Example:

public interface IStrategy
{
void Execute();
}
public class ConcreteStrategyA : IStrategy
{
public void Execute() => Console.WriteLine("Strategy A executed.");
}
public class Context
{
private IStrategy _strategy;
public Context(IStrategy strategy) => _strategy = strategy;
public void SetStrategy(IStrategy strategy) => _strategy = strategy;
public void Execute() => _strategy.Execute();
}
  • Use Case: Algorithms with interchangeable implementations.

3.3 Command

Encapsulates a request as an object.

.NET Example:

public interface ICommand
{
void Execute();
}
public class LightOnCommand : ICommand
{
private readonly Light _light;
public LightOnCommand(Light light) => _light = light;
public void Execute() => _light.On();
}
public class Light
{
public void On() => Console.WriteLine("Light is on.");
}
  • Use Case: Undo/redo systems.

This is a concise overview of implementing GoF design patterns in .NET. These patterns provide reusable solutions for common software problems and enhance maintainability, scalability, and flexibility.

*AI generated

Archives

Categories