iOS-Interviewvorbereitung

iOS-Interviewfragen

20 häufig gestellte iOS-Interviewfragen. iOS-Entwicklung ist ein gefragtes Feld für Apps mit Swift, SwiftUI und UIKit sowie Lifecycle-, Concurrency-, Netzwerk-, Storage-, Performance-, Test- und App-Store-Release-Aufgaben. Die Fragen decken verschiedene Niveaus ab, und du kannst mündliche Antworten in unserem Interview-Trainer üben.

iOS-KI-Interview startenKeine Kreditkarte erforderlich. 1 kostenlose Sitzung verfügbar.
Technisches Interview-Training auf EnglischEin Modus, in dem Nicht-Muttersprachler technische Interviews üben können.

Fragen für Einsteiger

1Worin unterscheiden sich @Binding und @State in SwiftUI?

@State stellt von SwiftUI verwalteten Speicher für lokalen Zustand bereit. @Binding liest und schreibt einen Wert, dessen Quelle woanders liegt. Übergibt eine Elternansicht beispielsweise $isEnabled, kann eine untergeordnete Ansicht den Wert ändern, ohne eine eigene Kopie als Zustand zu besitzen. SwiftUI aktualisiert Ansichten, die den Zustand verwenden.

struct ParentView: View {
    @State private var isOn: Bool = false
    
    var body: some View {
        VStack {
            Text("Switch is: \(isOn ? "ON" : "OFF")")
            // Pass binding using $ prefix
            CustomToggle(isOn: $isOn)
        }
    }
}

struct CustomToggle: View {
    @Binding var isOn: Bool
    
    var body: some View {
        Button("Toggle") {
            isOn.toggle() // Modifies parent's @State
        }
    }
}
Diese Frage mit einem KI-Coach beantworten

2Welche Rolle spielt ein Provisioning Profile bei der Veröffentlichung einer iOS-App?

Ein Provisioning Profile ist eine von Apple signierte Autorisierung. Es legt fest, welche Zertifikate die App signieren dürfen, für welche App-ID und welchen Zeitraum es gilt und welche Entitlements die App beanspruchen darf. Entwicklungs- und Ad-hoc-Profile führen die zugelassenen Gerätekennungen auf. Ein App-Store-Vertriebsprofil enthält keine solche Geräteliste und dient zur Prüfung vor der Verteilung. Apple signiert die App für den Store erneut. Der aus dem Store geladene Build enthält kein eingebettetes Provisioning Profile.

Provisioning Profile (.mobileprovision)
├── App ID / Bundle Identifier (e.g., com.example.app)
├── Certificates (Public key / Distribution Certificate)
├── Entitlements (e.g., Push Notifications, Associated Domains)
└── Device UDIDs (Present for Development/Ad-Hoc; omitted for App Store distribution)
Diese Frage mit einem KI-Coach beantworten

3Was bedeutet es für eine iOS-App, Aufgaben im Hintergrund auszuführen, und welche grundlegenden Einschränkungen legt das System für diese Arbeit fest?

Die Ausführung von Aufgaben im Hintergrund bedeutet unter iOS, dass Code ausgeführt wird, während die App gerade nicht aktiv auf dem Bildschirm oder für den Benutzer sichtbar ist. Wenn ein Benutzer eine App verlässt, wechselt sie vom aktiven Vordergrundzustand in den Hintergrund und kurz darauf in einen angehaltenen Zustand (Suspended State), in dem ihre Ausführung pausiert ist, ihr Speicher jedoch im Arbeitsspeicher (RAM) verbleibt. Um die Akkulaufzeit, die Reaktionsfähigkeit des Systems und die Geräteressourcen zu schonen, kontrolliert iOS die Hintergrundausführung streng. Das System begrenzt die Dauer, für die eine App nach dem Wechsel in den Hintergrund Code ausführen darf (standardmäßig nur für eine kurze, systemgesteuerte Zeit; eine zeitlich begrenzte Anforderung zusätzlicher Hintergrundlaufzeit oder eine geeignete Hintergrundschnittstelle kann weitere Ausführung erlauben, ohne eine feste Dauer zu garantieren), drosselt die CPU- und Netzwerkpriorität und kann angehaltene Apps beenden, wenn das Gerät unter Speicherdruck gerät.

