Design patterns

In short: A design pattern is a proven solution to a problem that comes up in many programs, for example Strategy, Observer, Factory Method, Singleton and Adapter.

Problem

The method that grows with every promotion

The price in the shop depends on the promotion:

static decimal FinalPrice(decimal price, string promo)
{
    if (promo == "student")
    {
        return price * 0.9m;
    }
    else if (promo == "black friday")
    {
        return Math.Max(price - 20, 0);
    }
    else if (promo == "loyal customer")
    {
        return price * 0.95m;
    }
    return price;
}

Console.WriteLine($"€{FinalPrice(120, "student"):F2}");
Console.WriteLine($"€{FinalPrice(120, "black friday"):F2}");
Console.WriteLine($"€{FinalPrice(120, "none"):F2}");

Output

€108.00
€100.00
€120.00

It works. But marketing comes up with a new promotion every month. Each one means a new else if in this method, and often in two more: the one for the invoice and the one for the confirmation email. The method knows about all the promotions at once, and every change touches it. This problem is so common that its solution has a name.

The idea

Design patterns

A design pattern is a proven solution to a problem that comes up in many programs. It is not a library and not code to copy. It is a way to arrange the classes and interfaces that has already been through thousands of projects.

Patterns fall into three groups:

• Creational: how objects are made. For example Singleton (only one object of the class) and Factory Method (something else decides which class to create).
• Structural: how classes and objects are put together into bigger ones. For example Adapter (connects incompatible interfaces) and Composite (a tree of parts that you work with as one whole).
• Behavioral: how objects split the work and talk to each other. For example Strategy (a replaceable rule) and Observer (subscribers to an event).

Why they are worth knowing:

• you do not reinvent a solution that others have already tested;
• the code changes with less risk, because the part that changes is kept separate;
• the names are a shared language. "Put an adapter here" tells a colleague a whole structure in one word.

More precisely, if you are curious

The classic catalog is the 1994 book "Design Patterns" by four authors known as the "Gang of Four" (GoF). It has 23 patterns. Here are the five you will run into most often in C# code. C# has some of them built into the language: delegates (Func, Action) do the job of Strategy, and events (event) the job of Observer. A pattern is not a goal: if one if does the job, you do not need a pattern.

See it

Strategy: a replaceable rule

The discount becomes a property of type Func<decimal, decimal>: a function that takes a price and returns a price. A type for a function like this is called a delegate in C#. The checkout does not know which promotion it is, it only calls Discount(price):

class Checkout
{
    public Func<decimal, decimal> Discount { get; set; }

    public Checkout(Func<decimal, decimal> discount)
    {
        Discount = discount;
    }

    public decimal Total(decimal price)
    {
        return Math.Max(Discount(price), 0);
    }
}

Each discount is a lambda:

var checkout = new Checkout(price => price);
Console.WriteLine($"No discount: €{checkout.Total(120):F2}");

checkout.Discount = price => price * 0.9m;
Console.WriteLine($"Student: €{checkout.Total(120):F2}");

checkout.Discount = price => price - 20;
Console.WriteLine($"Black Friday: €{checkout.Total(120):F2}");

Output

No discount: €120.00
Student: €108.00
Black Friday: €100.00

A new promotion is a new lambda. Checkout does not change. The rule can also be changed while the program is running: you store a new lambda in checkout.Discount.This is Strategy: a family of rules, each of the same type (here Func<decimal, decimal>), so they are interchangeable. The compare lambda you pass to a list's Sort is also a strategy: Sort knows how to sort, and you say what to sort by.

More precisely, if you are curious

In the books, the class that uses the strategy is called the "context" (here Checkout). In Java the strategy is an interface. In C# an interface works too, but then you cannot pass a lambda: a lambda converts to a delegate, and an interface is not a delegate.

interface IDiscountStrategy
{
    decimal Apply(decimal price);
}

IDiscountStrategy student = price => price * 0.9m;

Error

error CS1660: Cannot convert lambda expression to type 'IDiscountStrategy' because it is not a delegate type

That is why a replaceable rule made of one function is a delegate in C#. If the strategy has its own fields, it can be a class, and the checkout gets its method. new PercentDiscount(10).Apply, without parentheses, is a delegate to the Apply method of that object:

class PercentDiscount
{
    private decimal percent;

    public PercentDiscount(decimal percent)
    {
        this.percent = percent;
    }

