Inleiding: Waarom kerngegevens en NSFetchedResultsController Matter

In de moderne iOS-ontwikkeling, het leveren van een vloeistof, responsieve gebruikersinterface is vaak afhankelijk van hoe efficiënt uw app gegevens verwerkt die in de loop van de tijd verandert. Of u nu een sociale feed, een taakbeheerder, of een inventarissysteem, de gegevens weergegeven aan gebruikers is zelden statisch. Core Data . Apple's volwassen object grafiek en persistentie kader . . gekoppeld aan (FRC) biedt een battle-geteste oplossing voor het beheer van dynamische, grootschalige datasets terwijl het houden van de UI in sync zonder handmatige overhead.

Dit artikel geeft een diepgaande, praktische handleiding voor het gebruik van Kerngegevens met meldingen is de sleutel. Wanneer objecten worden ingevoegd, bijgewerkt of verwijderd, zendt de context deze wijzigingen uit, wat precies is wat hefboomwerkingen zijn om uw UI consistent te houden.

Voor officiële documentatie over de ontwikkelaar, zie De kerngegevens van Apple referentie.

NSFetchedResultsController: De brug tussen kerngegevens en uw UI

is een controller-object dat ontworpen is om de resultaten die van een verzoek om ophalen van Core Data worden teruggestuurd efficiënt te beheren, vooral wanneer de onderliggende gegevens naar verwachting zullen veranderen. Het bewaakt de relevante beheerde objectcontext en rapporteert automatisch wijzigingen via het gedelegeerde protocol.

Belangrijkste kenmerken

  • Automatische change tracking: De FRC luistert naar contextmeldingen en vertaalt ze in gestructureerde gedelegeerde callbacks (, , ).
  • Ingebouwde sectie: Door een te specificeren, halen de controllergroepen resultaten in secties, waardoor het triviaal is om sectioned tafelweergaven of collectieweergaven weer te geven.
  • Prestatieoptimalisatie: Het FRC gebruikt fouten en caching onder de kap. Het haalt alleen gegevens op als nodig is en kan optioneel een persistente cache gebruiken om opnieuw ophalen te voorkomen wanneer de beheerde objectcontext wordt opgeslagen.

Gedelegeerde methoden in detail

Om volledig te profiteren van de controller, moet je de implementeren. Het meest voorkomende patroon is deze terugroepacties te gebruiken binnen een of ] gedelegeerden om de UI te updaten. Bijvoorbeeld:

func controllerWillChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
 tableView.beginUpdates()
}

func controller(_ controller: NSFetchedResultsController<NSFetchRequestResult>,
 didChange anObject: Any,
 at indexPath: IndexPath?,
 for type: NSFetchedResultsChangeType,
 newIndexPath: IndexPath?) {
 switch type {
 case .insert:
 tableView.insertRows(at: [newIndexPath!], with: .fade)
 case .delete:
 tableView.deleteRows(at: [indexPath!], with: .fade)
 case .update:
 tableView.reloadRows(at: [indexPath!], with: .fade)
 case .move:
 tableView.moveRow(at: indexPath!, to: newIndexPath!)
 @unknown default:
 tableView.reloadData()
 }
}

func controllerDidChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
 tableView.endUpdates()
}

Dit patroon zorgt ervoor dat de tabelweergave veranderingen in synchronisatie met de onderliggende gegevens animeert, waardoor flikkeren of inconsistentie wordt voorkomen.

Stapsgewijze uitvoering

Hieronder volgt een compleet, productie-klaar voorbeeld met Swift 5, gericht op iOS 15+. We gaan ervan uit dat een eenvoudige entiteit genaamd met eigenschappen (String) en (Bool) en een ] (Datum).

1. Stel de kerngegevensstack in

In uw of een speciale (gewoonlijk in SwiftUI-apps), maak de persistente container:

class PersistenceController {
 static let shared = PersistenceController()
 let container: NSPersistentContainer

