Core Data vs Realm vs SwiftData: Kapsamlı Karşılaştırma ve Seçim Rehberi

1// NSPersistentContainer ile modern setup
2class CoreDataStack {
3    static let shared = CoreDataStack()
4    
5    lazy var persistentContainer: NSPersistentContainer = {
6        let container = NSPersistentContainer(name: "MyApp")
7        
8        // Background context için
9        container.viewContext.automaticallyMergesChangesFromParent = true
10        
11        container.loadPersistentStores { description, error in
12            if let error = error {
13                fatalError("Core Data stack failed: \(error)")
14            }
15        }
16        
17        return container
18    }()
19    
20    var viewContext: NSManagedObjectContext {
21        persistentContainer.viewContext
22    }
23    
24    func newBackgroundContext() -> NSManagedObjectContext {
25        persistentContainer.newBackgroundContext()
26    }
27    
28    func save() {
29        let context = viewContext
30        guard context.hasChanges else { return }
31        
32        do {
33            try context.save()
34        } catch {
35            print("Save error: \(error)")
36        }
37    }
38}
39 
40// Entity tanımı - .xcdatamodeld dosyasında
41// Product entity with attributes: id, name, price, stock
42 
43// NSManagedObject subclass
44@objc(Product)
45public class Product: NSManagedObject {
46    @NSManaged public var id: UUID
47    @NSManaged public var name: String
48    @NSManaged public var price: NSDecimalNumber
49    @NSManaged public var stock: Int32
50    @NSManaged public var category: Category?
51}
52 
53extension Product {
54    @nonobjc public class func fetchRequest() -> NSFetchRequest<Product> {
55        return NSFetchRequest<Product>(entityName: "Product")
56    }
57    
58    static func create(name: String, price: Decimal, stock: Int, in context: NSManagedObjectContext) -> Product {
59        let product = Product(context: context)
60        product.id = UUID()
61        product.name = name
62        product.price = NSDecimalNumber(decimal: price)
63        product.stock = Int32(stock)
64        return product
65    }
66}
67 
68// CRUD Operations
69class ProductRepository {
70    private let coreData = CoreDataStack.shared
71    
72    func fetchAll() throws -> [Product] {
73        let request = Product.fetchRequest()
74        request.sortDescriptors = [NSSortDescriptor(keyPath: \Product.name, ascending: true)]
75        return try coreData.viewContext.fetch(request)
76    }
77    
78    func search(name: String) throws -> [Product] {
79        let request = Product.fetchRequest()
80        request.predicate = NSPredicate(format: "name CONTAINS[cd] %@", name)
81        return try coreData.viewContext.fetch(request)
82    }
83    
84    func delete(_ product: Product) {
85        coreData.viewContext.delete(product)
86        coreData.save()
87    }
88}

1struct ProductListView: View {
2    @Environment(\.managedObjectContext) private var viewContext
3    
4    @FetchRequest(
5        sortDescriptors: [NSSortDescriptor(keyPath: \Product.name, ascending: true)],
6        animation: .default
7    )
8    private var products: FetchedResults<Product>
9    
10    var body: some View {
11        List {
12            ForEach(products) { product in
13                ProductRow(product: product)
14            }
15            .onDelete(perform: deleteProducts)
16        }
17    }
18    
19    private func deleteProducts(offsets: IndexSet) {
20        withAnimation {
21            offsets.map { products[$0] }.forEach(viewContext.delete)
22            try? viewContext.save()
23        }
24    }
25}