    public decimal Apply(decimal price)
    {
        return price * (1 - percent / 100);
    }
}

var checkout = new Checkout(new PercentDiscount(10).Apply);
Console.WriteLine($"Student: €{checkout.Total(120):F2}");

Output

Student: €108.00

A class is the better choice when the strategy has its own fields or is long. A lambda, when it is one line.

See it

Observer: subscribers to an event

When the stock of a product changes, the website has to show the new count, and the warehouse has to reorder if there are only a few left. Tomorrow it may be an email to customers too. The product should not know about any of them.

class Product
{
    private string name;
    private int quantity;
    private List<Action<string, int>> listeners = new List<Action<string, int>>();

    public Product(string name, int quantity)
    {
        this.name = name;
        this.quantity = quantity;
    }

    public void Subscribe(Action<string, int> listener)
    {
        listeners.Add(listener);
    }

    public int Quantity
    {
        get { return quantity; }
        set
        {
            if (value == quantity)
            {
                return;
            }
            quantity = value;
            foreach (var listener in listeners)
            {
                listener(name, quantity);
            }
        }
    }
}

var phone = new Product("Phone", 0);
phone.Subscribe((name, qty) => Console.WriteLine($"Website: {name}, {qty} in stock"));
phone.Subscribe((name, qty) =>
{
    if (qty < 3)
    {
        Console.WriteLine($"Warehouse: reorder {name}");
    }
});

phone.Quantity = 10;
phone.Quantity = 2;

Output

Website: Phone, 10 in stock
Website: Phone, 2 in stock
Warehouse: reorder Phone

• Whoever wants to know subscribes with Subscribe and passes a lambda. Its type is Action<string, int>: a delegate that takes a name and a count and returns nothing.
• The stock is a property Quantity. On phone.Quantity = 10 its set runs: the product goes through the list and calls each subscriber. Who they are and what they do is none of its business.
• If the count has not changed, nobody is bothered.

var phone = new Product("Phone", 0);
phone.Subscribe((name, qty) => Console.WriteLine($"Website: {name}, {qty} in stock"));
phone.Subscribe((name, qty) =>
{
    if (qty < 3)
    {
        Console.WriteLine($"Warehouse: reorder {name}");
    }
});

phone.Quantity = 10;
phone.Quantity = 2;

Step by step, in words

1. Phone with 0 in stock and an empty listeners list.
2. The website subscribes: the lambda goes into the list.
3. So does the warehouse. The product does not know who they are, only that it can call them with a name and a count.
4. The stock becomes 10. The product goes through the list and calls each subscriber in the order they subscribed. The website shows the new count.
5. The warehouse checks 10 < 3: no, so it does nothing.
6. The stock becomes 2. The product goes through the list and calls each subscriber in the order they subscribed. The website shows the new count.
7. The warehouse checks 2 < 3: yes, so it reorders.

This is Observer. The product is the observed object (the subject), and the listeners are the observers. Buttons in graphical programs work exactly like this: "when clicked, call this".

More precisely, if you are curious

• In C# the list of subscribers is built into the language: an event (event). += subscribes, -= unsubscribes, and StockChanged?.Invoke(...) calls all the subscribers. With no subscribers the event is null, which is why there is ?.: then nothing is called.

class Product
{
    private string name;
    private int quantity;

    public event Action<string, int> StockChanged;

    public Product(string name, int quantity)
    {
        this.name = name;
        this.quantity = quantity;
    }

    public int Quantity
    {
        get { return quantity; }
        set
        {
            if (value == quantity)
            {
                return;
            }
            quantity = value;
            StockChanged?.Invoke(name, quantity);
        }
    }
}

• You unsubscribe the same lambda you subscribed, so you keep it in a variable. A subscriber that nobody unsubscribes stays in memory as long as the product does.

var phone = new Product("Phone", 5);
Action<string, int> site = (name, qty) => Console.WriteLine($"Website: {qty} in stock");
phone.StockChanged += site;
phone.Quantity = 4;
phone.StockChanged -= site;
phone.Quantity = 3;
Console.WriteLine("The website is no longer listening");

Output

Website: 4 in stock
The website is no longer listening

• From outside, the event can only be subscribed to and unsubscribed from. Only the class itself can raise it:

phone.StockChanged("Phone", 0);

Error

