Wie wende ich den Typ auf eine NSFetchRequest-Instanz an?

In Swift 2 funktionierte der folgende Code:

let request = NSFetchRequest(entityName: String)

aber in Swift 3 gibt es Fehler:

Der generische Parameter "ResultType" konnte nicht abgeleitet werden

weil NSFetchRequestist jetzt ein generischer Typ. In ihren Dokumenten haben sie Folgendes geschrieben:

let request: NSFetchRequest<Animal> = Animal.fetchRequest

Wenn meine Ergebnisklasse zum Beispiel ist, Levelwie soll ich dann richtig anfordern?

Weil das nicht funktioniert:

let request: NSFetchRequest<Level> = Level.fetchRequest

let request: NSFetchRequest<NSFetchRequestResult> = Level.fetchRequest()

oder

let request: NSFetchRequest<Level> = Level.fetchRequest()

je nachdem welche version du willst.

Sie müssen den generischen Typ angeben, da der Methodenaufruf ansonsten nicht eindeutig ist.

Die erste Version ist definiert für NSManagedObject, die zweite Version wird automatisch für jedes Objekt mit einer Erweiterung generiert, z.

extension Level {
    @nonobjc class func fetchRequest() -> NSFetchRequest<Level> {
        return NSFetchRequest<Level>(entityName: "Level");
    }

    @NSManaged var timeStamp: NSDate?
}

Der springende Punkt ist, die Verwendung von String-Konstanten zu entfernen.

Ich glaube, ich habe es so gemacht:

let request:NSFetchRequest<NSFetchRequestResult> = NSFetchRequest(entityName: "Level")

Zumindest werden Daten aus der Datenbank gespeichert und geladen.

Aber es fühlt sich so an, als wäre es keine richtige Lösung, aber es funktioniert vorerst.

Die einfachste Struktur, die ich in 3.0 gefunden habe, lautet wie folgt:

let request = NSFetchRequest<Country>(entityName: "Country")

Dabei ist der Datenentitätstyp Land.

Beim Versuch, eine Core Data BatchDeleteRequest zu erstellen, stellte ich jedoch fest, dass diese Definition nicht funktioniert und Sie anscheinend das folgende Formular verwenden müssen:

let request: NSFetchRequest<NSFetchRequestResult> = Country.fetchRequest()

obwohl die Formate ManagedObject und FetchRequestResult äquivalent sein sollen.

Hier sind einige generische CoreData-Methoden, die Ihre Frage beantworten könnten:

import Foundation
import Cocoa

func addRecord<T: NSManagedObject>(_ type : T.Type) -> T
{
    let entityName = T.description()
    let context = app.managedObjectContext
    let entity = NSEntityDescription.entity(forEntityName: entityName, in: context)
    let record = T(entity: entity!, insertInto: context)
    return record
}

func recordsInTable<T: NSManagedObject>(_ type : T.Type) -> Int
{
    let recs = allRecords(T.self)
    return recs.count
}


func allRecords<T: NSManagedObject>(_ type : T.Type, sort: NSSortDescriptor? = nil) -> [T]
{
    let context = app.managedObjectContext
    let request = T.fetchRequest()
    do
    {
        let results = try context.fetch(request)
        return results as! [T]
    }
    catch
    {
        print("Error with request: \(error)")
        return []
    }
}

func query<T: NSManagedObject>(_ type : T.Type, search: NSPredicate?, sort: NSSortDescriptor? = nil, multiSort: [NSSortDescriptor]? = nil) -> [T]
{
    let context = app.managedObjectContext
    let request = T.fetchRequest()
    if let predicate = search
    {
        request.predicate = predicate
    }
    if let sortDescriptors = multiSort
    {
        request.sortDescriptors = sortDescriptors
    }
    else if let sortDescriptor = sort
    {
        request.sortDescriptors = [sortDescriptor]
    }

    do
    {
        let results = try context.fetch(request)
        return results as! [T]
    }
    catch
    {
        print("Error with request: \(error)")
        return []
    }
}


func deleteRecord(_ object: NSManagedObject)
{
    let context = app.managedObjectContext
    context.delete(object)
}

func deleteRecords<T: NSManagedObject>(_ type : T.Type, search: NSPredicate? = nil)
{
    let context = app.managedObjectContext

    let results = query(T.self, search: search)
    for record in results
    {
        context.delete(record)
    }
}

func saveDatabase()
{
    let context = app.managedObjectContext

    do
    {
        try context.save()
    }
    catch
    {
        print("Error saving database: \(error)")
    }
}

Angenommen, es gibt ein NSManagedObject-Setup für Contact wie folgt:

class Contact: NSManagedObject
{
    @NSManaged var contactNo: Int
    @NSManaged var contactName: String
}

Diese Methoden können folgendermaßen verwendet werden:

let name = "John Appleseed"

let newContact = addRecord(Contact.self)
newContact.contactNo = 1
newContact.contactName = name

let contacts = query(Contact.self, search: NSPredicate(format: "contactName == %@", name))
for contact in contacts
{
    print ("Contact name = \(contact.contactName), no = \(contact.contactNo)")
}

deleteRecords(Contact.self, search: NSPredicate(format: "contactName == %@", name))

recs = recordsInTable(Contact.self)
print ("Contacts table has \(recs) records")

saveDatabase()

Dies ist der einfachste Weg, um auf Swift 3.0 zu migrieren. Fügen Sie einfach hinzu <Country>

(getestet und gearbeitet)

let request = NSFetchRequest<Country>(entityName: "Country")

Ich hatte auch "ResultType" konnte nicht Fehler abgeleitet werden. Sie wurden gelöscht, sobald ich das Datenmodell neu erstellt und den Codegen jeder Entität auf "Klassendefinition" gesetzt habe. Ich habe hier eine kurze Beschreibung mit schrittweisen Anweisungen gemacht:

Suchen Sie nach einem übersichtlichen Tutorial zum überarbeiteten NSPersistentContainer in Xcode 8 mit Swift 3

Mit "neu erstellt" meine ich, dass ich eine neue Modelldatei mit neuen Einträgen und Attributen erstellt habe. Ein bisschen langweilig, aber es hat funktioniert!

Was bisher für mich am besten funktioniert hat war:

let request = Level.fetchRequest() as! NSFetchRequest<Level>

Ich hatte das gleiche Problem und löste es mit den folgenden Schritten:

• Wählen Sie Ihre xcdatamodeld-Datei aus und rufen Sie den Data Model Inspector auf
• Wählen Sie Ihre erste Entität aus und gehen Sie zur Abschnittsklasse
• Stellen Sie sicher, dass Codegen "Klassendefinition" ausgewählt ist.
• Entfernen Sie alle generierten Entitätsdateien. Du brauchst sie nicht mehr.

Danach musste ich alle Vorkommen von fetchRequest entfernen / neu schreiben, da XCode sich irgendwie mit der codegenerierten Version zu vermischen scheint.

HTH

Swift 3.0 Das sollte funktionieren.

let request: NSFetchRequest<NSFetchRequestResult> = NSManagedObject.fetchRequest()
request.entity = entityDescription(context)
request.predicate = predicate