 init() {
 container = NSPersistentContainer(name: "YourModelName")
 container.loadPersistentStores { storeDescription, error in
 if let error = error as NSError? {
 fatalError("Unresolved error \(error), \(error.userInfo)")
 }
 }
 container.viewContext.automaticallyMergesChangesFromParent = true
 }
}

2. Maak de NSManagedObject Subklasse

Gebruik de datamodeleditor van Xcode om de klassebestanden te genereren of handmatig aan te maken. Zorg ervoor dat uw entiteit de juiste klassemoduleinstelling gebruikt.

3. Configureer het verzoek om ophalen en FRC

In uw weergave controller, stel het ophalen verzoek en initialiseer de opgehaalde resultaten controller. Het is het beste om dit uit te voeren in of een weergavemodel's init.

lazy var fetchedResultsController: NSFetchedResultsController<Task> = {
 let fetchRequest: NSFetchRequest<Task> = Task.fetchRequest()
 let sortDescriptor = NSSortDescriptor(key: "dueDate", ascending: true)
 fetchRequest.sortDescriptors = [sortDescriptor]
 // Optional: limit results with batch size for large datasets
 fetchRequest.fetchBatchSize = 20

 let controller = NSFetchedResultsController(
 fetchRequest: fetchRequest,
 managedObjectContext: PersistenceController.shared.container.viewContext,
 sectionNameKeyPath: "completionStatus", // e.g., a transient attribute or a computed property
 cacheName: nil
 )
 controller.delegate = self
 try? controller.performFetch()
 return controller
}()

4. Rijd de tabelweergave met de FRC

Uw methoden worden triviaal:

func numberOfSections(in tableView: UITableView) -> Int {
 fetchedResultsController.sections?.count ?? 0
}

func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
 let sectionInfo = fetchedResultsController.sections![section]
 return sectionInfo.numberOfObjects
}

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
 let cell = tableView.dequeueReusableCell(withIdentifier: "TaskCell", for: indexPath)
 let task = fetchedResultsController.object(at: indexPath)
 configure(cell, with: task)
 return cell
}

Merk op dat we nooit oproepen handmatig .. de gedelegeerde methoden behandelen elke invoegen, verwijderen en bijwerken.

Geavanceerd gebruik en beste praktijken

Thread Safety

Core Data contexts zijn niet draadveilig. Gebruik altijd de (die draait op de hoofdwachtrij) voor alle UI-gerelateerde ophalen verzoeken en FRC's. Voor achtergrondwerk, maak een privé wachtrij context en merge wijzigingen in de weergave context. Vermijd het gebruik van dezelfde FRC in meerdere wachtrijen.

Caching

De parameter kan de lanceringsprestaties verbeteren door aanhoudende sectie- en objectinformatie. Echter, als uw ophalen verzoek of datamodel verandert, moet u de cache verwijderen () om corruptie te voorkomen.

Grote gegevenssets verwerken

Gebruik om het aantal objecten dat in het geheugen is opgehaald te beperken. Overweeg ook om ] alleen in te stellen als u direct toegang tot elke eigenschap nodig heeft. Voor relatie-intensieve gegevens kan pre-fetching met herhaalde fouten voorkomen.

Integratie met SwiftUI

Terwijl een UIKit-centrische functie heeft, kunt u het nog steeds in SwiftUI gebruiken door het in te pakken in een of door het nieuwere ]-eigenschapswikkelaar (die intern een soortgelijk mechanisme gebruikt).Voor complexe dynamische gegevens in SwiftUI is meestal voldoende, maar de FRC geeft u fijnkorrelige controle over animaties en batching.