error CS0070: The event 'Product.StockChanged' can only appear on the left hand side of += or -= (except when used from within the type 'Product')

• In the old lecture the observed class is called Subject, with the methods attach and notifyAllObservers, and the observer is an abstract class with a method update(). The idea is the same, and with delegates you do not need a class for each observer.
• The listeners are called one after another in the thread that changed the count. If one of them is slow, all of them wait.

Try it

Who will hear it?

Product is the one from the card before this one.

What will the program print?

var coffee = new Product("Coffee", 5);
coffee.Subscribe((name, qty) => Console.WriteLine($"A: {qty}"));
coffee.Quantity = 4;
coffee.Quantity = 4;
coffee.Subscribe((name, qty) => Console.WriteLine($"B: {qty}"));
coffee.Quantity = 0;

Answer

A: 4
A: 0

A: 4
B: 4
A: 0
B: 0

A: 4
A: 4
A: 0
B: 0

A: 4
A: 0
B: 0

Check

See it

Factory Method: which class to create

The customer has chosen how we notify them: email or SMS. The code that sends should not write new EmailNotification() in ten places, each with its own if.

interface INotification
{
    void Send(string to, string text);
}

class EmailNotification : INotification
{
    public void Send(string to, string text)
    {
        Console.WriteLine($"Email to {to}: {text}");
    }
}

class SmsNotification : INotification
{
    public void Send(string to, string text)
    {
        Console.WriteLine($"SMS to {to}: {text}");
    }
}

The choice is in one place, in a factory:

static class NotificationFactory
{
    public static INotification Create(string channel)
    {
        return channel switch
        {
            "email" => new EmailNotification(),
            "sms" => new SmsNotification(),
            _ => throw new ArgumentException($"Unknown channel: {channel}"),
        };
    }
}

string[,] customers =
{
    { "email", "maria@example.com" },
    { "sms", "+359 88 123 4567" },
    { "pigeon", "5 Shipka St." }
};
for (int i = 0; i < customers.GetLength(0); i++)
{
    try
    {
        var n = NotificationFactory.Create(customers[i, 0]);
        n.Send(customers[i, 1], "Your order has been shipped.");
    }
    catch (ArgumentException e)
    {
        Console.WriteLine(e.Message);
    }
}

Output

Email to maria@example.com: Your order has been shipped.
SMS to +359 88 123 4567: Your order has been shipped.
Unknown channel: pigeon

The caller says what it wants ("email") and gets an INotification. Only the factory knows exactly which class is behind it. A new channel, for example push, is a new class and a new line in the switch. The sending is not touched.

More precisely, if you are curious

• This is the most common form in practice. Its more precise name is "simple factory". The Factory Method from the GoF book is something else: the parent has an abstract method that creates the object, and the subclasses decide what kind:

abstract class Shop
{
    protected abstract INotification CreateNotification();

    public void ConfirmOrder(string to)
    {
        CreateNotification().Send(to, "The order has been received.");
    }
}

class OnlineShop : Shop
{
    protected override INotification CreateNotification()
    {
        return new EmailNotification();
    }
}

class PhoneShop : Shop
{
    protected override INotification CreateNotification()
    {
        return new SmsNotification();
    }
}

new OnlineShop().ConfirmOrder("maria@example.com");
new PhoneShop().ConfirmOrder("+359 88 123 4567");

Output

Email to maria@example.com: The order has been received.
SMS to +359 88 123 4567: The order has been received.

ConfirmOrder is written once, in Shop, and does not know what notification it sends.

• In old examples the factory returns null for an unknown kind. Then the caller blows up with a NullReferenceException far from the real cause:

static class NotificationFactory
{
    public static INotification Create(string channel)
    {
        if (channel == "email")
        {
            return new EmailNotification();
        }
        if (channel == "sms")
        {
            return new SmsNotification();
        }
        return null;
    }
}

var n = NotificationFactory.Create("pigeon");
try
{
    n.Send("5 Shipka St.", "Your order has been shipped.");
}
catch (NullReferenceException e)
{
    Console.WriteLine($"NullReferenceException: {e.Message}");
}

Output

NullReferenceException: Object reference not set to an instance of an object.

An exception with a clear message in the factory is better.

See it

Singleton: only one object

The application's settings, like the currency, are read once. If every part of the program makes its own settings object, they are read many times and can drift apart.

class AppConfig
{
    private static AppConfig instance;

