GoF Design Patterns

Gangs of Four Design Patterns

Creational Pattern

These patterns are designed for class instantiation. They can be either class-creational patterns or object-creational patterns.

Factory Method

• The Factory method offers an interface for creating an instance of a class, with its subclasses deciding which class to instantiate.

public class CardGame {
    public static CardGame createCardGame(GameType type) {
        if(type == GameType.Poker) {
            return new PokerGame();
        }
        else if(type == GameType.BlackJack) {
            return new BlackJackGame();
        }
        return null;
    }
}

Object Pooling

Object pooling is a software creational design pattern that recycles objects rather than recreating them. It does that by holding selected objects in a pool ready for use when they are requested by an application.

This process helps to improve performance by minimizing unnecessary object creation.

Unity's ObjectPool class can be used, or custom pool managers can be implemented.

Singleton

• The patterns main objective is to create only one instance of a class and to provide only one global access point to that object.

• With this description, this design pattern perfectly fits in the category of the Creational Design Patterns, because at the end, we are creating an object, with only a single instance.

public sealed class NaiveSingleton {
    private static readonly object _lockInstance = new object();
    private static NaiveSingleton _instance = null;

    private NaiveSingleton() { ... }

    public static NaiveSingleton getInstance(){
        lock(_lockInstance){
            if (_instance == null)
                _instance = new NaiveSingleton();
            return _instance;
        }
    }
}

• First, Singletons should always be a sealed in order to prevent class inheritance, which could end up with multiple instances which contradicts the purpose of Singleton.

• Second, the constructor must also be private to prevent creating new instances.

Disadvantages

• a.k.a. Anti-Pattern, because it can interfere with the unit testing and is inflexible.

Structural Pattern

These patterns are designed with regard to a class's structure and composition. The main goal pf most of these patterns is to increase the functionality of the class(es) involved, without changing much of its composition.

Behavioral Pattern

These patterns are designed depending on how one class communicates with others.

Command

The command pattern is a behavioral design pattern in which an object is used to encapsulate all information needed to perform an action or trigger an event at a later time. This information includes the method name, the object that owns the method, and values for the method parameters.

Command Design Pattern Explained with C# Examples | Syncfusion BlogsSyncfusion Blogs

Observer

The Observer pattern allows an object (the subject) to notify its dependents (observers) of changes, typically through events or delegates.

In Unity, this pattern is frequently used for event handling, UI updates, and inter-component communication.

State

State is a behavioral design pattern that lets an object alter its behavior when its internal state changes. It appears as if the object changed its class.

Unity's Animator Controller provides a visual interface for creating state machines for character animations, but you can also implement custom state machines for game logic.

Strategy

Strategy is a behavioral design pattern that lets you define a family of algorithms, put each of them into a separate class, and make their objects interchangeable.

Design Patterns