import UIKit

NotificationCenter.default.addObserver(
    forName: UIApplication.didEnterBackgroundNotification,
    object: nil,
    queue: .main
) { _ in
    print("App entered background. Code execution will pause soon unless extended.")
}
Diese Frage mit einem KI-Coach beantworten

4Welche Rolle haben Publisher und Subscriber in einer Combine-Pipeline?

Ein Publisher stellt Werte vom Typ Output bereit und kann mit .finished oder mit einem Fehler vom Typ Failure abschließen. Ein Subscriber erhält beim Abonnieren eine Subscription. Über sie fordert er Werte an und kann die Verbindung abbrechen. Er verarbeitet gelieferte Werte und gegebenenfalls den Abschluss. Ein Publisher kann zum Beispiel Netzwerkantworten liefern, während ein Subscriber daraus den Zustand einer Ansicht aktualisiert.

import Combine

// Publisher: emits a sequence of integers
let numberPublisher = [1, 2, 3].publisher

// Subscriber: consumes the emitted integers
let cancellable = numberPublisher.sink(
    receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("Finished")
        case .failure(let error):
            print("Error: \(error)")
        }
    },
    receiveValue: { value in
        print("Received: \(value)")
    }
)
Diese Frage mit einem KI-Coach beantworten

5Was bedeuten async und await in Swift, und wie rufst du damit eine asynchrone iOS-API auf?

async kennzeichnet eine Funktion, deren Ausführung ausgesetzt werden kann. await markiert eine mögliche Unterbrechung, etwa bis eine Netzwerkanfrage abgeschlossen ist. Der Thread wird beim tatsächlichen Suspendieren nicht durch Warten blockiert. Der Aufruf erfolgt in einer async-Funktion oder einem Task, bei einer werfenden Funktion mit try await. async allein verlagert synchrone oder CPU-intensive Arbeit nicht automatisch in den Hintergrund.

func fetchUserData(from url: URL) async throws -> User {
    let (data, response) = try await URLSession.shared.data(from: url)
    
    guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
        throw URLError(.badServerResponse)
    }
    
    return try JSONDecoder().decode(User.self, from: data)
}
Diese Frage mit einem KI-Coach beantworten

6Wofür eignet sich UserDefaults in einer iOS-App, und welche Daten gehören woanders hin?

Speichere dort kleine Einstellungen und Merker, etwa ein gewähltes Farbschema oder hasSeenOnboarding. Geeignet sind Eigenschaftslistentypen wie Zahlen, Strings, Bool, Date, Data und passende Arrays oder Wörterbücher. Für Passwörter, Schlüssel oder Sitzungstokens verwende den Keychain. Große Dokumente, Medien und umfangreiche Datensätze gehören in Dateien oder einen geeigneten Datenspeicher. UserDefaults bietet weder die Zugriffskontrollen des Keychain noch eine Schnittstelle für große Datenbestände.

// Saving simple preference values
UserDefaults.standard.set(true, forKey: "hasCompletedOnboarding")
UserDefaults.standard.set("dark", forKey: "preferredTheme")

// Reading values back
let hasCompletedOnboarding = UserDefaults.standard.bool(forKey: "hasCompletedOnboarding")
let theme = UserDefaults.standard.string(forKey: "preferredTheme") ?? "system"
Diese Frage mit einem KI-Coach beantworten

7Was ist ARC in Swift, und wie steuert es die Lebensdauer von Klasseninstanzen?