    public string Currency { get; } = "EUR";

    private AppConfig()
    {
        Console.WriteLine("Reading the settings...");
    }

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

var a = AppConfig.Instance;
var b = AppConfig.Instance;
Console.WriteLine(a == b);
Console.WriteLine(b.Currency);

Output

Reading the settings...
True
EUR

• The constructor is private. Nobody outside the class can write new AppConfig().
• The only object is in the static field instance. The property Instance creates it the first time it is read and then always returns that one.
• "Reading the settings..." is printed once, and a == b is True: there is one object.

This is Singleton.

More precisely, if you are curious

• If two threads (parts of the program that run at the same time) read Instance at the same moment, both may see null and create two objects.
• The safest Singleton in C# is a static readonly field. The runtime initializes the static fields of a class exactly once, before the class is used, even when many threads ask for it at once:

class Settings
{
    public static readonly Settings Instance = new Settings();

    public string Currency { get; } = "EUR";

    private Settings()
    {
        Console.WriteLine("Creating the settings...");
    }
}

Console.WriteLine(Settings.Instance.Currency);
Console.WriteLine(Settings.Instance == Settings.Instance);

Output

Creating the settings...
EUR
True

• If creating the object is expensive and should happen only when it is needed, there is Lazy<T>. The object is created on the first .Value, also once and also with many threads:

class AppConfig
{
    private static readonly Lazy<AppConfig> instance = new Lazy<AppConfig>(() => new AppConfig());

    public string Currency { get; } = "EUR";

    private AppConfig()
    {
        Console.WriteLine("Reading the settings...");
    }

    public static AppConfig Instance
    {
        get { return instance.Value; }
    }
}

Console.WriteLine("The program starts");
var a = AppConfig.Instance;
var b = AppConfig.Instance;
Console.WriteLine(a == b);

Output

The program starts
Reading the settings...
True

• A Singleton is a global variable for the whole program with a nice name. Anyone can use it from anywhere, so it is hard to test and hard to replace. It is often better to create the object once in Main and pass it through the constructor to the ones that use it.

Try it

Find the bug

Order numbers have to be unique, so the counter is a Singleton. But the program gave out the number 1001 twice:

Console.WriteLine(OrderNumbers.Instance.NextNumber());
Console.WriteLine(OrderNumbers.Instance.NextNumber());
Console.WriteLine(new OrderNumbers().NextNumber());

Output

1001
1002
1001

Which line in the class is the bug on?

Pick the line with the bug.

1class OrderNumbers2{3 private static OrderNumbers instance;4 private int next = 1001;56 public OrderNumbers()7 {8 }910 public static OrderNumbers Instance11 {12 get13 {14 if (instance == null)15 {16 instance = new OrderNumbers();17 }18 return instance;19 }20 }2122 public int NextNumber()23 {24 return next++;25 }26}

Check

See it

Adapter: connects incompatible interfaces

The shop pays through an interface with an amount in euros and a "yes or no" answer. The bank gives you an old library that wants cents and returns an error code. The library is not yours, and you cannot change it.

// The bank's old library. You cannot change it.
class LegacyBankClient
{
    // The amount is in cents. Returns 0 on success and an error code otherwise.
    public int Charge(long cents, string reference)
    {
        Console.WriteLine($"Bank: {cents} cents for {reference}");
        return cents <= 50000 ? 0 : 51;
    }
}

You write a class that looks like what the shop expects, and inside it calls the bank:

// This is what the shop expects.
interface IPaymentGateway
{
    bool Pay(string orderId, decimal amountEur);
}

class BankAdapter : IPaymentGateway
{
    private LegacyBankClient bank;

    public BankAdapter(LegacyBankClient bank)
    {
        this.bank = bank;
    }

