Core Data vs SwiftData Vergleich

Apples production-erprobtes Persistenz-Framework mit 20 Jahren Reife

VS
SwiftData

WWDC 2023: Swift-native Persistenz mit dem @Model-Makro ohne Boilerplate

8 Min. LesezeitiOS

Punktevergleich

Diagramm wird geladen...

Detaillierte Bewertung

Detaillierte Bewertung: Core Data und SwiftData — Bewertungen pro Kategorie auf einer Skala von 1 bis 10
KategorieCore DataSwiftData
Performance
9/10
9/10
Erlernbarkeit
4/10
9/10
Ökosystem
9/10
6/10
Community
9/10
5/10
Arbeitsmarkt
8/10
6/10
Zukunftssicherheit
6/10
10/10

Vor- und Nachteile

Core Data

Vorteile

  • Seit iOS 3 verfügbar — außerordentlich stabil und dokumentiert
  • Hervorragende Integration mit UITableView/UICollectionView über NSFetchedResultsController
  • iCloud-Synchronisierung über NSPersistentCloudKitContainer
  • Ausgereifte Unterstützung für komplexe Beziehungen und Migrationsszenarien
  • Fortgeschrittene Performance-Features wie Faulting, Batch-Operationen
  • Integration mit Core Spotlight für durchsuchbare Inhalte
  • SQLite-, Binary-, In-Memory-Store-Typen
  • Umfangreiches Community-Wissen und Stack-Overflow-Ressourcen

Nachteile

  • Umständlicher Code mit NSManagedObject — sehr viel Boilerplate
  • Thread-Sicherheit schwierig — korrekte Verwaltung des NSManagedObjectContext ist komplex
  • Steile Lernkurve — Syntax von NSFetchRequest, NSPredicate
  • Fehlermeldungen helfen Entwicklern kaum weiter
  • Für die Arbeit mit modernem Swift ist ein Wrapper nötig

Am besten geeignet für

Apps mit erforderlichem Support unter iOS 16Komplexe Datenbeziehungen und MigrationsanforderungenAnwendungen, bei denen iCloud-Synchronisierung entscheidend istGroße Datensätze und fortgeschrittene Fetch-OptimierungPflege bestehender Core-Data-Projekte

SwiftData

Vorteile

  • Ein Datenmodell in einer Zeile über das @Model-Makro definieren — kein Boilerplate
  • Native SwiftUI-Integration — automatisches UI-Update über @Query
  • Kompatibel mit Swift Concurrency — funktioniert natürlich mit async/await
  • Baut auf Core Data auf — dieselbe SQLite-Infrastruktur, dieselbe Performance
  • Die Konfiguration der iCloud-Synchronisierung ist deutlich einfacher
  • Typsichere Predicates und Sort Descriptors
  • Minimale Migrations-API — einfache Schemaänderungen automatisch

Nachteile

  • Erfordert iOS 17+ — für breiten Einsatz noch früh
  • Bei komplexen Migrationsszenarien weniger Kontrolle als bei Core Data
  • Noch in der Reifung — mit jeder WWDC können größere Änderungen kommen
  • Deutlich weniger Community-Ressourcen als bei Core Data (Stack Overflow usw.)
  • Für einige fortgeschrittene Core-Data-Funktionen gibt es noch kein Äquivalent

Am besten geeignet für

Neue Projekte mit Ziel iOS 17+Persistenz-Integration in SwiftUI-AnwendungenEinfache bis mittelkomplexe DatenmodelleSchnelles Prototyping und kleine AnwendungenNeue Projekte moderner Swift-Teams

Code-Vergleich

Core Data
// Core Data - Todo-Liste CRUD
import CoreData
import SwiftUI

// NSManagedObject-Subklasse
@objc(TodoItem)
class TodoItem: NSManagedObject {
    @NSManaged var id: UUID
    @NSManaged var title: String
    @NSManaged var isCompleted: Bool
    @NSManaged var createdAt: Date
}

// View Model
class TodoViewModel: ObservableObject {
    let container: NSPersistentContainer
    @Published var todos: [TodoItem] = []

    init() {
        container = NSPersistentContainer(name: "TodoModel")
        container.loadPersistentStores { _, error in
            if let error { fatalError("Core Data load failed: \\(error)") }
        }
        fetchTodos()
    }

    func fetchTodos() {
        let request = NSFetchRequest<TodoItem>(entityName: "TodoItem")
        request.sortDescriptors = [NSSortDescriptor(key: "createdAt", ascending: false)]
        do {
            todos = try container.viewContext.fetch(request)
        } catch {
            print("Fetch error: \\(error)")
        }
    }

    func addTodo(title: String) {
        let todo = TodoItem(context: container.viewContext)
        todo.id = UUID()
        todo.title = title
        todo.isCompleted = false
        todo.createdAt = Date()
        saveContext()
    }

    func toggleTodo(_ todo: TodoItem) {
        todo.isCompleted.toggle()
        saveContext()
    }

    private func saveContext() {
        try? container.viewContext.save()
        fetchTodos()
    }
}
SwiftData
// SwiftData - Todo-Liste CRUD
import SwiftData
import SwiftUI

// @Model-Makro — kein Boilerplate!
@Model
class TodoItem {
    var id: UUID
    var title: String
    var isCompleted: Bool
    var createdAt: Date

    init(title: String) {
        self.id = UUID()
        self.title = title
        self.isCompleted = false
        self.createdAt = Date()
    }
}

// SwiftUI View — @Query mit automatischem Update
struct TodoListView: View {
    @Environment(\.modelContext) private var context
    @Query(sort: \.createdAt, order: .reverse) private var todos: [TodoItem]
    @State private var newTitle = ""

    var body: some View {
        List {
            ForEach(todos) { todo in
                HStack {
                    Image(systemName: todo.isCompleted ? "checkmark.circle.fill" : "circle")
                        .foregroundStyle(todo.isCompleted ? .green : .gray)
                        .onTapGesture { todo.isCompleted.toggle() }
                    Text(todo.title)
                        .strikethrough(todo.isCompleted)
                }
            }
            .onDelete { indexSet in
                indexSet.forEach { context.delete(todos[$0]) }
            }
        }
        .toolbar {
            TextField("Neues Todo...", text: $newTitle)
            Button("Hinzufügen") {
                guard !newTitle.isEmpty else { return }
                context.insert(TodoItem(title: newTitle))
                newTitle = ""
            }
        }
    }
}

Fazit

Wer iOS 17+ als Ziel hat, sollte mit SwiftData starten — weniger Code, weniger Fehler, bessere SwiftUI-Integration. Bei Support für ältere Geräte, komplexen Migrationen oder einer großen bestehenden Core-Data-Basis bleibt Core Data die richtige Wahl. Da beide dieselbe Infrastruktur nutzen, lassen sie sich theoretisch auch kombinieren.

Kostenlose Beratung erhalten
FAQ

Häufig gestellte Fragen

Langfristig ja, das ist die Richtung, in die Apple investiert. Die Abschaffung von Core Data wird jedoch Jahre dauern — bestehende Core-Data-Projekte werden weiterhin unterstützt.

Verwandte Blogartikel

Alle Artikel ansehen

Verwandte Projekte

Alle Projekte ansehen
Alle Vergleiche