Introduksiyon: Kung Bakit Nakaukit ang Core Data at NSF

Sa makabagong pag-unlad ng iOS, ang paghahatid ng isang likido, tumutugong interface ay kadalasang depende sa kung gaano kahusay ang paghawak ng iyong app ng datos na nagbabago sa paglipas ng panahon.Ang paggawa mo man ng isang social feed, isang task manager, o isang sistema ng imbentaryo, ang datos na ipinapakita sa mga gumagamit ay bihirang statistika. Core Data — ang may-gulang na bagay na grap at strip na balangkas ng Apple — ay katambal ng (FRC) na nagbibigay ng solusyongresture-stic na pang-sticing, malaking mga data habang ang UI ay nag-inkorized.

Ang artikulong ito ay nagbibigay ng in-depth, praktikal na gabay sa paggamit ng Core Data na may na mga notasyon ay susi. Kapag ang mga bagay ay isiningit, inaapruba, o inalis, ang konteksto ay sumasahimpapawid ng mga pagbabagong ito, na siya mismong kung ano mga lebel upang panatilihing hindi pabagu-bago ang iyong UI.

Para sa opisyal na dokumentasyon ng developer, tumutukoy sa [Apple's Core Data Framework Reference.

NSF Nakaukit na mga ResultsController: Ang Tulay sa Pagitan ng Core Data at ng Iyong UI

ay isang controller na bagay na dinisenyo upang mahusay na pangasiwaan ang mga resulta na ibinalik mula sa isang Core Data request, lalo na kapag ang mga saligang datos ay inaasahang magbago. Ito ay sumusubaybay sa kaugnay na pinangangasiwaang konteksto ng bagay at awtomatikong nag-uulat ng mga pagbabago sa pamamagitan ng lehislatura nito.

Mga Pangunahing Katangian

  • [ Ang FRC ay nakikinig sa kontekstong normatibong at isinasalin ang mga ito sa mga naka-ayos na mga lebel callback (, , ).
  • Built-in sectioning: Sa pamamagitan ng pagtatakda ng isang , ang mga controller group ay kumukuha ng resulta sa mga seksiyon, na ginagawang maliit na ipakita ang mga sekwensiyang pagtingin o mga pananaw ng koleksiyon.
  • Performance optimisasyon: Ginagamit ng FRC ang faulting at caching sa ilalim ng hood.Nagdurulot lamang ito ng datos kung kinakailangan at maaaring gamitin nang hindi sapilitan ang isang tuloy-tuloy na cache upang maiwasan ang re-fetching kapag naligtas ang pinangasiwang kontekstong bagay.

Delegadong mga Pamamaraan

Upang lubos na makinabang sa tagakontrol, dapat mong ipatupad ang .[[[[Kalahatan:8] Ang pinakakaraniwang parisan ay ang paggamit ng mga kalwang ito sa loob ng isang o delegado upang mag-ebolb-update ng UI. Halimbawa:

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()
}

Tinitiyak ng parisang ito na ang mga bagay na may buhay ay nagbabagong - anyo at kasabay ng mga impormasyong nasa likod nito, anupat nahahadlangan ang pag - ikli o pagkakasalungatan.

Hakbang-by-Tandaang Pag-iisyu

Nasa ibaba ang isang kumpleto, produksyon-handang halimbawa gamit ang Swift 5, tinatarget ang iOS 15+.[kailangan ng sanggunian] na may mga katangian (String) at [Bool]), at isang (Date).

1. Itakda ang Core Data Stack

Sa inyong o isang dedikadong (karaniwang nasa SwiftUI apps), lumikha ng walang tigil na lalagyan:

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. Lumikha ng NSManuageObject Subclass

Gamitin ang data model editor ng Xcode para makagawa ng mga file ng klase, o gumawa ng mga ito nang manu - mano.

3. Configure the Fetch Request and FRC

Sa iyong palagay, itatag ang kahilingan ng pag - a - access at i - obserba ang nakuhang mga resulta na kumokontrol sa sakit.

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. Paunlarin ang Table View sa FRC

Ang iyong mga pamamaraan ay nagiging walang kabuluhan:

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
}

Pansinin na hindi natin tinatawag nang manu - mano — ang mga paraan ng delegado ang humahawak sa bawat pagpapasok, pag - aalis ng impormasyon, at pagre - update.

Patiunang Paggamit at Pinakamabuting mga Gawain

Likas na Kaligtasan

Ang mga konteksto ng Core Data ay hindi sinulid-ligtas. Laging gamitin ang (na tumatakbo sa pangunahing queue) para sa lahat ng mga UI-related draft requests at FRCs. Para sa background work, lumikha ng isang pribadong queue na konteksto at magsanib ng mga pagbabago sa konteksto ng pananaw. Iwasang gamitin ang parehong FRC sa ibayo ng multiple queues.

Pagdusa

Ang parameter ay maaaring magpabuti ng paglunsad sa pamamagitan ng patuloy na pag-iisyu ng seksyon at info ng bagay. Gayunpaman, kung ang iyong dratch request o data model champion, dapat mong i-disclaim () upang maiwasan ang korupsiyon.

Pakikitungo sa Malalaking Daket

Gamitin ang para limitahan ang bilang ng mga bagay na naaalala. Isa pa, isaalang-alang ang pagtatakda tangi lamang kung kailangan mo ang kagyat na pag-access sa bawat property. Para sa relasyon-intensive data, ang prefetching na may ay maaaring maiwasan ang paulit-ulit na pagkakamali.

Pagkahibang sa SwiftUI

Bagaman ang UIKit[T:30] ay UIKit[centric, magagamit mo pa rin ito sa SwiftUI sa pamamagitan ng pagbabalot nito sa isang o paggamit ng mas bago property staple (na sa loob ay gumagamit ng katulad na mekanismo). para sa masalimuot na dynamic data sa SwiftUI, ay karaniwang sapat, ngunit ang FRC ay nagbibigay sa iyo ng mahusay na kontrol sa bergrained at pag-egraint.

Karaniwang mga Patibong at Kung Paano Maiiwasan ang mga Ito

  • Forregett : Hindi ipapatupad ng tagakontrol ang singil hanggang sa tawagin mo itong paraang ito. Gawin mo ito nang minsan, karaniwang pagkatapos ng panimulang pag-aalsa.
  • Huwag magtakda ng delegado: Kung walang delegado, hindi ka maikakalat ang mga pagbabago sa tanawin ng hapag. Laging tumawag .
  • Ituwid na uri ng pagkain: Kung ang iyong bahaging pangalan ay hindi tugma sa unang uri ng mga daanan, maaaring lumitaw ang mga bahagi nang hindi tama.Patunayin ang katangiang ginamit sa ay lumilitaw sa mga uri ng awdisyon.
  • sa tabi ng FRC:] Ang pagtawag samantalang ang FRC ay mga pagbabagong pampagbabago ay maaaring maging sanhi ng mga pagbagsak. Hayaang pangasiwaan ng delegadong pamamaraan ang lahat ng UI updates.
  • [Ignored core data konteksto na nakapagliligtas ng mga kabiguan: Kung ililigtas mo ang konteksto at nangyayari ang isang pagkakamali, maaaring hindi pa ito naipagbigay alam sa FRC. Laging humawak ng mga pagkakamali at isaalang-alang ang paggamit ng sa mga kontekstong background.

Mga Pag - aasikaso sa Pag - aasikaso

ay mahusay na, ngunit narito ang karagdagang mga optimisasyon:

  • May katalinuhang gamitin ang mga marka: Ang isang masalimuot na epron ay maaaring magpabagal sa panimulang bolyum.
  • [Limitang pagkuha ng mga katangian: Kung kailangan mo lamang ng ilang katangian, magtakda sa retel request.
  • Mga update: Kapag gumagawa ng maraming pagbabago, ibalot ito sa isang bloke upang mabawasan ang bilang ng mga lebel callback.
  • Iwasan ang hindi kinakailangang pagkakamali: Kung alam mong maaccess mo ang lahat ng bagay sa isang resultang set, gamitin upang i-pre-fetch ang mga ito, ngunit maging maingat sa memorya.

Para sa mas malalim na pagsisid sa pagsasagawa ng Core Data, tingnan ang [Apple's Core Data Performance Guide.

Tunay na mga Halimbawa ng Daigdig ng mga Taga - New World

Halimbawa 1: Chat Support

Ang isang appoining app ay nagtatanghal ng isang listahan ng mga usapan na pinag-isa-isa ng karamihan ng mga kamakailang mensahe. Ang mga bagong papasok na mensahe ay dapat lumitaw agad. sa paggamit ng isang FRC, ang pananaw na kontak ay maaaring sumang-ayon sa mga pagbabago lamang para sa mga kasalukuyang ahensiya ng tagagamit. ang pag-aasal sa pamamagitan ng mga date groups ay mensahe sa "Ngayon", "Yesterday", atbp.

Halimbawa 2: Pangangasiwa sa Imahe

Kapag ang antas ng stock ay nagbago mula sa isang saligang - batas, awtomatikong binabago ng FRC ang UI. Sa pagtatakda tungo sa 50, ang pangmalas ay nananatiling tumutugon kahit sa libu - libong bagay.

Halimbawa 3: Ilista ang Tungkol sa mga Kategorya

Ang klasikong halimbawa: mga atas na inipangkat sa "Overdue", "Sa ngayon", at "Upcoming". Ang ay maaaring isang pansamantalang hinangong entidad na hinango mula sa at kasalukuyang petsa.Esure ang parehong hinangong halaga ay ginagamit sa uri ng mga indibidwal upang maiwasan ang mga mismache.

Pagsasaayos

Sa pagdadalubhasa sa kombinasyon ng Core Data at ay isang batong panulok ng pagtatayo ng matitibay, dinamikong mga aplikasyon ng iOS. sa pamamagitan ng pagtanggal ng mabigat na pagbuhat ng pagbabagong pagsubaybay at UIconclusion sa mga balangkas ng Apple, maaari mong ituon ang pansin sa paglikha ng isang dakilang karanasang tagagamit sa halip na pagsusulat ng boilerplate data wormanagement code.

Ikaw man ay nagpapanatili ng pamanang UIKit app o nag - aampon ng SwiftUI sa , ang mga simulain ay nananatili pa ring gayon: unawain ang iyong bagay na graph, maingat na isaayos ang mga kahilingan ng pagkuha, at hayaang ang mga resulta ang siyang sumusupil sa kung ano ang pinakamabuting magagawa nito.

Para sa higit pang panggagalugad, suriin ang [Ray Wenderlich's Core Data tornial[ at ang artikulo NSHipster tungkol sa NSF na inukit naRessultsContsController.