ARC ist automatische Referenzzählung. Der Compiler erzeugt die nötigen Halte- und Freigabeoperationen, die zur Laufzeit die Lebensdauer von Klasseninstanzen verwalten. Starke Referenzen halten eine Instanz am Leben. Wenn sie nicht mehr stark gehalten wird, wird sie freigegeben und ihr deinit ausgeführt. Der genaue Freigabezeitpunkt folgt nicht immer dem sichtbaren Ende des Gültigkeitsbereichs. Starke Referenzzyklen können Objekte auch ohne externe Besitzer am Leben halten.

class User {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) initialized")
    }
    deinit {
        print("\(name) deallocated")
    }
}

var ref1: User? = User(name: "Alice") // count = 1
var ref2: User? = ref1               // count = 2

ref1 = nil                           // count = 1
ref2 = nil                           // count = 0 -> deinit called
Diese Frage mit einem KI-Coach beantworten

8Wie sendest du mit URLSession eine einfache HTTP-GET-Anfrage in iOS?

Erzeuge eine gültige URL und rufe try await URLSession.shared.data(from: url) aus einem asynchronen Kontext auf. Alternativ erstellst du mit dataTask(with:) einen Task mit Completion-Handler und startest ihn mit resume(). Behandle Transportfehler, prüfe die HTTPURLResponse und den erwarteten Statuscode und dekodiere erst dann die Daten. Aktualisiere die Oberfläche im MainActor-Kontext.

guard let url = URL(string: "https://api.example.com/items") else { return }

let task = URLSession.shared.dataTask(with: url) { data, response, error in
    if let error = error {
        print("Network error: \(error.localizedDescription)")
        return
    }
    
    guard let httpResponse = response as? HTTPURLResponse, (200...299).contains(httpResponse.statusCode) else {
        print("Server error or invalid status code")
        return
    }
    
    if let data = data {
        DispatchQueue.main.async {
            // Update UI on main thread
        }
    }
}
task.resume()
Diese Frage mit einem KI-Coach beantworten

9Was ist Instruments in Xcode, und wie untersuchst du damit ein Leistungsproblem?

Instruments zeichnet Laufzeitdaten einer App auf. Starte über Product > Profile und wähle ein Instrument passend zum Symptom, etwa Time Profiler bei hoher CPU-Last oder Allocations und Leaks bei Speicherproblemen. Reproduziere den Ablauf möglichst auf einem Gerät. Untersuche auffällige Zeitbereiche und Aufrufstapel. Vergleiche nach einer gezielten Änderung denselben Ablauf erneut.

1. In Xcode, select Product -> Profile (Builds with Release optimizations).
2. Select the 'Time Profiler' template.
3. Click Record and perform the sluggish action in the app.
4. Stop recording.
5. Inspect the Call Tree tab:
   - Enable 'Separate by Thread' and 'Hide System Libraries'.
   - Trace the heaviest call stack on the Main Thread to identify the blocking function.
Diese Frage mit einem KI-Coach beantworten

10Welche Rolle spielt APNs bei Remote-Mitteilungen auf iOS?

APNs ist der Push-Mitteilungsdienst von Apple. Nach der Registrierung erhält die App ein Token für diese App auf dem Gerät und meldet es ihrem Server. Der Server sendet eine authentifizierte Anfrage mit Token und Mitteilungsdaten an APNs. iOS verarbeitet zugestellte Mitteilungen je nach Typ, Berechtigung und aktuellem Zustand. APNs-Zustellung und Hintergrundausführung sind nicht garantiert.

[Provider Server] ---> (HTTP/2 Request + Device Token + Payload) ---> [APNs]
                                                                           |
                                                               (Persistent APNs Connection)
                                                                           v
                                                                    [iOS Device / App]
Diese Frage mit einem KI-Coach beantworten

Fragen für Fortgeschrittene

11Wie fügen Sie neue Meldungen vorne in einen UITableView-Feed ein, sodass jede ID nur einmal vorkommt?

Erstellen Sie die neue Liste in Abrufreihenfolge und hängen Sie bestehende Einträge mit noch ungesehenen IDs an. Aktualisieren Sie auf dem Main Actor und beenden Sie die Aktualisierungsanzeige sowohl bei Erfolg als auch Fehler.

