iOS Design Patterns

What is a Singleton?

A Singleton ensures only one instance of a class exists. In modern Swift, use actors for thread-safe singletons:

actor DatabaseManager {
    static let shared = DatabaseManager()
    private var database: Database?
    private init() {}
    func connect() async throws {
        guard database == nil else { return }
        database = try await Database.connect()
    }
}

When to Use Singletons

• System services (networking, database, analytics)
• Shared resources (file manager, cache)
• Configuration objects

Avoid singletons for business logic, view models, and test doubles.

NotificationCenter

The Observer pattern allows objects to subscribe to notifications without tight coupling:

extension Notification.Name {
    static let userDidLogin = Notification.Name("userDidLogin")
}
NotificationCenter.default.post(name: .userDidLogin, object: nil, userInfo: ["userId": user.id])

Combine Publishers

class UserModel: ObservableObject {
    @Published var name: String = ""
    @Published var isLoggedIn: Bool = false
}
struct ProfileView: View {
    @ObservedObject var user: UserModel
    var body: some View { Text(user.name) }
}

When to Use Each

• NotificationCenter: loose coupling, cross-module
• Combine: type-safe, composable, integrated with SwiftUI

Factory Pattern

Creates objects without specifying exact class:

protocol ViewFactory {
    func makeView() -> UIViewController
}
struct HomeViewFactory: ViewFactory {
    func makeView() -> UIViewController {
        HomeViewController(viewModel: HomeViewModel())
    }
}

Builder Pattern

Constructs complex objects step by step:

class URLRequestBuilder {
    private var request: URLRequest
    init(url: URL) { self.request = URLRequest(url: url) }
    func method(_ method: String) -> URLRequestBuilder {
        request.httpMethod = method; return self
    }
    func header(_ key: String, value: String) -> URLRequestBuilder {
        request.setValue(value, forHTTPHeaderField: key); return self
    }
    func build() -> URLRequest { request }
}

Strategy Pattern

Defines interchangeable algorithms:

protocol SortStrategy {
    func sort<T: Comparable>(_ array: inout [T])
}
struct QuickSort: SortStrategy {
    func sort<T: Comparable>(_ array: inout [T]) { array.sort() }
}