Vaak Pitfalls en hoe ze te vermijden

  • Vergeten : De controller zal de ophaling niet uitvoeren totdat je deze methode noemt. Doe het één keer, meestal direct na initialisatie.
  • De gedelegeerde niet instellen: Zonder gedelegeerde zullen wijzigingen zich niet verspreiden in de tabelweergave. Bel altijd .
  • Foute sorteerde descriptoren: Als uw sectienaam sleutel pad niet overeenkomt met de eerste sorteerdescriptor, kunnen secties buiten de orde verschijnen. Zorg ervoor dat het attribuut dat gebruikt wordt in verschijnt in de sorteerdescriptoren.
  • Het gebruik van naast FRC:] Het bellen terwijl de FRC animatie veranderingen kan leiden tot crashes. Laat de gedelegeerde methoden alle updates van de UI behandelen.
  • Het negeren van de kerngegevenscontext slaat fouten op: Als u de context opslaat en er een fout optreedt, wordt het FRC mogelijk niet gemeld. Behandel altijd fouten en overweeg het gebruik van in achtergrondcontexten.

Prestatieoverwegingen

is al efficiënt, maar hier zijn extra optimalisaties:

  • Gebruik predicaten verstandig: Een complexe predicaat kan de eerste ophaling vertragen. Gebruik geïndexeerde attributen waar mogelijk.
  • Geef de verkregen eigenschappen terug: Als je alleen bepaalde eigenschappen nodig hebt, zet op het ophalen verzoek.
  • Bijwerken van de wedstrijd: Wanneer u veel wijzigingen aanbrengt, wordt het spelletje in een blok verpakt om het aantal gedelegeerde terugroepacties te verminderen.
  • Vermijd onnodige fouten: Als je weet dat je toegang hebt tot alle objecten in een resultaatset, gebruik dan om ze voor te halen, maar wees voorzichtig met het geheugen.

Voor een diepere duik in de prestaties van kerngegevens, zie Apple's Core Data Performance Guide.

Voorbeelden van de reële wereld

Voorbeeld 1: Chattoepassing

Een berichtenapp toont een lijst van gesprekken gesorteerd op de meest recente bericht. Nieuwe inkomende berichten moeten onmiddellijk verschijnen. Met behulp van een FRC kan het contactscherm zich alleen abonneren op wijzigingen voor de huidige conversatie-entiteiten van de gebruiker. Opdelen op datumgroepen berichten in "Vandaag," "Gisteren," enz.

Voorbeeld 2: Inventarisbeheer

Een e-commerce app toont producten in categorieën. Wanneer voorraadniveaus veranderen van een achtergrondsynchronisatie, de FRC automatisch updates van de UI. Door het instellen tot 50, blijft het beeld reageren, zelfs met duizenden items.

Voorbeeld 3: To-Do lijst met categorieën

Het klassieke voorbeeld: taken gegroepeerd in "Overdue," "Vandaag" en "Upcoming." De kan een transient afgeleid kenmerk zijn berekend uit en huidige datum. Zorg ervoor dat dezelfde afgeleide waarde wordt gebruikt in de sorteerdescriptor om mismatches te voorkomen.

Conclusie

Het beheersen van de combinatie van Core Data en is een hoeksteen van het bouwen van robuuste, dynamische iOS-toepassingen. Door het zwaar tillen van change tracking en UI-synchronisatie naar Apple's kaders te verwijderen, kunt u zich richten op het creëren van een geweldige gebruikerservaring in plaats van het schrijven van boilerplate data-management code.

Of u nu een legacy UIKit-app onderhoudt of SwiftUI adopteert met , de principes blijven hetzelfde: begrijp uw objectgrafiek, configureer fetchverzoeken zorgvuldig, en laat de opgehaalde resultatencontroller doen wat het beste is. Met de praktijken die in dit artikel worden beschreven . . inclusief caching, draadveiligheid en performance tuning . . zul je goed uitgerust zijn om alle dataset die zich in de loop van de tijd ontwikkelt te verwerken.

Voor verdere exploratie, kijk op Ray Wenderlich's Core Data tutorial en het NSHipster artikel over NSFetchedResultsController.