Apple hat beachtliche Aussagen darüber gemacht, wie schnell die Programmiersprache Swift sein soll, zum Beispiel, dass sie bis zu 2,6-mal schneller sei als Objective-C.
Die Details der Tests hinter diesen Aussagen wurden nie veröffentlicht, und wer sie selbst überprüft hat, kam zu ganz anderen Ergebnissen: Nicht optimierter Swift-Code kann um eine Größenordnung langsamer sein als Objective-C. Mit Optimierungen ist Swift meist immer noch langsamer, aber der Unterschied ist nicht mehr so groß.
In seinem Buch iOS and macOS Performance Tuning hat der Softwareentwickler und Forscher Marcel Weiher gezeigt, dass sich Swift deutlich beschleunigen lässt. Dafür müsste man aber auf reines C oder C-basierte Funktionen ausweichen und würde allen Komfort verlieren, den Swift mitbringt.
Bei Cleevio wollen wir Code schreiben, der so schnell wie möglich läuft und trotzdem komfortabel, sicher und lesbar bleibt. Swift eignet sich deshalb hervorragend für die meisten unserer Anwendungsfälle (auch wenn wir für eines unserer Projekte eine C-Bibliothek für eine rechenintensive Aufgabe geschrieben haben), weil es unsere Anforderungen erfüllt, ohne dass wir komplett auf reines C umsteigen müssen.
Für manche Probleme im Code gibt es allerdings viele Lösungswege, manche performanter, manche weniger. Dieser Artikel konzentriert sich auf den Unterschied zwischen Static und Dynamic Dispatch. Wir sehen ihn uns im Code an und besprechen, wie er sich auf die Performance auswirkt. Außerdem geht es um die Einschränkungen in Situationen, in denen es deutlich unbequemer ist, den Code optimal zu schreiben.
Static Dispatch
Static Dispatch beschreibt eine Situation, in der wir schon zur Kompilierzeit wissen, welcher Funktionsrumpf ausgeführt wird. Typische Vertreter sind konkrete Typen oder Generics.
Das folgende Beispiel zeigt es:
struct DinnerServer {
func isFoodReady() -> Bool {
true
}
}
let server = DinnerServer()
server.isFoodReady()Hier können wir sicher sein, dass DinnerServer die Funktion ausführt und wir den Wert true erhalten. Dasselbe gilt für Klassen, die mit dem Schlüsselwort final gekennzeichnet sind: Von ihnen kann nicht abgeleitet werden, also steht schon beim Kompilieren fest, was ausgeführt wird.
Ähnliche Ergebnisse sehen wir, wenn wir Generics verwenden, die Swift-Protokolle voll ausreizen. Generics sind ein wesentlicher Teil der App-Entwicklung mit Swift, schließlich wurde die Sprache selbst als protokollorientiert beschrieben. Definieren wir zuerst ein Protokoll:
protocol Server {
func isFoodReady() -> Bool
}Jetzt lassen wir DinnerServer dieses Protokoll erfüllen. Das ist einfach, weil DinnerServer die Funktion bereits implementiert.
extension DinnerServer: Server { }Nehmen wir an, wir haben eine Funktion, die einen Server als Argument nimmt und zurückgibt, ob das Essen fertig ist. Sie könnte so definiert sein:
func isFoodReady(server: Server) -> Bool {
server.isFoodReady()
}In der aktuellen Implementierung sagen wir jedoch, dass es ein beliebiger Server sein kann. Wir bekommen ein Ergebnis, wissen aber nicht, welcher Typ die Funktion ausführt. Und weil jeder Server als Variable in die Funktion gegeben werden kann, wissen wir nicht einmal, ob wir true erhalten. Zum Glück können wir dem Compiler mit Generics mitteilen, welcher Typ für die Ausführung der Funktion zuständig ist.
func isFoodReady<T: Server>(server: T) {
server.isFoodReady()
}Hier übergeben wir der Funktion T: Server. Diese Syntax in spitzen Klammern bedeutet, dass wir nicht irgendeinen Server erwarten, sondern einen ganz bestimmten. Der Compiler erzeugt dann eine eigene Version für jeden Typ, den wir der Funktion in unserer Codebasis übergeben. Die kompilierte App wird dadurch minimal größer, aber wir können sicher sein, dass die Ausführung schnell ist, denn der Compiler erzeugt für uns eine Funktion, die so aussieht:
func isFoodReady(server: DinnerServer) {
server.isFoodReady()
}In unserer Codebasis sehen wir eine solche Funktion nicht. Ich zeige sie Ihnen, damit Sie ein Bild davon haben, wie der Compiler hinter den Kulissen von Generics profitiert.
Natürlich könnten wir dasselbe selbst tun und die Funktion isFoodReady(server:) für jeden Typ deklarieren, der das Protokoll Server erfüllt. Das wäre aber eine unvertretbare Zeitverschwendung. Sie von Hand zu schreiben wäre außerdem fehleranfälliger, weil man leicht eine vergessen könnte.
Bei einer einzigen Funktion wirkt das noch machbar. Aber was ist mit komplexerem Code? Zum Beispiel, wenn wir die Anforderungen des Protokolls Server um die Funktionen prepareIngredients und finalizePreparation erweitern
protocol Server {
func isFoodReady() -> Bool
func preparedIngredients(size: Int) -> ()
func finalizePreparation() -> ()
}und dann unseren DinnerServer so erweitern, dass er das Protokoll Server weiterhin erfüllt:
extension DinnerServer: Server {
func server.prepareIngredients(size: Int) {
var preparedIngredients = 0
while preparedIngredients < size {
preparedIngredients += 1
}
}
func finalizePreparation() { }
}Dann können wir eine eigene Funktion für die Zubereitung schreiben, die den Aufruf beider Funktionen übernimmt:
func prepareFood<T: Server>(server: T, size: Int) {
server.prepareIngredients(size: size)
server.finalizePreparation()
}Wie Sie in der Implementierung gesehen haben, ist finalizePreparation bei DinnerServer leer, weil unser Server nichts weiter tun muss, als die Zutaten vorzubereiten. Ein anderer Server braucht sie aber vielleicht.
Das können wir jetzt in einer weiteren Funktion (orderFood) verwenden, die abstürzen soll, wenn das Essen nicht fertig ist, obwohl es zubereitet sein müsste:
func orderFood<T: Server>(server: T, size: Int) {
prepareFood(server: server, size: size)
if !isFoodReady(server: server) {
fatalError("Food is not ready for some reason")
}
}Wie Sie sehen: Müssten wir Funktionen für konkrete Typen anlegen, würde die Menge an Code, die wir schreiben müssten, exponentiell wachsen
mit der wachsenden Zahl der Funktionen oder der Typen, die sie verwenden.
Generics verbessern auch die Testbarkeit unseres Codes, weil wir Mock-Typen nur für Testzwecke anlegen können, ohne eigene Funktionen für sie schreiben zu müssen.
Dynamic Dispatch
Dynamic Dispatch ist die genau umgekehrte Situation: Zur Kompilierzeit wissen wir nicht, welcher Funktionsrumpf ausgeführt wird. Wir können dem Compiler also nicht zu denselben Optimierungen verhelfen, die er mit Generics vornehmen kann.
Wie eine Funktion mit Dynamic Dispatch in unserem Beispiel aussieht, habe ich bereits gezeigt. Es ist eine Funktion, die jeden Typ annimmt, der das Protokoll Server erfüllt:
func isFoodReady(server: Server) -> Bool {
server.isFoodReady()
}Das Ergebnis: Die Ausführung dieses dynamischen isFoodReady kostet zur Laufzeit mehr Arbeit. Der Assembler-Code des Compilers zeigt das deutlich. Zunächst unterscheiden sich generische und nicht generische Funktionen in ihrer Implementierung.
output.isFoodReady<A where A: output.Server>(server: A) -> Swift.Bool: //generic function
push rbp
mov rbp, rsp
push r13
sub rsp, 40
mov qword ptr [rbp - 40], rdx
mov rax, rsi
mov rsi, qword ptr [rbp - 40]
mov qword ptr [rbp - 32], rax
mov r13, rdi
mov rdi, qword ptr [rbp - 32]
mov qword ptr [rbp - 24], 0
mov qword ptr [rbp - 16], rdi
mov qword ptr [rbp - 24], r13
mov rax, qword ptr [rsi + 8]
call rax
add rsp, 40
pop r13
pop rbp
ret
output.isFoodReady(server: output.Server) -> Swift.Bool: //non-generic function
push rbp
mov rbp, rsp
push r13
sub rsp, 24
mov qword ptr [rbp - 16], 0
mov qword ptr [rbp - 16], rdi
mov rsi, qword ptr [rdi + 24]
mov qword ptr [rbp - 32], rsi
mov rax, qword ptr [rdi + 32]
mov qword ptr [rbp - 24], rax
call __swift_project_boxed_opaque_existential_1
mov rdi, qword ptr [rbp - 32]
mov rsi, qword ptr [rbp - 24]
mov r13, rax
mov rax, qword ptr [rsi + 8]
call rax
add rsp, 24
pop r13
pop rbp
retWie wir sehen, enthält die nicht generische Funktion einen besonderen Aufruf von __swift_project_boxed_opaque_existential_1, denn genau damit müssen wir hier arbeiten: mit Existentials. Auch an der Stelle, an der diese Funktionen aufgerufen werden, zeigen sich Unterschiede.
Der Aufruf unserer generischen Funktion ist recht geradliniger Code:
lea rsi, [rip + (full type metadata for output.DinnerServer)]
add rsi, 8
lea rdx, [rip + (protocol witness table for output.DinnerServer : output.Server in output)]
call (output.isFoodReady<A where A: output.Server>(server: A) -> Swift.Bool)Wenn wir dagegen unsere generische Funktion aufrufen, wird es unübersichtlicher:
lea rax, [rip + (full type metadata for output.DinnerServer)]
add rax, 8
mov qword ptr [rbp - 16], rax
lea rax, [rip + (protocol witness table for output.DinnerServer : output.Server in output)]
mov qword ptr [rbp - 8], rax
lea rdi, [rbp - 40]
call (output.isFoodReady(server: output.Server) -> Swift.Bool)
lea rdi, [rbp - 40]
call __swift_destroy_boxed_opaque_existential_1
xor eax, eax
add rsp, 48
pop rbp
retDer auffälligste Unterschied ist ein zusätzlicher Aufruf der Funktion __swift_destroy_boxed_opaque_existential_1. Dieser zusätzliche Overhead sorgt dafür, dass der Code langsamer läuft. Wie viel langsamer? Dazu kommen wir im nächsten Abschnitt.
Dem Begriff Existential begegnen wir auch im Zusammenhang mit Swift 5.6, das das existential any eingeführt hat. Swift will uns damit dazu bringen, any vor jeden Protokolltyp zu schreiben, den wir (zum Beispiel) in einer Funktion verwenden wollen. So soll uns bewusster werden, dass wir Dynamic Dispatch verwenden. Wir können damit rechnen, dass künftige Swift-Versionen eine Warnung oder einen Fehler ausgeben, wenn wir das Wort any in unserer Codebasis nicht verwenden. Der oben gezeigte Code sähe dann so aus:
func isFoodReady(server: any Server) -> Bool {
server.isFoodReady()
}So einfach ist das. Es genügt, das Wort any zu ergänzen.
Ein weiteres Beispiel für Dynamic Dispatch ist eine Klasse, die nicht als final definiert ist. Der Compiler kann nicht sicher sein, welche Klasse der Funktion übergeben wird: die in der Funktion angegebene Klasse oder eine, die von ihr erbt? Ist die Klasse als final deklariert, ist Vererbung nicht mehr möglich, und der Compiler kann weitere Optimierungen vornehmen. Dasselbe gilt für einzelne Funktionen oder Variablen. Sind sie als final deklariert, können sie nicht überschrieben werden, und der Compiler muss keinen Dynamic Dispatch verwenden.
Warum sollte dann überhaupt jemand Dynamic Dispatch verwenden? Das sehen wir uns im Abschnitt „Einschränkungen“ an. Dort zeige ich Beispiele, in denen Static Dispatch in manchen Situationen zumindest unbequem ist.
Die Ergebnisse
Grundsätzlich ist zu erwarten, dass Dynamic Dispatch langsamer ist als dieselben Funktionen mit Static Dispatch. Genau das zeigen die Ergebnisse. Die Frage ist nur: zu welchem Preis? Die Antwort hängt davon ab, ob wir über Generics oder über final-Klassen sprechen.
Die Messung
Ich stelle die Ergebnisse für Static und Dynamic Dispatch im Vergleich vor. Für die Messungen habe ich eine Bibliothek geschrieben, die Funktionen in einem Typ namens MeasureFunc (er enthält die Funktion und ihren Namen) sowie die Anzahl der Wiederholungen entgegennimmt.
func measure(functions: [MeasureFunc], repeats: Int)Sie ist sehr einfach aufgebaut: Sie führt alle Funktionen wiederholt aus und hängt das Ergebnis an ein Dictionary an, das anschließend sortiert wird. Danach werden die Ergebnisse verarbeitet: Die Bibliothek kann sie ausgeben oder zum Beispiel als CSV speichern. Die Durchschnittszeit jeder Funktion wird als Mittelwert der Durchläufe berechnet, und zwar mit CAMediaCurrentTime, das sich viel schneller erzeugen lässt als Date und deshalb genauer sein sollte.
func oneRunOf(_ function: () -> ()) -> Double {
let timeBefore = CACurrentMediaTime()
function()
return CACurrentMediaTime() - timeBefore
}Ich zeige die Ergebnisse im Verhältnis zur schnellsten Funktion. Würde also eine Funktion 1 Minute dauern und die andere 2 Minuten, hätte die erste den Index 100 % und die zweite 200 %, weil ihre Ausführung doppelt so lange dauert.
Der Code wurde mit Release-Optimierungen kompiliert. Ohne sie wäre er voraussichtlich deutlich langsamer.
Für alle Tests, die ich Ihnen zeige, verwende ich die Funktion TestingClass, die so deklariert ist:
final class TestingClass: Testable {
let variable1 = UUID()
let variable2 = UUID()
let variable3 = UUID()
let variable4 = UUID()
let variable5 = UUID()
}Sie erfüllt das Protokoll Testable, das nur eine Anforderung hat: einen init ohne Parameter. Ich habe UUIDs verwendet, weil ihre Erzeugung etwas Zeit kostet, obwohl sie Werttypen sind.
Eine Klasse an ein Array anhängen
Die Wiederverwendung von Code ist eine der großen Ideen der modernen Programmierung. Wir wollen uns nicht wiederholen und nach Möglichkeit nur eine Zeile an einer Stelle ändern statt eine Zeile an mehreren Stellen.
Im ersten Beispiel habe ich statisch und dynamisch dispatchten Code getestet, indem ich unsere TestingClass zu einem Array hinzugefügt habe. Ja, mit einem ContiguousArray ginge es schneller, aber seien wir ehrlich: Das benutzt niemand (und selbst ich nur manchmal).
Der Code zum Anhängen an ein Array ist für den generischen Typ sehr einfach: Er nimmt ein Element und hängt es 100.000-mal an.
func getAppendingToArray<T: Testable>(_ item: T) {
var array: Array<T> = []
for _ in 0..<100000 {
array.append(item)
}
}Bei einer dynamisch dispatchten Funktion ändert sich am Code nur, dass wir statt T direkt Testable verwenden. Mit Swift 5.6 würden wir any Testable schreiben.
func getAppendingToArrayDynamicDispatch(_ item: Testable) {
var array: Array<Testable> = []
for _ in 0..<100000 {
array.append(item)
}
}Die Ergebnisse überraschen nicht: Mit der generischen Funktion geht es deutlich schneller. Wie viel schneller? Um etwa 62 %.
Eine Klasse mit Initialisierung an ein Array anhängen
Manchmal müssen wir ein bestimmtes Element nicht nur wiederholt an ein Array anhängen, sondern es auch aus Daten erzeugen und daraus ein Modell bauen. Die Initialisierung selbst kostet also Zeit. Und auch wenn das Anhängen viel schneller ist (wie gesagt um 62 %), sollte der Unterschied bei der Gesamtzeit der Funktion deutlich kleiner ausfallen, weil die Zeit für den init gleich sein sollte.
Die Funktionen ähneln dem einfachen Anhängen an ein Array sehr, mit dem einzigen Unterschied, dass wir das Element beim Anhängen initialisieren. Die generische Funktion sieht so aus:
func getAppendingAndCreatingArray<T: Testable>(ofType usedType: T.Type) {
var array: Array<T> = []
for _ in 0..<100000 {
array.append(usedType.init())
}
}Und die dynamisch dispatchte so:
func getAppendingAndCreatingArrayDynamicDispatch(ofType usedType: Testable.Type) {
var array: Array<Testable> = []
for _ in 0..<100000 {
array.append(usedType.init())
}
}Die Ergebnisse bestätigen unsere Erwartung: Dynamic Dispatch ist 7 % langsamer als Generics, weil ein erheblicher Teil der Zeit auf das Erzeugen der Klasse entfällt. Wäre es keine Klasse oder hätte sie keine 5 Variablen, wäre Dynamic Dispatch relativ gesehen langsamer (aber nie um mehr als die 62 % aus dem vorherigen Test).

