The Observer Pattern Alternatives

Observer Pattern Alternatives

The Observer Pattern

import Foundation

// Subject posts, observers react, neither holds the other.
NotificationCenter.default.post(name: Notification.Name("tick"), object: nil)
print("Broadcast an event")

Delegation

protocol DownloadDelegate: AnyObject {
    func didFinish(_ bytes: Int)
}
class Downloader {
    weak var delegate: DownloadDelegate?
    func finish() { delegate?.didFinish(1024) }
}
print("Delegate is one-to-one and typed")

Delegate vs Notification

import Foundation

// One listener -> delegate. Many/unknown listeners -> NotificationCenter.
print("Cardinality guides the choice")

Combine Publishers

import Combine

let subject = PassthroughSubject<Int, Never>()
let c = subject.sink { print("Got \($0)") }
subject.send(5)
_ = c

NotificationCenter Publisher

import Foundation
import Combine

let name = Notification.Name("ping")
let c = NotificationCenter.default.publisher(for: name)
    .sink { _ in print("Combine got notification") }
NotificationCenter.default.post(name: name, object: nil)
_ = c

Combine Operators

import Combine

let subject = PassthroughSubject<Int, Never>()
let c = subject
    .filter { $0 > 0 }
    .map { $0 * 2 }
    .sink { print($0) }
subject.send(-1)
subject.send(3)
_ = c

Async Sequences

import Foundation

func listen() async {
    let name = Notification.Name("ping")
    for await _ in NotificationCenter.default.notifications(named: name) {
        print("Async observed")
        break
    }
}
print("Can await notifications")

Closures and Callbacks

struct Button {
    var onTap: () -> Void
    func tap() { onTap() }
}
Button(onTap: { print("tapped") }).tap()

Choosing an Approach

import Foundation

// Match the tool to the communication shape.
print("Delegate, Notification, Combine, async, closure")

Tradeoffs

import Foundation

// Prefer typed approaches when the relationship is known.
print("Type safety vs flexibility tradeoff")

Quick Check

Recap