Protocol-oriented architecture in iOS Swift

Introduction

Protocol-oriented architecture helps organize code by defining clear roles and behaviors. It makes your app easier to understand and change.

When you want to share common behavior across different types without using inheritance.

When you want to write flexible and reusable code that can work with many kinds of objects.

When you want to separate what something does from how it does it.

When you want to make your code easier to test by using protocols as contracts.

When you want to design your app with clear responsibilities for each part.

Syntax

iOS Swift

protocol SomeProtocol {
    func doSomething()
}

struct SomeStruct: SomeProtocol {
    func doSomething() {
        print("Doing something")
    }
}

A protocol defines a blueprint of methods or properties.

Types like structs, classes, or enums can conform to protocols by implementing the required methods.

Examples

This example shows a protocol Drivable and a struct Car that follows it.

iOS Swift

protocol Drivable {
    func drive()
}

struct Car: Drivable {
    func drive() {
        print("Car is driving")
    }
}

Here a class Bird conforms to the Flyable protocol by implementing fly().

iOS Swift

protocol Flyable {
    func fly()
}

class Bird: Flyable {
    func fly() {
        print("Bird is flying")
    }
}

This shows a protocol with a property requirement and a struct that provides it.

iOS Swift

protocol Identifiable {
    var id: String { get }
}

struct User: Identifiable {
    var id: String
}

Sample App

This program defines a protocol Greetable with a greet method. The struct Person follows the protocol and prints a greeting with the person's name.

iOS Swift

protocol Greetable {
    func greet()
}

struct Person: Greetable {
    var name: String
    func greet() {
        print("Hello, my name is \(name)")
    }
}

let person = Person(name: "Alex")
person.greet()

Important Notes

Protocols help you write code that focuses on what to do, not how to do it.

Using protocols makes your code easier to change and test.

Swift encourages protocol-oriented programming as a modern way to design apps.

Summary

Protocols define a set of rules or behaviors.

Types conform to protocols by implementing required methods or properties.

Protocol-oriented architecture helps build flexible and reusable code.