    public bool Pay(string orderId, decimal amountEur)
    {
        long cents = (long)Math.Round(amountEur * 100);
        return bank.Charge(cents, "ORDER-" + orderId) == 0;
    }
}

IPaymentGateway gateway = new BankAdapter(new LegacyBankClient());
Console.WriteLine(gateway.Pay("1001", 49.90m));
Console.WriteLine(gateway.Pay("1002", 1299.00m));

Output

Bank: 4990 cents for ORDER-1001
True
Bank: 129900 cents for ORDER-1002
False

The adapter translates in both directions: euros into cents and a number into text on the way there, code 0 into true on the way back. The shop does not know there is an old library behind it. If tomorrow you change banks, you write a new adapter, and the shop is not touched.

This is Adapter: like a plug adapter that changes neither the plug nor the wall.

More precisely, if you are curious

The classic example in the books, and in the old lecture, is a media player. AudioPlayer can play only mp3, and an existing class AdvancedMediaPlayer has the methods playVlc and playMp4. MediaAdapter implements the player's interface and forwards to the right method. The structure is the same as here.

Exercise

Patterns in the shop

Solve the tasks in your editor.

1. Discounts as strategies. A static class Discounts with methods that return a lambda of type Func<decimal, decimal>: None(), Percent(decimal p) and Fixed(decimal amount) (never below €0). A class Cart with a list of prices and a replaceable discount in the property Discount. Add coffee beans (€18.50), honey (€12) and tea (€4.20), and print the total with no discount, with −10%, with −€5 and with −€50.

Output

No discount: €34.70
-10%: €31.23
-€5: €29.70
-€50: €0.00

2. "Notify me when it is in stock". The product keeps a list of customers who are waiting. When the stock goes from 0 to more than 0, it notifies all of them and clears the list, because the notification is one-time. The console has 0 in stock, Maria and Georgi subscribe, then the stock becomes 5, 0 and 3.

Output

Email to Maria: Console is in stock (5 units)
SMS to Georgi: Console is in stock
End

3. A notification factory. Add PushNotification and a factory for the three channels that ignores uppercase and lowercase. Read a number of lines and then lines "channel;address". Send "Your reservation is confirmed." to each address, and for an unknown channel print the exception's message.

Input

4
Email;maria@example.com
sms;+359 88 123 4567
push;Elena's phone
fax;02 123 456

Output

Email to maria@example.com: Your reservation is confirmed.
SMS to +359 88 123 4567: Your reservation is confirmed.
Push to Elena's phone: Your reservation is confirmed.
Unknown channel: fax

4. An old thermometer. A class OldThermometer returns the temperature in Fahrenheit with ReadFahrenheit(). The new system works with interface ITemperatureSensor { double Celsius(); }. Write ThermometerAdapter (°C = (°F − 32) × 5 / 9). In a list of sensors, put two old thermometers (71.6 °F and 39.2 °F) through the adapter, and one new sensor DigitalSensor that returns 21.5 °C. A lambda does not work here: the interface is not a delegate.

Output

Office: 22.0 °C
Warehouse: 4.0 °C
Server room: 21.5 °C

More tasks

• Shipping as a strategy. Make a Func<decimal, decimal> for the shipping price to an office, to an address and from the store, and put the chosen one in the checkout together with the discount.
• A log as a Singleton. A class Logger with a property Instance and a method Log(string text) that numbers the lines. Check that the numbers continue when you call it from two different methods.
• A price observer. Add an event for price changes to the product, and send a notification only when the price drops by at least 10%.

Test

Check yourself

1. What is a design pattern?

A proven, named solution to a problem that keeps coming up: an idea for how to arrange the classesA compiler ruleA ready-made library you add to the project

2. Every new promotion in the shop adds a new else if to the price method. Which pattern helps?

AdapterSingletonStrategy: each discount is a separate lambda of type Func<decimal, decimal>, and the checkout is told which one to use

3. The product tells the website, the warehouse and the email system when the stock changes, without knowing who they are. Which pattern is it?

Factory MethodSingletonObserver

4. What does Singleton prevent?

The fields being changedA second object being created: the constructor is private, and the only object is obtained through the Instance propertyThe class being extended

5. You have an old class that returns the temperature in Fahrenheit, and the program expects an interface ITemperatureSensor with a method Celsius(). What do you do?

Factory MethodRewrite the old classAdapter: a new class implements the interface and calls the old one inside, converting the values

Check

The idea

Next: the patterns up close

Here you saw five patterns briefly, with lambdas. The Software engineering course has a whole module on patterns: each one starts from code that hurts, has an animation of which object calls which, and says when you don't need it. Builder, Decorator, Composite, Command, State, Template Method, Iterator and Repository are there too.

The module is here: Design patterns.

Start the lesson over

Related lessons

• Builds on: Lists · Nested classes · Lambdas and delegates · record, switch and patterns
• Continues in: Why patterns · Strategy · Observer · Factory Method and Simple Factory
• Tasks on this topic: Modern C#