Protocol in Swift — was ist das, Syntax und Möglichkeiten

Was ist ein Protocol in Swift?

Protocol ist eine abstrakte Schnittstelle, die definiert, was ein Typ können muss, aber nicht wie er es tut. In Swift ist ein Protokoll analog zu Schnittstellen in Java oder Go, jedoch mit zusätzlichen Fähigkeiten.

Ein Protokoll kann Folgendes erfordern:

• Instanz- und Typmethoden (statisch)
• Eigenschaften mit { get } oder { get set } Spezifikatoren
• Initialisierer
• Subscripts
• Assoziierte Typen (Generics auf Protokollebene)

Laut WWDC 2015 hat Apple die protokollorientierte Programmierung als grundlegenden Ansatz für die Swift-Anwendungsarchitektur eingeführt. Im Gegensatz zur OOP, wo Klassenvererbung starre Hierarchien erzeugt, bietet POP Protokollkomposition. Dies bietet Flexibilität: Ein einzelner Typ kann mehreren Protokollen entsprechen und deren Anforderungen und Implementierungen durch Erweiterungen erhalten.

Syntax der Protokoll Deklaration

Protocol wird mit dem Schlüsselwort protocol, einem Namen und einem Rumpf deklariert.

protocol Drawable {
    func draw(context: CGContext)
    var boundingBox: CGRect { get }
}

Ein Typ übernimmt ein Protokoll mittels Doppelpunkt nach seinem Namen:

struct Circle: Drawable {
    let center: CGPoint
    let radius: CGFloat

    func draw(context: CGContext) {
        context.addArc(center: center, radius: radius, ...)
    }

    var boundingBox: CGRect {
        CGRect(x: center.x - radius, y: center.y - radius,
               width: radius * 2, height: radius * 2)
    }
}

Ein einzelner Typ kann mehrere Protokolle durch Kommas getrennt übernehmen: struct MyType: ProtocolA, ProtocolB. Der Compiler prüft, ob alle Anforderungen jedes Protokolls erfüllt sind.

Eigenschafts- und Methodenanforderungen

Eigenschaftsanforderungen werden mit dem Schlüsselwort var und den Zugriffsspezifikatoren { get } oder { get set } deklariert.

protocol UserProtocol {
    var name: String { get }
    var age: Int { get set }
    static var maxAge: Int { get }
    mutating func updateName(_ newName: String)
}

Das Schlüsselwort mutating in einem Protokoll zeigt an, dass die Methode self ändern kann. Strukturen müssen eine solche Methode als mutating implementieren, während Klassen sie weglassen können. Methodenanforderungen werden mit einer vollständigen Signatur einschließlich Parameterbezeichnern deklariert.

Protokollvererbung

Protocol kann ein anderes Protokoll erben und neue Anforderungen hinzufügen. Dies erzeugt eine Hierarchie von Verträgen ohne starre Klassenkopplung.

protocol Vehicle {
    var speed: Double { get set }
    func move()
}

protocol Flyable: Vehicle {
    var altitude: Double { get set }
    func takeOff()
}

Ein Typ, der Flyable übernimmt, muss die Anforderungen beider Protokolle erfüllen — Vehicle und Flyable. Swift unterstützt Mehrfachvererbung von Protokollen: protocol A: B, C.

Protocol Composition

Protocol Composition ist ein Mechanismus, der es erlaubt anzugeben, dass ein Typ gleichzeitig mehreren Protokollen entsprechen muss, ohne ein neues kombiniertes Protokoll zu erstellen.

func render(_ item: Drawable & Animatable) {
    item.draw(context: ...)
    item.animate(duration: 0.3)
}

Die Komposition (&) funktioniert in Funktionsparametern, Variablen und generischen Einschränkungen. Der Compiler prüft, dass der übergebene Typ gleichzeitig alle Protokolle erfüllt. Die Komposition wird häufig in SwiftUI verwendet: some View ist ein Generikum mit Komposition.

Protocol Composition ist der Erstellung einer Vererbungshierarchie vorzuziehen: statt protocol A: B, C kann man direkt B & C übernehmen. Dies bietet Flexibilität und reduziert die Kopplung. Die Komposition ist besonders nützlich in Funktionsparametern und generischen Einschränkungen, wo Anforderungen temporär kombiniert werden müssen, ohne ein Zwischenprotokoll zu erstellen. Dies reduziert die Anzahl der Hilfstypen im Code.

Protokoll als Typ

Protocol kann als Typ einer Variablen, eines Funktionsparameters oder eines Sammlungselements verwendet werden. Dies wird als existential type bezeichnet.

var drawableItem: Drawable
let items: [Drawable] = [Circle(...), Rectangle(...)]

func process(drawables: [any Drawable]) {
    for item in drawables {
        item.draw(context: ...)
    }
}

Das Schlüsselwort any (Swift 5.6+) kennzeichnet explizit einen Existential. Ohne any gibt der Compiler eine Warnung aus. Swift unterstützt auch some (opaque types) zum Verbergen des konkreten Typs hinter einem Protokoll — dies ist ein Standardansatz in SwiftUI.

Häufige Fehler mit Protokollen

Bei der Arbeit mit Protokollen machen Entwickler oft mehrere wiederkehrende Fehler.

• Mutating vergessen — eine Methode ist im Protokoll als mutating markiert, aber eine Struktur implementiert sie ohne das Schlüsselwort
• Protokoll als Typ statt Generikum — Verwendung von Drawable anstelle von <T: Drawable> wo ein konkreter Typ benötigt wird
• Zirkuläre Protokollreferenz — ein Protokoll, das sich selbst über einen assoziierten Typ referenziert, ohne korrekte Auflösung
• Nur-Klassen-Protokoll — unnötige Verwendung von AnyObject, was struct und enum ausschließt