SwiftUI技术问询：如何在操作、定时或CoreData变更后更新视图

Got it, let’s tackle this CoreData favorites update issue head-on—this is a common pitfall when working with persistent data and UI syncing. The core problem is that your view isn’t listening for changes to the isFavorited boolean property of your Quote entity. Here’s how to fix it for both SwiftUI and UIKit setups:

SwiftUI Solution #

SwiftUI plays nicely with CoreData’s observable objects, so we just need to make sure we’re using the right property wrappers to listen for changes.

1. Single Quote View (Detail/Row) #

For individual quote views (like a row in your list or a detail screen), use @ObservedObject for your Quote entity instance. Since NSManagedObject conforms to ObservableObject out of the box, this will automatically trigger a view refresh whenever isFavorited (or any other property) changes:

struct QuoteView: View {
    @ObservedObject var quote: Quote // Your CoreData Quote entity
    @Environment(\.managedObjectContext) private var viewContext

    var body: some View {
        VStack(alignment: .leading) {
            Text(quote.content ?? "No quote text")
                .font(.body)
            Spacer()
            Button(action: toggleFavorite) {
                Image(systemName: quote.isFavorited ? "heart.fill" : "heart")
                    .foregroundColor(.red)
            }
        }
        .padding()
    }

    private func toggleFavorite() {
        // Toggle the favorite status directly on the managed object
        quote.isFavorited.toggle()
        // Save changes to CoreData
        do {
            try viewContext.save()
        } catch {
            let nsError = error as NSError
            print("Failed to save favorite status: \(nsError), \(nsError.userInfo)")
        }
    }
}

2. Quotes List View #

For your main list of quotes, use @FetchRequest to fetch your CoreData objects. FetchedResults is an observable collection, so any changes to individual quotes (like isFavorited) will automatically update the corresponding row in the list:

struct QuotesListView: View {
    // Fetch quotes sorted by date (adjust sort as needed)
    @FetchRequest(
        sortDescriptors: [NSSortDescriptor(keyPath: \Quote.dateAdded, ascending: false)],
        animation: .default
    ) private var quotes: FetchedResults<Quote>

    @Environment(\.managedObjectContext) private var viewContext

    var body: some View {
        List(quotes) { quote in
            NavigationLink(destination: QuoteView(quote: quote)) {
                HStack {
                    Text(quote.content ?? "")
                        .lineLimit(2)
                    Spacer()
                    Image(systemName: quote.isFavorited ? "heart.fill" : "heart")
                        .foregroundColor(.red)
                }
            }
        }
    }
}

UIKit Solution #

If you’re using UIKit, you’ll rely on NSFetchedResultsController to listen for CoreData changes and update your UITableView or UICollectionView in real time.

Step 1: Set Up NSFetchedResultsController #

Configure the controller to fetch your quotes, then set its delegate to handle updates:

class QuotesTableViewController: UITableViewController, NSFetchedResultsControllerDelegate {
    var fetchedResultsController: NSFetchedResultsController<Quote>!
    var managedObjectContext: NSManagedObjectContext!

    override func viewDidLoad() {
        super.viewDidLoad()
        setupFetchedResultsController()
        tableView.register(QuoteCell.self, forCellReuseIdentifier: "QuoteCell")
    }

    private func setupFetchedResultsController() {
        let fetchRequest: NSFetchRequest<Quote> = Quote.fetchRequest()
        fetchRequest.sortDescriptors = [NSSortDescriptor(keyPath: \Quote.dateAdded, ascending: false)]
        
        fetchedResultsController = NSFetchedResultsController(
            fetchRequest: fetchRequest,
            managedObjectContext: managedObjectContext,
            sectionNameKeyPath: nil,
            cacheName: nil
        )
        fetchedResultsController.delegate = self
        
        do {
            try fetchedResultsController.performFetch()
        } catch {
            fatalError("Failed to fetch quotes: \(error.localizedDescription)")
        }
    }
}

Step 2: Implement Delegate Methods for UI Updates #

The delegate methods will notify you when a quote’s properties change (like isFavorited) and let you refresh the corresponding table row:

// MARK: - NSFetchedResultsControllerDelegate
extension QuotesTableViewController {
    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 .update:
            // Reload the row when a quote's properties (like isFavorited) change
            if let indexPath = indexPath {
                tableView.reloadRows(at: [indexPath], with: .automatic)
            }
        case .insert, .delete, .move:
            // Handle other change types if needed
            break
        @unknown default:
            break
        }
    }

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

Step 3: Update Cell and Toggle Favorite #

Make sure your table cell displays the correct favorite status, and handle the toggle action:

// MARK: - UITableView DataSource/Delegate
extension QuotesTableViewController {
    override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return fetchedResultsController.sections?[section].numberOfObjects ?? 0
    }

    override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "QuoteCell", for: indexPath) as! QuoteCell
        let quote = fetchedResultsController.object(at: indexPath)
        
        cell.quoteLabel.text = quote.content
        cell.favoriteButton.setImage(
            UIImage(systemName: quote.isFavorited ? "heart.fill" : "heart"),
            for: .normal
        )
        cell.favoriteButton.tag = indexPath.row
        cell.favoriteButton.addTarget(self, action: #selector(toggleFavorite(_:)), for: .touchUpInside)
        
        return cell
    }

    @objc private func toggleFavorite(_ sender: UIButton) {
        let indexPath = IndexPath(row: sender.tag, section: 0)
        let quote = fetchedResultsController.object(at: indexPath)
        
        quote.isFavorited.toggle()
        do {
            try managedObjectContext.save()
        } catch {
            print("Failed to save favorite status: \(error.localizedDescription)")
        }
    }
}

// Custom table cell
class QuoteCell: UITableViewCell {
    let quoteLabel = UILabel()
    let favoriteButton = UIButton(type: .system)
    
    override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
        super.init(style: style, reuseIdentifier: reuseIdentifier)
        // Add subviews and layout setup (omitted for brevity)
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
}

Key Checks to Ensure Success #

• Main Thread Sync: Always perform CoreData saves on the main thread (UI updates must happen here). If you’re modifying quotes from a background thread, dispatch the save to DispatchQueue.main.
• Entity Configuration: Ensure your isFavorited property in the CoreData model is set as a Boolean, stored, and optional (if needed).
• Auto-Generated Classes: If you’re using manual CoreData classes, make sure isFavorited is declared as @NSManaged so CoreData can track changes.

内容的提问来源于stack exchange，提问作者ThurayaOtto