Diese Frage mit einem KI-Coach beantworten

12Was unterscheidet einen Swift-Actor von einer gewöhnlichen Klasse, wenn mehrere Tasks veränderliche Daten nutzen?

Eine geteilte Klasse schützt ihre veränderlichen Eigenschaften nicht automatisch. Der Actor bildet eine Isolationsdomäne. Sein Executor koordiniert isolierte Zugriffe und das Überschreiten der Grenze ist meist asynchron. Das hilft gegen Datenrennen ohne einzelne Eigenschaftssperren. Ein Actor hat keinen eigenen Thread und macht eine ganze async-Methode nicht atomar. Während eines await kann andere Arbeit den Zustand ändern. Danach prüfe ich Voraussetzungen erneut, halte Änderungen an Invarianten synchron zusammen und nutze bei Unterbrechungen Versionen oder Zustandsübergänge. Für nonisolated-Member und übertragene Werte gelten eigene Regeln. Fachliche Reihenfolge muss ich weiterhin gestalten.

Diese Frage mit einem KI-Coach beantworten

13Wie testen Sie Laden, Erfolg und Abbruch eines iOS-ViewModels ohne echte API?

Ich injiziere einen Fake für ein kleines API-Protokoll. Der Test steuert sein asynchrones Ergebnis, startet die Ladung, prüft den Ladezustand und liefert Daten oder Fehler. Danach prüfe ich Folgezustand und erhaltene Daten. Beim Abbruch müssen Task und Ladeanzeige entsprechend dem UI-Vertrag beendet werden, ohne gewöhnliche Fehlermeldung außer wenn vorgesehen. Mit einer verspäteten Antwort teste ich, dass ein veralteter Aufruf keine neue Auswahl überschreibt. Ich beachte Actor-Isolation, verwende explizite Synchronisation oder steuerbare Uhr statt Schlafpausen und teste erneutes Laden, Freigabe und Bildschirmwechsel. Die Prüfung gilt beobachtbarem Verhalten ohne Netz und Zugangsdaten.

Diese Frage mit einem KI-Coach beantworten

14Wie baust du mit Combine eine Suche mit Eingabepause, Deduplizierung und sicheren Oberflächenaktualisierungen?

Verarbeite Suchtext mit debounce und removeDuplicates. Bilde jeden gültigen Begriff auf einen Anfrage-Publisher ab und verwende switchToLatest. Das beendet das vorherige Abonnement, sobald ein neuer innerer Publisher eintrifft. Während der Eingabepause kann die ältere Anfrage noch aktiv sein. Ordne Ergebnisse deshalb dem aktuellen Begriff zu. Fange Fehler im inneren Publisher ab und unterscheide Fehler von leeren Ergebnissen. Liefere den Darstellungszustand auf dem Hauptscheduler aus.

import Combine
import Foundation

class SearchViewModel: ObservableObject {
    @Published var query: String = ""
    @Published var searchResults: [String] = []
    private var cancellables = Set<AnyCancellable>()
    
    init() {
        $query
            .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
            .removeDuplicates()
            .map { query -> AnyPublisher<[String], Never> in
                guard !query.trimmingCharacters(in: .whitespaces).isEmpty else {
                    return Just([]).eraseToAnyPublisher()
                }
                return self.performSearch(query)
                    .catch { _ in Just([]) }
                    .eraseToAnyPublisher()
            }
            .switchToLatest()
            .receive(on: DispatchQueue.main)
            .assign(to: &$searchResults)
    }
    
    private func performSearch(_ term: String) -> AnyPublisher<[String], Error> {
        let url = URL(string: "https://api.example.com/search?q=\(term)")!
        return URLSession.shared.dataTaskPublisher(for: url)
            .map(\.data)
            .decode(type: [String].self, decoder: JSONDecoder())
            .eraseToAnyPublisher()
    }
}
Diese Frage mit einem KI-Coach beantworten