1import RealmSwift
2 
3// Model tanımı
4class RealmProduct: Object, Identifiable {
5    @Persisted(primaryKey: true) var id: ObjectId
6    @Persisted var name: String = ""
7    @Persisted var price: Double = 0
8    @Persisted var stock: Int = 0
9    @Persisted var category: RealmCategory?
10    @Persisted var tags = List<String>()
11    @Persisted var createdAt: Date = Date()
12    
13    convenience init(name: String, price: Double, stock: Int) {
14        self.init()
15        self.name = name
16        self.price = price
17        self.stock = stock
18    }
19}
20 
21// Realm configuration
22class RealmManager {
23    static let shared = RealmManager()
24    
25    var realm: Realm {
26        try! Realm(configuration: configuration)
27    }
28    
29    private var configuration: Realm.Configuration {
30        var config = Realm.Configuration.defaultConfiguration
31        config.schemaVersion = 1
32        config.migrationBlock = { migration, oldVersion in
33            // Migration logic
34        }
35        return config
36    }
37    
38    // CRUD Operations
39    func create<T: Object>(_ object: T) {
40        try? realm.write {
41            realm.add(object)
42        }
43    }
44    
45    func update(_ block: () -> Void) {
46        try? realm.write {
47            block()
48        }
49    }
50    
51    func delete<T: Object>(_ object: T) {
52        try? realm.write {
53            realm.delete(object)
54        }
55    }
56    
57    func fetchAll<T: Object>(_ type: T.Type) -> Results<T> {
58        return realm.objects(type)
59    }
60}
61 
62// SwiftUI Integration with @ObservedResults
63struct RealmProductListView: View {
64    @ObservedResults(RealmProduct.self) var products
65    
66    var body: some View {
67        List {
68            ForEach(products) { product in
69                ProductRow(product: product)
70            }
71            .onDelete(perform: $products.remove)
72        }
73    }
74}

1import SwiftData
2 
3// Model tanımı - Pure Swift, macro-based
4@Model
5final class SDProduct {
6    @Attribute(.unique) var id: UUID
7    var name: String
8    var price: Decimal
9    var stock: Int
10    var category: SDCategory?
11    var tags: [String]
12    var createdAt: Date
13    
14    init(name: String, price: Decimal, stock: Int) {
15        self.id = UUID()
16        self.name = name
17        self.price = price
18        self.stock = stock
19        self.tags = []
20        self.createdAt = Date()
21    }
22}
23 
24@Model
25final class SDCategory {
26    var name: String
27    @Relationship(inverse: \SDProduct.category) var products: [SDProduct]
28    
29    init(name: String) {
30        self.name = name
31        self.products = []
32    }
33}
34 
35// App setup
36@main
37struct MyApp: App {
38    var body: some Scene {
39        WindowGroup {
40            ContentView()
41        }
42        .modelContainer(for: [SDProduct.self, SDCategory.self])
43    }
44}
45 
46// SwiftUI Integration
47struct SwiftDataProductListView: View {
48    @Environment(\.modelContext) private var context
49    @Query(sort: \SDProduct.name) private var products: [SDProduct]
50    
51    var body: some View {
52        List {
53            ForEach(products) { product in
54                ProductRow(product: product)
55            }
56            .onDelete(perform: deleteProducts)
57        }
58    }
59    
60    private func deleteProducts(offsets: IndexSet) {
61        for index in offsets {
62            context.delete(products[index])
63        }
64    }
65}
66 
67// Dynamic Query
68struct FilteredProductsView: View {
69    @Query private var products: [SDProduct]
70    
71    init(minPrice: Decimal, category: String?) {
72        let predicate = #Predicate<SDProduct> { product in
73            product.price >= minPrice &&
74            (category == nil || product.category?.name == category)
75        }
76        _products = Query(filter: predicate, sort: \SDProduct.name)
77    }
78    
79    var body: some View {
80        List(products) { product in
81            ProductRow(product: product)
82        }
83    }
84}

1╔════════════════════════════════════════════════════════╗
2║           BENCHMARK RESULTS(ms)                       ║
3╠════════════════════════════════════════════════════════╣
4║  Operation      │ Core Data │  Realm  │ SwiftData     ║
5╠════════════════════════════════════════════════════════╣
6║  1K Insert      │    45     │   18    │    38         ║
7║  10K Insert     │   420     │   95    │   350         ║
8║  1K Read        │    12     │    5    │    10         ║
9║  10K Read       │    85     │   22    │    72         ║
10║  Complex Query  │    28     │   18    │    24         ║
11║  Memory(10K)   │   45MB    │  28MB   │   38MB        ║
12╚════════════════════════════════════════════════════════╝

1                iOS 17+ ONLY?
2                     │
3            ┌────────┴────────┐
4           YES               NO
5            │                 │
6        SwiftData      Cross-Platform?
7        (Önerilen)           │
8                     ┌───────┴───────┐
9                    YES             NO
10                     │               │
11                   Realm      CloudKit gerek?
12                                   │
13                             ┌─────┴─────┐
14                            YES         NO
15                             │           │
16                         Core Data     Realm