Klassenrekursion
Wir sprechen hier nicht über Rekursionsalgorithmen (die meist ohnehin nicht der performanteste Weg sind, eine Aufgabe zu lösen). Ich zeige Ihnen sehr einfachen Code einer Klasse, die einen Parameter entgegennimmt und ihn dann weiterreicht. Anwendung findet so etwas etwa bei Dependency Injection, zum Beispiel in Koordinatoren oder im Umgang mit ViewModels in SwiftUI.
Rekursion mit Static Dispatch sieht wie folgt aus. Wie Sie sehen, beginnen wir mit einem Element, das das Protokoll Testable erfüllt, und durchlaufen die Rekursion dann 5-mal (beginnend bei 0).
final class RecursionStaticDispatch<T: Testable> {
let storage: T
let height: Int
init(item: T, height: Int) {
self.storage = item
self.height = height
recurseIfRecursionLessThanFive()
}
func recurseIfRecursionLessThanFive() {
if height < 5 {
let _ = RecursionStaticDispatch(item: storage, height: height + 1)
}
}
}Dynamic Dispatch sieht sehr ähnlich aus. Der einzige Unterschied: Wir deklarieren storage als Testable statt als generisches T.
final class RecursionDynamicDispatch {
let storage: Testable
let height: Int
init(item: Testable, height: Int) {
self.storage = item
self.height = height
recurseIfRecursionLessThanFive()
}
func recurseIfRecursionLessThanFive() {
if height < 5 {
let _ = RecursionDynamicDispatch(item: storage, height: height + 1)
}
}
}Auch hier ist Static Dispatch deutlich schneller, in diesem Fall um 67 %.

