Comment appliquer le type à une instance NSFetchRequest?

Dans Swift 2, le code suivant fonctionnait:

let request = NSFetchRequest(entityName: String)

mais dans Swift 3, cela donne une erreur:

Le paramètre générique "ResultType" n'a pas pu être déduit

parce que NSFetchRequestc'est maintenant un type générique. Dans leurs documents, ils ont écrit ceci:

let request: NSFetchRequest<Animal> = Animal.fetchRequest

donc si ma classe de résultat est par exemple Levelcomment dois-je demander correctement?

Parce que cela ne fonctionne pas:

let request: NSFetchRequest<Level> = Level.fetchRequest

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

ou

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

selon la version que vous souhaitez.

Vous devez spécifier le type générique car sinon, l'appel de méthode est ambigu.

La première version est définie pour NSManagedObject, la deuxième version est générée automatiquement pour chaque objet utilisant une extension, par exemple:

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

    @NSManaged var timeStamp: NSDate?
}

Le but est de supprimer l'utilisation des constantes String.

Je pense que je l'ai fait fonctionner en faisant ceci:

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

au moins, il enregistre et charge les données de DataBase.

Mais il semble que ce n'est pas une solution appropriée, mais cela fonctionne pour le moment.

La structure la plus simple que j'ai trouvée et qui fonctionne dans la version 3.0 est la suivante:

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

où le type d'entité de données est le pays.

En essayant de créer un Core Data BatchDeleteRequest, cependant, j'ai trouvé que cette définition ne fonctionne pas et il semble que vous devrez utiliser le formulaire:

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

même si les formats ManagedObject et FetchRequestResult sont supposés être équivalents.

Voici quelques méthodes CoreData génériques qui pourraient répondre à votre question:

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

En supposant qu'il existe une configuration NSManagedObject pour Contact comme ceci:

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

Ces méthodes peuvent être utilisées de la manière suivante:

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

C'est le moyen le plus simple de migrer vers Swift 3.0, il suffit d'ajouter <Country>

(testé et travaillé)

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

J'ai également eu "ResultType" ne pouvait pas être des erreurs déduites. Ils ont été effacés une fois que j'ai reconstruit le modèle de données en définissant Codegen de chaque entité sur "Définition de classe". J'ai fait un bref résumé avec des instructions étape par étape ici:

Vous recherchez un tutoriel clair sur le NSPersistentContainer révisé dans Xcode 8 avec Swift 3

Par «reconstruit», je veux dire que j'ai créé un nouveau fichier de modèle avec de nouvelles entrées et attributs. Un peu fastidieux, mais ça a marché!

Ce qui a fonctionné le mieux pour moi jusqu'à présent était:

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

J'ai eu le même problème et je l'ai résolu avec les étapes suivantes:

• Sélectionnez votre fichier xcdatamodeld et accédez à l'inspecteur de modèle de données
• Sélectionnez votre première entité et accédez à la classe Section
• Assurez-vous que Codegen "Définition de classe" est sélectionné.
• Supprimez tous vos fichiers Entity générés. Vous n'en avez plus besoin.

Après cela, j'ai dû supprimer / réécrire toutes les occurrences de fetchRequest car XCode semble en quelque sorte se mélanger avec la version générée par le code.

HTH

Swift 3.0 Cela devrait fonctionner.

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