15Wie bindest du asynchrones Laden an einen iOS-Bildschirm, damit veraltete Ergebnisse die Oberfläche nicht überschreiben?

Verwende in SwiftUI task oder task(id:). Halte in UIKit den Task fest und brich ihn an der passenden Sichtbarkeitsgrenze und bei einem neueren Auftrag ab. Prüfe den Abbruch nach Wartepunkten und vor der Zuweisung. Vergleiche bei konkurrierenden Aufrufen zusätzlich Anfrage-ID oder aktuelle Auswahl. Führe diese Prüfung und die Zuweisung gemeinsam auf dem MainActor aus. Behandle Abbruch getrennt von echten Fehlern.

@MainActor
final class UsersViewController: UIViewController {
    private var loadTask: Task<Void, Never>?
    private let service: UserService

    override func viewDidLoad() {
        super.viewDidLoad()
        loadUsers()
    }

    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        loadTask?.cancel()
    }

    private func loadUsers() {
        loadTask?.cancel()
        loadingView.isHidden = false

        loadTask = Task { [weak self] in
            do {
                let users = try await self?.service.fetchUsers() ?? []
                try Task.checkCancellation()

                guard let self else { return }
                self.loadingView.isHidden = true
                self.tableModel = users
                self.tableView.reloadData()
            } catch is CancellationError {
                // User navigated away or a new load replaced this one; do not update UI.
            } catch {
                guard let self else { return }
                self.loadingView.isHidden = true
                self.showError(error)
            }
        }
    }
}
Diese Frage mit einem KI-Coach beantworten

16Wie würden Sie bei unterschiedlichen Arten von App-Daten zwischen UserDefaults, Keychain, Dateien, SQLite und Core Data wählen?

Die Wahl des passenden iOS-Speichermechanismus hängt von Datensensibilität, Datenmenge, relationaler Komplexität, Abfrageanforderungen und dem Backup-Lebenszyklus ab: 1. **Keychain**: Für sensible Daten (Authentifizierungs-Tokens, Passwörter, Verschlüsselungsschlüssel). Unterstützt verschlüsselte Speicherung und Zugriffskontrollen. Biometrische Vorlagen verwaltet weiterhin das System; Apps erhalten keinen Zugriff darauf. Keychain garantiert keine Geheimhaltung gegenüber Code, der mit den berechtigten Zugriffsrechten der App ausgeführt wird. Ein Fortbestand nach Neuinstallation darf nicht als zugesicherter Speichervertrag behandelt werden. 2. **UserDefaults**: Für einfache, unkritische Einstellungen und Flags (z. B. `hasCompletedOnboarding`, Theme-Auswahl). Da UserDefaults für kleine Einstellungen optimiert ist, sollte es nicht für große Datensätze, Mediendateien oder sensible Tokens verwendet werden. 3. **Dateisystem (Documents / Caches / Application Support)**: Für eigenständige Dateien und große Binärdaten (heruntergeladene Bilder, Audio, PDFs). `Documents` ist nutzerorientiert und wird in iCloud gesichert; `Caches` dient für löschbare, wiederherunterladbare Inhalte; `Application Support` ist für persistente Dateien gedacht, die nicht direkt für den Nutzer sichtbar sind. 4. **SQLite**: Für strukturierte, tabellarische Daten mit Bedarf an schnellen indizierten Abfragen, Massenoperationen oder plattformübergreifender Datenbanknutzung ohne den Overhead eines Objektgraphen. 5. **Core Data / SwiftData**: Für komplexe Objektgraphen mit Relationen, Änderungsverfolgung, Faulting, Undo-Management und nativer Anbindung an UIKit (`NSFetchedResultsController`) oder SwiftUI (`@Query`).

- Auth tokens / API keys          -> Keychain (Hardware-backed encrypted store)
- App settings / UI flags         -> UserDefaults (Lightweight key-value, non-sensitive)
- Downloaded videos / PDFs        -> File System (Documents / Caches directory)
- 50k items with complex queries   -> SQLite / Core Data / SwiftData (Indexed, relationship-aware)
Diese Frage mit einem KI-Coach beantworten

