Core Data vs SwiftData Comparaison

Framework de persistance d'Apple éprouvé, avec 20 ans de maturité

VS
SwiftData

WWDC 2023 : macro @Model pour une persistance sans boilerplate

8 min de lectureiOS

Comparaison des scores

Chargement du graphique...

Notation détaillée

Notation détaillée: Core Data et SwiftData — notes sur 10, catégorie par catégorie
CatégorieCore DataSwiftData
Performance
9/10
9/10
Facilité d'apprentissage
4/10
9/10
Écosystème
9/10
6/10
Communauté
9/10
5/10
Marché de l'emploi
8/10
6/10
Pérennité
6/10
10/10

Avantages & Inconvénients

Core Data

Avantages

  • Disponible depuis iOS 3 — extrêmement stable et bien documenté
  • Intégration parfaite avec UITableView/UICollectionView via NSFetchedResultsController
  • Synchronisation cloud via NSPersistentCloudKitContainer
  • Support mature pour les relations complexes et les scénarios de migration
  • Fonctionnalités avancées comme le faulting et les opérations par lots pour ajuster les performances
  • Contenu indexable grâce à l'intégration Core Spotlight
  • Types de stockage SQLite, Binary, en mémoire
  • Vaste base de connaissances communautaire et ressources Stack Overflow

Inconvénients

  • Code verbeux avec NSManagedObject — beaucoup de boilerplate
  • Sécurité des threads délicate — bien gérer NSManagedObjectContext est complexe
  • Courbe d'apprentissage abrupte — syntaxe de NSFetchRequest et NSPredicate
  • Messages d'erreur peu utiles pour le développeur
  • Nécessite un wrapper pour s'intégrer proprement au Swift moderne

Idéal pour

Applications nécessitant un support antérieur à iOS 16Relations de données complexes et besoins de migrationApplications où la synchronisation iCloud est critiqueGrands jeux de données et optimisation avancée des requêtesMaintenance de projets Core Data existants

SwiftData

Avantages

  • Définition de modèle de données en une ligne grâce à la macro @Model — zéro boilerplate
  • Intégration native à SwiftUI — mise à jour automatique de l'UI via @Query
  • Compatible avec Swift Concurrency — fonctionne naturellement avec async/await
  • Fonctionne au-dessus de Core Data — même infrastructure SQLite, mêmes performances
  • Configuration de la synchronisation iCloud bien plus simple
  • Prédicats et descripteurs de tri type-safe
  • API de migration minimaliste — les changements de schéma simples sont automatiques

Inconvénients

  • Nécessite iOS 17+ — encore tôt pour une adoption généralisée
  • Moins de contrôle que Core Data sur les scénarios de migration complexes
  • Encore en maturation — chaque WWDC peut apporter des changements majeurs
  • Ressources communautaires/Stack Overflow bien moins nombreuses que pour Core Data
  • Pas encore d'équivalent pour certaines fonctionnalités avancées de Core Data

Idéal pour

Nouveaux projets ciblant iOS 17+Intégration de la persistance dans des applications SwiftUIModèles de données de complexité simple à moyennePrototypage rapide et petites applicationsNouveaux projets des équipes Swift modernes

Comparaison de code

Core Data
// Core Data - CRUD d'une liste de tâches
import CoreData
import SwiftUI

// Sous-classe de NSManagedObject
@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 - CRUD d'une liste de tâches
import SwiftData
import SwiftUI

// Macro @Model — zéro 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()
    }
}

// Vue SwiftUI — mise à jour automatique via @Query
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("Nouvelle tâche...", text: $newTitle)
            Button("Ajouter") {
                guard !newTitle.isEmpty else { return }
                context.insert(TodoItem(title: newTitle))
                newTitle = ""
            }
        }
    }
}

Conclusion

Si vous ciblez iOS 17+, commencez avec SwiftData — moins de code, moins d'erreurs, meilleure intégration avec SwiftUI. Pour le support d'anciens appareils, des migrations complexes ou une base Core Data de production importante, préférez Core Data. Les deux partageant la même infrastructure, ils peuvent théoriquement être utilisés ensemble.

Obtenir une consultation gratuite
FAQ

Questions fréquentes

À long terme, oui — c'est la direction dans laquelle Apple investit. Mais le retrait de Core Data prendra des années : les projets existants continueront d'être supportés.

Articles de blog associés

Voir tous les articles

Projets associés

Voir tous les projets
Toutes les comparaisons