Final-Klassen
Als ich Klassen als final deklariert habe, fand ich nur einen winzigen Unterschied. Es gehört aber eindeutig zu Apples Optimierungstipps, die Sie auf dessen Github finden. In den Tests für diesen Artikel habe ich mich nicht besonders auf Benchmarks von final-Klassen konzentriert, aber es zeigt sich, dass wir mit final-Klassen ein wenig gewinnen können, nicht nur bei der Laufzeit, sondern auch bei den Kompilierzeiten.
Ich empfehle diesen großartigen Benchmark aus den Swift-Foren von Jon_Shier. Er zeigt, dass als final deklarierte Klassen die Kompilierung um etwa 1 % beschleunigen können. Nicht schlecht, oder? Und da es mit Generics etwas länger dauert, könnten wir so zurückgewinnen, was wir verloren haben. Zumindest teilweise.
Einschränkungen
Unsere iOS-Architektur basiert auf MVVM-C. Zuerst übergeben wir die Abhängigkeiten an den Coordinator, der dann ViewModel und ViewController erzeugt und anschließend das ViewModel an den ViewController hängt (oder an die View, je nachdem, ob es eine neuere App mit SwiftUI ist oder eine ältere, die rein auf UIKit aufbaut).
In den Koordinatoren ließ sich Static Dispatch recht einfach nutzen. Statt dieser Variante:
final class ExampleCoordinator {
typealias Dependencies = AllDependencies
(...)
}Jetzt verwenden wir Generics, die so deklariert sind:
final class ExampleCoordinator<Dependencies: AllDependencies> {
(...)
}Dieser Code ist sogar kürzer, weil kein typealias für Dependencies mehr nötig ist, der später in den Funktionen des Koordinators verwendet wird. Wenn wir die Abhängigkeiten ändern müssen, ändern wir sie also nur an einer Stelle.
Ein Detail dabei: Wenn Sie diese Umstellung angehen und Generics statt eines any-Existentials verwenden, müssen Sie das an allen Stellen ändern. Oder Sie beginnen zumindest bei einem Root-Koordinator und arbeiten sich dann entlang des Flows nach unten. Zur Veranschaulichung deklarieren wir ein Protokoll Developer:
protocol Developer { }und einen Typ, der es erfüllt:
struct CleevioDeveloper: Developer { }Dieser Code kompiliert:
func invoiceForCustomer(developer: any Developer) { }
let developer = CleevioDeveloper()
invoiceForCustomer(developer: developer)Der folgende dagegen nicht. Generics erwarten nämlich einen konkreten Typ, und der Compiler kann aus einem Existential keinen konkreten Typ machen.
func invoiceForCustomer<T: Developer>(developer: T) { }
let developer: any Developer = CleevioDeveloper()
invoiceForCustomer(developer: developer)Bei ViewModels und ViewControllern ist es aber nicht so einfach. Wäre das ViewModel generisch, müsste es per Generics sowohl im ViewController als auch im ViewModel selbst ausdrücklich deklariert werden (Sie sehen es im folgenden Beispiel in den spitzen Klammern, wo wir den Code duplizieren müssen). Im ViewController müssten wir dann deklarieren, welche Protokolle das ViewModel erfüllt, was ein späteres Refactoring etwas erschweren würde.
protocol CanFly { }
final class ViewModel<T: CanFly> { (…) }
final class ViewController<T: CanFly>: UIViewController {
let viewModel: ViewModel<T>
(…)
}Außerdem lässt sich eine Klasse, die Generics verwendet, nicht per Extension zum Delegate für eine Objective-C-API machen. Das zeigt das folgende Beispiel, in dem wir den Fehler „Conformance of generic class ViewController<T> to @objc protocol UITableViewDelegate cannot be in an extension“ erhalten. Ja, das ließe sich über ein weiteres Objekt lösen, das als Delegate dient, aber das würde erhebliche Änderungen erfordern.
extension ViewController: UITableViewDelegate { } //does not workGenerics können auch sehr komplex werden, wenn wir Standardargumente für generische Abhängigkeiten haben wollen. Im Kontext von SwiftUI ist das besonders gut zu sehen, es gilt aber überall, wo Generics verwendet werden. Zur Veranschaulichung bauen wir eine sehr einfache ContainerView mit zwei Attributen: content und dessen overlay.
struct ContainerView<Content: View, Overlay: View>: View {
var content: Content
var overlay: Overlay
init(@ViewBuilder content: () -> Content,
@ViewBuilder overlay: () -> Overlay) {
self.content = content()
self.overlay = overlay()
}
var body: some View {
content
.overlay(overlay)
}
}Was also, wenn wir dafür Standardargumente anlegen wollen? Wir müssten ContainerView um sie erweitern. Nehmen wir an, das Standardargument für content soll Text sein und für overlay EmptyView.
Für Content sähe das so aus. Achten Sie auf Content == Text: Dort deklarieren wir, dass diese Extension nur gilt, wenn Content ein Text ist. Und im init steht ebenfalls Text mit dem lokalisierten String „Placeholder“. Wann immer Sie also den init ContainerView(overlay:) verwenden, wird der Text mit dem String Placeholder angezeigt.
extension ContainerView where Content == Text {
init(@ViewBuilder content: () -> Content = { Text("Placeholder") },
@ViewBuilder overlay: () -> Overlay) {
self.content = content()
self.overlay = overlay()
}
}Und damit Overlay standardmäßig EmptyView ist, so. Das Ergebnis: Wir können den Parameter overlay jetzt weglassen:
extension ContainerView where Overlay == EmptyView {
init(@ViewBuilder content: () -> Content,
@ViewBuilder overlay: () -> Overlay = EmptyView.init) {
self.content = content()
self.overlay = overlay()
}
}Was aber, wenn wir einen init mit zwei Standardargumenten wollen, Text und EmptyView? Dann müssten wir eine weitere Extension wie diese deklarieren. Damit können wir die beiden vorherigen Extensions kombinieren und die ContainerView einfach als ContainerView() deklarieren, ohne ein Argument angeben zu müssen:
extension ContainerView where Content == Text, Overlay == EmptyView {
init(@ViewBuilder content: () -> Content = { Text("Placeholder") },
@ViewBuilder overlay: () -> Overlay = EmptyView.init) {
self.content = content()
self.overlay = overlay()
}
}Und was, wenn wir weitere Argumente hätten, die einen Standardwert bekommen sollen? Wie Sie sehen, wächst die Komplexität hier exponentiell. Für zwei Standardargumente brauchen wir 3 Extensions. Für 3 bräuchten wir 7 Argumente. An dieser Stelle sollte man auch über die Wartung sprechen: ob ein rein generischer Ansatz von Anfang an sinnvoll ist, wenn die API oder die App-Architektur noch nicht fertig ist und sich künftig stark ändern kann.
Ergänzend sei gesagt: Wenn wir uns für Generics entscheiden, führt an manchen Stellen einfach kein Weg daran vorbei. Apple macht bei seinen SwiftUI-Elementen genau dasselbe. Die eigentliche Implementierung sehen wir zwar nicht, aber in der Dokumentation sehen wir die Header und die Namen der Funktionen.
SwiftUI.Label hat zwei Argumente: Title und Icon. Und weil Apple möchte, dass Nutzer einige Convenience-inits verwenden können, gibt es zusätzlich zwei Extensions mit Convenience-Initialisierern (Standardparameter hat Apple hier nicht). In der ersten Extension, in der Title ein Text ist, gibt es zum Beispiel Convenience-Inits, die String, LocalizedStringKey sowie einen String für ein Bild oder ein SF Image annehmen. Wie Sie sehen, lässt sich ein Label nicht mit some View und zugleich mit dem String eines Bildes initialisieren. Dafür müsste Apple eine weitere Extension anlegen. Dasselbe gilt für den Fall, dass Title ein String ist, Icon aber some View. APIs zu entwerfen ist einfach schwer: Entweder Sie bieten alle Convenience-Inits an oder Sie machen sich das Leben leichter.
public struct Label<Title, Icon> : View where Title : View, Icon : View
extension Label where Title == Text, Icon == Image
extension Label where Title == LabelStyleConfiguration.Title, Icon == LabelStyleConfiguration.IconDiese Einschränkungen sind keineswegs abschließend. Je nach Kontext gibt es womöglich Wege, sie zu umgehen. Wenn Sie gute Beispiele für Einschränkungen oder für deren Lösung haben, lassen Sie es mich bitte wissen!
Swift 5.7
Apple hat Swift 5.7 um viele großartige Neuerungen erweitert. Der Umgang mit Generics wurde deutlich verbessert, und einige der oben genannten Einschränkungen gehören der Vergangenheit an.
Im ersten Kapitel dieses Artikels haben wir zum Beispiel folgende Funktion definiert:
func isFoodReady<T: Server>(server: T) {In Swift 5.7 genügt es, sie so zu schreiben:
func isFoodReady(server: some Server) {Die Schreibweise mit spitzen Klammern, die potenzielle Nutzer von Generics vielleicht abgeschreckt hat, ist verschwunden. An ihre Stelle tritt dasselbe Schlüsselwort some, das wir aus SwiftUI kennen, jetzt auch im Parameter einer Funktion.
Ich habe auch gezeigt, wie schwer es ist, in SwiftUI Standardargumente für Parameter zu definieren. Das ist vorbei. Für unseren Anwendungsfall brauchten wir 4 inits. In Swift 5.7 genügt ein einziger.
init(@ViewBuilder content: () -> Content = { Text("Placeholder") },
@ViewBuilder overlay: () -> Overlay = EmptyView.init) {
self.content = content()
self.overlay = overlay()
}Und am interessantesten: Es ist jetzt möglich, etwas zu nutzen, das die Leute bei Apple Existential Unboxing nennen. Was bedeutet das? Wir können ein Existential jetzt in einer generischen Funktion verwenden. Das folgende Beispiel zeigt es, denke ich, anschaulich genug:
func takeAn(existential: Dependency) {
takeA(generic: existential)
}
func takeA(generic: some Dependency) {
takeAn(existential: generic)
}Wie Sie sehen, kann ein existenzieller any-Typ eine generische Funktion aufrufen, die dann (wie es schon immer ging) wieder eine existenzielle Funktion aufruft. Das ist (zusammen mit den anderen Neuerungen) der Grund, warum meine Präsentation für das Team über Generics in Swift 5.7 und darüber, wie wir unseren Code mit dem Kommenden verbessern können, Big Year For Generics hieß.
Ab Swift 5.7 können wir Generics schrittweise im Code einführen, weil nicht mehr die gesamte Koordinator-Hierarchie umgestellt werden muss, wenn wir damit anfangen wollen. Wir können mit einem einzigen beginnen und nach und nach weitermachen.
Swift 5.7 verbessert also deutlich, was wir schon hatten, und der bisherige Code kompiliert weiterhin. Vorsicht nur vor einem zu frühen Umstieg auf Xcode 14: Zum Zeitpunkt des Schreibens ist es keineswegs stabil und hat ernste Probleme.
Fazit
Was also aus diesem Artikel mitnehmen? Nutzen Sie die Stärke von Static Dispatch, wann immer es geht. Swift ist eine großartige Sprache für Entwickler, auch wenn sie dem Compiler viel abverlangt. Und der Compiler braucht unsere Hilfe, die wir ihm mit Generics, final-Klassen oder auch mit private und anderen Deklarationen geben können.
Aber Vorsicht vor Überoptimierung. Wie im Abschnitt „Einschränkungen“ gezeigt, gibt es Situationen, in denen sie ein umfangreiches Refactoring des bestehenden Codes erfordern würde und ein späteres Refactoring erschweren könnte. Denken Sie immer auch an die Machbarkeit, denn Sie können viel von Ihrer Zeit oder der Zeit des Kunden verbrennen, um Code zu optimieren. Und obwohl die Auswirkungen auf die Performance erheblich sind, sind unsere Smartphones, Computer und Tablets heute so leistungsfähig, dass Nutzer sie womöglich gar nicht bemerken. Optimieren ist großartig, wann immer es möglich ist, es kann sogar Akkulaufzeit sparen. Übertreiben Sie es nur nicht.
Zum Schluss noch ein paar praktische Tipps. Ich gehe davon aus, dass Code, der Existentials ohne any verwendet, Ihnen künftig eine Warnung des Swift-Compilers einbringt. Wenn es so weit ist, überlegen Sie, ihn generisch zu machen, statt einfach any einzufügen. Bei Klassen können Sie zum Beispiel die folgende SwiftLint-Regel verwenden, die warnt, wenn Ihr Code eine Klasse enthält, die nicht als final deklariert ist (für Klassen, von denen abgeleitet werden soll, lässt sich die Regel jederzeit deaktivieren). Natürlich können Sie sie beliebig anpassen. Wir verwenden sie nur für Manager, Services und Koordinatoren.
final_class:
included: ".*\\.swift"
name: "Class not declared as final"
regex: '^(\s*)((public|private|internal)\s|)(class)\s'
message: "Classes should be declared as final if they are not to be subclassed"
severity: warning








