Delegate Pattern Explained

The delegate pattern is a common design pattern in iOS development that allows objects to communicate with each other without being tightly coupled. In SwiftUI, this pattern is often used to handle events and data between views, view controllers, and other objects.

The code in this post is available here.

To implement the delegate pattern in SwiftUI, you need to define a protocol that outlines the methods that will be implemented by the delegate. Then, you can create a delegate property on the object that will use the delegate and set it to an object that conforms to the delegate protocol.

Let's say you have a view that displays a list of items and you want to notify a parent view when an item is selected. Here's an example of how you can use the delegate pattern to accomplish this:

// Define the Item model
struct Item: Identifiable {
    let id = UUID()
    var name: String
}

// Define a delegate protocol
protocol ItemSelectionDelegate {
    func didSelectItem(item: Item)
}

// Create a view that uses the delegate
struct ItemListView: View {
    @State private var items = [Item]()
    var delegate: ItemSelectionDelegate?

    var body: some View {
        List(items) { item in
            HStack {
                Text(item.name)
            }
            .onTapGesture {
                delegate?.didSelectItem(item: item)
            }
        }
        .onAppear {
            items = [
                .init(name: "Item 1"),
                .init(name: "Item 2"),
                .init(name: "Item 3"),
                .init(name: "Item 4"),
                .init(name: "Item 5"),
                .init(name: "Item 6"),
                .init(name: "Item 7"),
            ]
        }
    }
}

// Create a parent view that implements the delegate protocol
struct ContentView: View {
    @State private var selectedItem: Item?

    var body: some View {
        VStack {
            Text("Selected item: \(selectedItem?.name ?? "None")")
            ItemListView(delegate: self)
        }
    }
}

extension ContentView: ItemSelectionDelegate {
    func didSelectItem(item: Item) {
        selectedItem = item
    }
}

In this example, the ItemListView defines a delegate property of type ItemSelectionDelegate. When an item in the list is tapped, it calls the didSelectItem method on the delegate, passing in the selected item.

The ContentView implements the ItemSelectionDelegate protocol and sets itself as the delegate for the ItemListView. When an item is selected in the list, the didSelectItem method is called on the delegate (which is the ContentView), and it updates the selectedItem property.

By using the delegate pattern, the ItemListView can communicate with the ContentView without knowing anything about it. This allows for more flexible and decoupled code.

In conclusion, the delegate pattern is a powerful tool for handling communication between objects in SwiftUI. By defining protocols and implementing delegates, you can create loosely coupled code that is easier to maintain and modify.

That’s all of today’s post. I hope it helps and let me know if it is by leaving a comment. Don’t forget to subscribe to my newsletter if you’d like to receive posts like this via email.

I’ll see you in the next post!