17Wann erfasst du self in UIKit-Callbacks stark, weak oder unowned?

Prüfe, wer den Callback hält und wie lange er aufgerufen werden kann. Hält der Controller das ViewModel und dieses den Callback, kann starkes Erfassen von self einen Zyklus bilden. Verwende dann etwa [weak self] und behandle nil. unowned ist nur bei einer gesicherten Lebensdauer sinnvoll. Eine nicht entweichende oder kurzlebige Closure ohne Rückzyklus darf self stark halten, wenn das gewünschte Verhalten ist.

final class ProfileViewController: UIViewController {
    private let viewModel: ProfileViewModel

    init(viewModel: ProfileViewModel) {
        self.viewModel = viewModel
        super.init(nibName: nil, bundle: nil)
    }

    required init?(coder: NSCoder) { fatalError() }

    override func viewDidLoad() {
        super.viewDidLoad()
        
        // VM stores the callback -> capture weak self to break retain cycle
        viewModel.onDataUpdated = { [weak self] state in
            guard let self else { return }
            self.updateUI(with: state)
        }
    }

    private func updateUI(with state: ProfileState) { /* Update views */ }
}
Diese Frage mit einem KI-Coach beantworten

Fragen für Erfahrene

18Wie führen Sie SwiftUI in einer großen UIKit-App Bildschirm für Bildschirm ein?

Ich wähle eine abgegrenzte Ansicht mit klaren Ein- und Ausgaben, bette sie mit UIHostingController ein und behalte UIKit-Navigation und Lebenszyklus. Fachlogik und Repositories bleiben frameworkunabhängig, jeder Bildschirmzustand hat einen Eigentümer. Für vorhandene UIKit-Controls oder Controller verwende ich UIViewRepresentable oder UIViewControllerRepresentable und gegebenenfalls einen Coordinator für Rückrufe. Ich prüfe Navigation, Schließen, Fokus, Barrierefreiheit, Themes und unterstützte Systemversionen. Ich teste Verhalten und Übergänge, vergleiche Darstellung und Leistung und ermögliche bei Bedarf einen umkehrbaren Einstieg. So migriere ich schrittweise ohne konkurrierende Zustandsquellen.

Diese Frage mit einem KI-Coach beantworten

19Wie planst du den Rollout einer stark genutzten iOS-App mit lokaler Migration und neuer Backend-Schnittstelle?

Stelle zuerst eine rückwärtskompatible Backend-Version bereit. Teste lokale Migrationen aus allen unterstützten Ausgangsversionen, einschließlich Unterbrechung, Platzmangel und Neustart. Schalte neue Funktionen getrennt von der Verteilung und mit sicheren Standardwerten frei. Überwache Migrationsfehler, Abstürze und API-Fehler während der Staffelung. Eine Pause oder ein Funktionsschalter repariert keine bereits installierte Binärdatei und macht keine lokale Migration rückgängig. Halte daher einen getesteten Korrekturpfad bereit.

Phase 1 (Backend Expand): Deploy API v2 supporting both new and legacy payloads.
Phase 2 (Client Distribution & Migration): Release client v2.0 via App Store Phased Release (1% -> 100%). DB migrates safely on first launch. Feature flag remains OFF.
Phase 3 (Validation & Feature Enablement): Monitor crash rates & migration success. Incrementally ramp Remote Config flag (10% -> 50% -> 100%).
Phase 4 (Backend Contract): Once legacy app adoption drops below deprecation threshold, sunset API v1.
Diese Frage mit einem KI-Coach beantworten

20Sie entwerfen eine Offline-First-Synchronisation für eine Notizen-App, bei der Bearbeitungen letztendlich über mehrere Geräte hinweg synchronisiert werden müssen, iOS Hintergrundaufgaben jedoch verzögern oder abbrechen kann. Welche Architektur für die Hintergrundausführung würden Sie wählen?

