Можно ли реализовать функциональность .onDelete и .onMove для .listStyle с поддержкой Core Data (GroupedListStyle ()) в SwiftUI?

Разве вы не можете сохранить результат фильтра и передать его внутри .onDelete в свой собственный метод удаления? Тогда удаление будет означать удаление элементов внутри IndexSet. Возможно ли перемещение между разделами? Или вы просто имеете в виду внутри каждой папки? Если только внутри каждой папки вы можете использовать один и тот же трюк, использовать сохраненные проекты и реализовать перемещение вручную, но вы определяете положение в CoreData.

Общая идея такова:

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

Вы правы, что ключ к тому, что вы хотите, - это получить один массив объектов и соответствующим образом сгруппировать его. В вашем случае это ваши проекты. Вы не показываете свою схему CoreData, но я ожидаю, что у вас есть сущность «Проекты» и сущность «Папки» и связь «один ко многим» между ними. Ваша цель - создать запрос CoreData, который создает этот массив проектов и группирует их по папкам. Тогда реальный ключ - использовать NSFetchedResultsController CoreData для создания групп с помощью sectionNameKeyPath.

Для меня непрактично отправлять вам весь мой проект, поэтому я постараюсь дать вам достаточно частей моего рабочего кода, чтобы указать вам в правильном направлении. Когда у меня будет возможность, я добавлю эту концепцию в пример программы, которую я только что опубликовал на GitHub. https://github.com/Whiffer/SwiftUI-Core-Data-Test

В этом суть вашего списка:

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

Части 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)
    }

Если вы хотите легко удалять вещи из секционированных (необязательно сгруппированных!) List, вам нужно воспользоваться преимуществами вложенности. Считайте, что у вас есть следующее:

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

Теперь вы хотите настроить .onDelete. Итак, давайте увеличим масштаб объявления 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
}