Apakah mungkin untuk mengimplementasikan fungsionalitas.onDelete dan .onMove ke .listStyle(GroupedListStyle()) yang didukung Data Inti di SwiftUI?

Tidak bisakah Anda menyimpan hasil filter dan meneruskannya di dalam .onDelete ke metode penghapusan khusus Anda? Maka hapus berarti menghapus item di dalam IndexSet. Apakah perpindahan antar bagian mungkin dilakukan? Atau maksud Anda hanya di dalam setiap folder? Jika hanya di dalam setiap folder Anda dapat menggunakan trik yang sama, gunakan proyek yang disimpan dan terapkan pemindahan secara manual bagaimanapun Anda menentukan posisi di CoreData.

Ide umumnya adalah sebagai berikut:

import SwiftUI

class FoldersStore: ObservableObject {
    @Published var folders: [MyFolder] = [

    ]

    @Published var allProjects: [Project] = [

    ]

    func delete(projects: [Project]) {

    }
    func move(projects: [Project], set: IndexSet, to: Int) {

    }
}

struct MyFolder: Identifiable {
    let id = UUID()
    var title: String
}

struct Project: Identifiable {
    let id = UUID()
    var title: String
    var folder: UUID
}

struct FoldersAndFilesView: View {
    var body: some View {
        FoldersAndFilesView_NeedsEnv().environmentObject(FoldersStore())
    }
}

struct FoldersAndFilesView_NeedsEnv: View {
    @EnvironmentObject var store: FoldersStore

    var body: some View {
        return ForEach(store.folders) { (folder: MyFolder) in
            Section(header: Text(folder.title) ) {
                FolderView(folder: folder)
            }
        }.listStyle(GroupedListStyle())
    }
}

struct FolderView: View {
    var folder: MyFolder
    @EnvironmentObject var store: FoldersStore

    func projects(for folder: MyFolder) -> [Project] {
        return self.store.allProjects.filter{ project in project.folder == folder.id}
    }

    var body: some View {
        let projects: [Project] = self.projects(for: folder)

        return ForEach(projects) { (project: Project) in
            Text(project.title)
        }.onDelete {
            self.store.delete(projects: $0.map{
                return projects[$0]
            })
        }.onMove {
            self.store.move(projects: projects, set: $0, to: $1)
        }
    }
}

Anda benar bahwa kunci untuk melakukan apa yang Anda inginkan adalah mendapatkan satu array objek dan mengelompokkannya dengan tepat. Dalam kasus Anda, ini adalah Proyek Anda. Anda tidak menampilkan skema CoreData Anda, tetapi saya berharap Anda memiliki entitas "Proyek" dan entitas "Folder" serta hubungan satu-ke-banyak di antara keduanya. Tujuan Anda adalah membuat kueri CoreData yang membuat rangkaian Proyek tersebut dan mengelompokkannya berdasarkan Folder. Maka kunci sebenarnya adalah menggunakan NSFetchedResultsController CoreData untuk membuat grup menggunakan sectionNameKeyPath.

Tidak praktis bagi saya untuk mengirimkan seluruh proyek saya kepada Anda, jadi saya akan mencoba memberi Anda cukup banyak kode kerja saya untuk mengarahkan Anda ke arah yang benar. Jika ada kesempatan, saya akan menambahkan konsep ini ke dalam contoh program yang baru saja saya terbitkan di GitHub. https://github.com/Whiffer/SwiftUI-Core-Data-Test

Inilah inti dari Daftar Anda:

@ObservedObject var dataSource =
        CoreDataDataSource<Project>(sortKey1: "folder.order",
                                              sortKey2: "order",
                                              sectionNameKeyPath: "folderName")

    var body: some View {

        List() {

            ForEach(self.dataSource.sections, id: \.name) { section in

                Section(header: Text(section.name.uppercased()))
                {
                    ForEach(self.dataSource.objects(forSection: section)) { project in

                        ListCell(project: project)
                    }
                }
            }
        }
        .listStyle(GroupedListStyle())
    }

Bagian dari CoreDataDataSource:

let frc = NSFetchedResultsController(
            fetchRequest: fetchRequest,
            managedObjectContext: McDataModel.stack.context,
            sectionNameKeyPath: sectionNameKeyPath,
            cacheName: nil)
frc.delegate = self

    public func performFetch() {

        do {
            try self.frc.performFetch()
        } catch {

            let nserror = error as NSError
            fatalError("Unresolved error \(nserror), \(nserror.userInfo)")
        }
    }

    private var fetchedObjects: [T] {

        return frc.fetchedObjects ?? []
    }

    public var sections: [NSFetchedResultsSectionInfo] {

        self.performFetch()
        return self.frc.sections!
    }

    public func objects(forSection: NSFetchedResultsSectionInfo) -> [T] {

        return forSection.objects as! [T]
    }

    public func move(from source: IndexSet, to destination: Int) {

        self.reorder(from: source, to: destination, within: self.fetchedObjects)
    }

Jika Anda ingin dengan mudah menghapus sesuatu dari suatu bagian (tidak harus dikelompokkan!) List, Anda perlu memanfaatkan sarang Anda. Anggaplah Anda memiliki yang berikut ini:

List {
  ForEach(self.folders) { folder in
    Section(header: folder.title) {
      ForEach(folder.items) { project in
        ProjectCell(project)
      }
    }
  }
}

Sekarang Anda ingin menyiapkan .onDelete. Jadi mari kita perbesar deklarasi Section:

Section(header: Text(...)) {
  ...
}
.onDelete { deletions in
  // you have access to the current `Folder` at this level of nesting
  // this is confirmed to work with singular deletion, not multi-select deletion
  // I would hope that this actually gets called once per section that contains a deletion
  // but that is _not_ confirmed
  guard !deletions.isEmpty else { return }

  self.delete(deletions, in: folder)
}

func delete(_ indexes: IndexSet, in folder: Folder) {
  // you can now delete this bc you have your managed object type and indexes into the project structure
}