Eine Offline-First-Synchronisationsarchitektur betrachtet die lokale Datenbank (wie SQLite, Core Data oder SwiftData) als unmittelbare maßgebliche Quelle für den Zustand der Benutzeroberfläche (UI), während Mutationen an eine persistente Outbox-Queue auf der Festplatte angehängt werden, damit ungesendete Bearbeitungen Prozessabbrüche überstehen. Um die opportunistische und nicht-deterministische Hintergrundausführung von iOS zu handhaben, wird die Hintergrundarbeit mehrstufig strukturiert: 1. Outbox-Leerung beim Wechsel in den Hintergrund: Initiiert über `UIApplication.shared.beginBackgroundTask(expirationHandler:)`, um laufende oder kurze anstehende Mutationen abzuschließen. 2. Opportunistisch geplante Synchronisation: Registriert beim `BGTaskScheduler` unter Verwendung von `BGAppRefreshTask` für leichtgewichtige Metadaten-/Delta-Synchronisationen und `BGProcessingTask` für aufwendigere Synchronisationsvorgänge. 3. Synchronisation großer Dateien: Auslagerung aus dem Hauptprozess über eine Hintergrund-`URLSessionConfiguration` für Datei-Uploads und -Downloads. 4. Server-getriggerte Synchronisation: Opportunistisches Aufwecken über Silent Push Notifications (`content-available: 1`). Da Hintergrundaufgaben jederzeit unterbrochen oder neu terminiert werden können, müssen Operationen clientseitig erzeugte Idempotenzschlüssel (z. B. universell eindeutige Kennungen, UUIDs) verwenden, um sichere Wiederholungsversuche ohne Datenverdopplung zu ermöglichen. Wird der `expirationHandler` einer Aufgabe aufgerufen, muss die laufende Arbeit sofort abgebrochen werden, unbestätigte Operationen müssen wieder als ausstehend markiert werden und `setTaskCompleted(success: false)` muss aufgerufen werden. Synchronisieren Sie außerdem beim Wechsel in den Vordergrund und nach lokalen Änderungen mit einer einzigen koordinierten Zuständigkeit für die Synchronisation. Ein Start im Hintergrund ist nie garantiert; versprechen Sie daher keine feste Frist bis zur Konvergenz. Letztliche Konsistenz wird mithilfe von Konfliktlösungsmechanismen angestrebt, etwa CRDTs (konfliktfrei replizierbaren Datentypen), Versionsvektoren zusammen mit einer Zusammenführungsregel oder dem Vorrang des letzten Schreibvorgangs mit Löschmarkierungen. Dabei dürfen entfernte Änderungen noch nicht festgeschriebene lokale Outbox-Änderungen nicht überschreiben.

import BackgroundTasks
import Foundation

final class NoteSyncCoordinator {
    static let shared = NoteSyncCoordinator()
    private let syncTaskID = "com.notesapp.sync.refresh"

    func registerSyncTask() {
        BGTaskScheduler.shared.register(forTaskWithIdentifier: syncTaskID, using: nil) { task in
            guard let refreshTask = task as? BGAppRefreshTask else { return }
            self.handleAppRefresh(task: refreshTask)
        }
    }

    func scheduleNextSync() {
        let request = BGAppRefreshTaskRequest(identifier: syncTaskID)
        request.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60)
        try? BGTaskScheduler.shared.submit(request)
    }

    private func handleAppRefresh(task: BGAppRefreshTask) {
        scheduleNextSync()
        let syncTask = Task {
            do {
                try await SyncEngine.shared.flushPersistentOutboxAndFetchDeltas()
                task.setTaskCompleted(success: true)
            } catch {
                task.setTaskCompleted(success: false)
            }
        }

        task.expirationHandler = {
            syncTask.cancel()
        }
    }
}
Diese Frage mit einem KI-Coach beantworten

Übe Interviews auf deinem Smartphone: iOS-Entwickler

Antworte laut und erhalte KI-Feedback in der Android-App.

EngineerSpeak bei Google Play herunterladen
Zum Download scannen