Automatic Dependency Injection (DI) in Swift 6 to make your code clean
Zusammenfassung
Kurz
Der Artikel zeigt einen zentralen Injector für Swift 6: `@Provider` registriert Abhängigkeiten, `@Inject` löst sie in einem ViewModel auf. Das Counter-App-Beispiel soll laut Autor manuelle Übergaben vereinfachen; eine umfassende Prüfung des Ansatzes liefert der Beitrag nicht, und der Autor räumt mögliche Unvollkommenheiten ein.
Mittel
Darren Thiores beschreibt eine automatische Dependency-Injection-Implementierung für Swift 6 Strict Concurrency anhand einer Counter-App mit MVVM. Ein als `@MainActor` markierter zentraler Injector speichert registrierte Objekte in einem Wörterbuch. Der Property-Wrapper `@Provider` registriert eine Abhängigkeit; `@Inject` löst sie anhand des Typs auf. Fehlt eine Registrierung, beendet der Beispielcode die Ausführung mit `fatalError`.
Die App registriert eine `SingleCounter`-Instanz über ein `Counter`-Protokoll beim Start in einem `AppModule`. Das ViewModel bezieht den Zähler per `@Inject`, die SwiftUI-Ansicht erzeugt das ViewModel als `@StateObject`. Zum Zurücksetzen beim Abbau des ViewModels zeigt der Autor einen Aufruf über `DispatchQueue.main.sync`, da die betreffende Eigenschaft Main-Actor-isoliert sei.
Laut Autor soll der Ansatz die manuelle Verwaltung von Abhängigkeiten erleichtern und das Dependency Inversion Principle unterstützen. Der Beitrag ist ein Implementierungsbeispiel, keine dokumentierte Prüfung oder vergleichende Bewertung. Der Autor weist selbst auf mögliche Unvollkommenheiten hin; Robustheit und Eignung für größere Anwendungen werden nicht umfassend belegt.
Ausführlich lesen
Der vollständige Artikel von Darren Thiores zeigt eine einfache automatische Dependency-Injection-Umsetzung für Swift 6 und Strict Concurrency. Er setzt die Theorie der Dependency Injection voraus: Ein Objekt erhält benötigte Abhängigkeiten von außen, statt sie selbst zu erzeugen. Bei der automatischen Variante übernimmt ein zentraler Mechanismus das Bereitstellen und Einsetzen dieser Objekte. Der Beitrag knüpft an einen früheren Artikel des Autors an und konzentriert sich auf die Implementierung anhand einer Counter-App mit MVVM.
Den Kern bildet ein als `@MainActor` markierter Injector. Er speichert Abhängigkeiten in einem Wörterbuch, dessen Schlüssel aus dem jeweiligen Typnamen gebildet werden; die Werte werden als `Any` abgelegt. `@Provider` registriert eine Instanz, während `@Inject` sie anhand ihres Typs aus dem gemeinsamen Injector auflöst. Ist für einen angeforderten Typ nichts registriert, löst der gezeigte Code einen `fatalError` aus. Der Autor begründet die Main-Actor-Markierung damit, die Injektion mit Swift 6 Strict Concurrency vereinbar zu machen.
Als Beispiel definiert der Artikel das `Counter`-Protokoll mit Funktionen zum Erhöhen und Zurücksetzen eines Zählers und eine `SingleCounter`-Implementierung. Ein `AppModule` registriert diese Implementierung unter dem Protokolltyp. Damit die Registrierung vor der Nutzung erfolgt, soll die App beim Start `AppModule.inject()` aufrufen. Das ViewModel erhält den Zähler anschließend mit `@Inject`, aktualisiert seinen veröffentlichten Zählwert beim Erhöhen und setzt den Zähler in `deinit` zurück. Für diesen Aufruf verwendet das Beispiel `DispatchQueue.main.sync`, weil eine Main-Actor-isolierte Eigenschaft laut Artikel aus dem nicht isolierten Deinitialisierungskontext nicht direkt referenziert werden könne. Die SwiftUI-Ansicht erzeugt das ViewModel selbst als `@StateObject` und bietet eine Schaltfläche zum Erhöhen des Zählers.
Der Autor stellt den Ansatz als Möglichkeit dar, Abhängigkeiten zentral bereitzustellen und ihre manuelle Übergabe in größeren Projekten zu reduzieren. Er verweist auf das Dependency Inversion Principle und schlägt vor, bei vielen Abhängigkeiten mehrere Module einzusetzen. Der Artikel liefert jedoch ein Tutorial-Beispiel, keine dokumentierte Evaluation oder einen Vergleich mit anderen DI-Verfahren. Er erläutert auch keine umfassende Fehlerbehandlung oder die Folgen der gewählten Typnamenschlüssel und des gemeinsam genutzten Zustands. Der Autor räumt ausdrücklich ein, dass der Ansatz Unvollkommenheiten haben kann, und bittet um Rückmeldungen. Daher belegt der Beitrag vor allem, wie seine konkrete Beispielimplementierung aufgebaut ist; weitergehende Aussagen zu Robustheit oder Eignung für beliebige Anwendungen weist er nicht nach.
Gegengeprüft von Claude Haiku 5.5: kleine Mängel
Es wurden keine Fragen zur Einordnung angegeben (Sammelfragen und Teilfragen sind leer), daher bleibt die Einordnung leer. Die Prüfung bezieht sich auf beide von Luna gelieferten Zusammenfassungen (kurz und mittel); beide geben den Bericht ohne erfundene Angaben wieder, lassen aber die oben genannten zentralen Aussagen aus.
Im Bericht, aber nicht in der Zusammenfassung
- Die Definition von Dependency Injection als Entwurfsmuster und die Abgrenzung zu Automatic DI, bei der die Injektion automatisiert statt manuell erfolgt
- Die Motivation des Artikels, nämlich Rückfragen zur Umstellung auf Swift 6 Strict Concurrency, die den Anlass für die Neufassung gaben
Wie die Modelle den Bericht einordnen
Ansicht
Filter
Kein Modell sieht bei diesem Bericht einen Bezug zu einer der 44 Sammelfragen.