Come applicare il tipo a un'istanza NSFetchRequest?

In Swift 2 il codice seguente funzionava:

let request = NSFetchRequest(entityName: String)

ma in Swift 3 dà errore:

Non è stato possibile dedurre il parametro generico "ResultType"

perché NSFetchRequestora è un tipo generico. Nei loro documenti hanno scritto questo:

let request: NSFetchRequest<Animal> = Animal.fetchRequest

quindi se la mia classe di risultati è ad esempio Levelcome dovrei richiedere correttamente?

Perché questo non funziona:

let request: NSFetchRequest<Level> = Level.fetchRequest

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

o

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

a seconda della versione che desideri.

Devi specificare il tipo generico perché altrimenti la chiamata al metodo è ambigua.

La prima versione è definita per NSManagedObject, la seconda versione viene generata automaticamente per ogni oggetto utilizzando un'estensione, ad esempio:

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

    @NSManaged var timeStamp: NSDate?
}

Il punto è rimuovere l'uso delle costanti String.

Penso di averlo fatto funzionare in questo modo:

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

almeno salva e carica i dati da DataBase.

Ma sembra che non sia una soluzione adeguata, ma per ora funziona.

La struttura più semplice che ho trovato che funziona in 3.0 è la seguente:

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

dove il tipo di entità di dati è Paese.

Tuttavia, quando ho provato a creare un Core Data BatchDeleteRequest, ho scoperto che questa definizione non funziona e sembra che dovrai seguire il modulo:

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

anche se i formati ManagedObject e FetchRequestResult dovrebbero essere equivalenti.

Ecco alcuni metodi CoreData generici che potrebbero rispondere alla tua domanda:

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

Supponendo che esista una configurazione NSManagedObject per Contact come questa:

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

Questi metodi possono essere utilizzati nel modo seguente:

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

Questo è il modo più semplice per migrare a Swift 3.0, basta aggiungere <Country>

(testato e lavorato)

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

Ho anche avuto "ResultType" non poteva essere dedotto errori. Sono stati cancellati una volta che ho ricostruito il modello di dati impostando il Codegen di ciascuna entità su "Definizione classe". Ho scritto un breve articolo con le istruzioni passo passo qui:

Alla ricerca di un tutorial chiaro sul NSPersistentContainer rivisto in Xcode 8 con Swift 3

Con "ricostruito" intendo che ho creato un nuovo file modello con nuove voci e attributi. Un po 'noioso, ma ha funzionato!

Quello che ha funzionato meglio per me finora è stato:

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

Ho avuto lo stesso problema e l'ho risolto con i seguenti passaggi:

• Seleziona il tuo file xcdatamodeld e vai a Data Model Inspector
• Seleziona la tua prima entità e vai alla classe Sezione
• Assicurati che Codegen "Class Definition" sia selezionato.
• Rimuovi tutti i tuoi file Entity generati. Non ne hai più bisogno.

Dopo averlo fatto, ho dovuto rimuovere / riscrivere tutte le occorrenze di fetchRequest poiché XCode sembra in qualche modo confondersi con la versione codegenerata.

HTH

Swift 3.0 Questo dovrebbe funzionare.

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