Swift 3 Generic fetch request extension

Question

I implemented an extension for the NSManagedObjectContext that takes any CoreData class as a parameter and performs a fetch request on it.

I am new to CoreData and would very much appreciate any sort of feedback for this function

extension NSManagedObjectContext{
func fetchObjects <T: NSManagedObject>(_ entityClass:T.Type, sortBy: [NSSortDescriptor]? = nil, predicate: NSPredicate? = nil) throws -> [AnyObject]{
 var request: NSFetchRequest<NSFetchRequestResult>
 if #available(iOS 10.0, *) {
 request = entityClass.fetchRequest()
 } else {
 let entityClassName = NSStringFromClass(entityClass)
 let entityName = entityClassName.components(separatedBy: ".").last ?? entityClassName
 request = NSFetchRequest(entityName: entityName)
 }
 var fetchRequestError: Error?
 request.returnsObjectsAsFaults = false
 if let predicate = predicate {
 request.predicate = predicate
 }
 if let sortBy = sortBy {
 request.sortDescriptors = sortBy
 }
 var fetchedResult: [T]?
 do {
 fetchedResult = try self.fetch(request) as? [T]
 }
 catch let error {
 fetchRequestError = error
 //print(fetchRequestError)
 }
 guard let entityArray = fetchedResult else {
 throw fetchRequestError!
 }
 return entityArray
 }
}

Answer 1

Your code looks good, but there are some things which can be simplified. Additionally, the method can be improved to return a array of the actual managed object subclass type instead of AnyObject.

Simplifications and small improvements

var request: NSFetchRequest<NSFetchRequestResult>

request is assigned exactly once, therefore it should be a constant:

---

let request: NSFetchRequest<NSFetchRequestResult>

let entityClassName = NSStringFromClass(entityClass)
let entityName = entityClassName.components(separatedBy: ".").last ?? entityClassName

can be simplified to

let entityName = String(describing: entityClass)

which returns the unqualified class name of the given class (in contrast to String(reflecting:) which returns the fully qualified class name including the module name).

---

if let predicate = predicate {
 request.predicate = predicate
}
if let sortBy = sortBy {
 request.sortDescriptors = sortBy
}

The predicate and sortDescriptors of NSFetchRequest are optionals, so there is no need to conditionally unwrap the given parameters. You can assign them directly:

request.predicate = predicate
request.sortDescriptors = sortBy

---

fetchedResult = try self.fetch(request) as? [T]

We know that the fetch request returns an array of T objects, the cast cannot fail. Therefore the second half of the method can be reduced to

do {
 let fetchedResult = try self.fetch(request) as! [T]
 return fetchedResult
} catch let error {
 print(error.localizedDescription)
 throw error
}

making the fetchRequestError variable obsolete. And if you don't need to print the error locally then no do/catch is needed at all:

let fetchedResult = try self.fetch(request) as! [T]
return fetchedResult

A possible error will be re-thrown to the caller of the method.

---

Putting it all together, the method now looks like this:

extension NSManagedObjectContext{
 func fetchObjects <T: NSManagedObject>(_ entityClass:T.Type,
 sortBy: [NSSortDescriptor]? = nil,
 predicate: NSPredicate? = nil) throws -> [AnyObject] {
 let request: NSFetchRequest<NSFetchRequestResult>
 if #available(iOS 10.0, *) {
 request = entityClass.fetchRequest()
 } else {
 let entityName = String(describing: entityClass)
 request = NSFetchRequest(entityName: entityName)
 }
 request.returnsObjectsAsFaults = false
 request.predicate = predicate
 request.sortDescriptors = sortBy
 let fetchedResult = try self.fetch(request) as! [T]
 return fetchedResult
 }
}

---

Returning a "correctly" typed array

The return type is [AnyObject], which means that the return value has to be cast to the actual managed object subclass type

let objects = try context.fetchObjects(YourEntity.self) as! [YourEntity]

This can be improved by changing the return type to [T] and using a typed fetched request NSFetchRequest<T>:

extension NSManagedObjectContext{
 func fetchObjects <T: NSManagedObject>(_ entityClass:T.Type,
 sortBy: [NSSortDescriptor]? = nil,
 predicate: NSPredicate? = nil) throws -> [T] {
 let request: NSFetchRequest<T>
 if #available(iOS 10.0, *) {
 request = entityClass.fetchRequest() as! NSFetchRequest<T>
 } else {
 let entityName = String(describing: entityClass)
 request = NSFetchRequest(entityName: entityName)
 }
 request.returnsObjectsAsFaults = false
 request.predicate = predicate
 request.sortDescriptors = sortBy
 let fetchedResult = try self.fetch(request)
 return fetchedResult
 }
}

This is now called as

let objects = try context.fetchObjects(YourEntity.self)

and objects is an array of YourEntity without additional cast.

Answer 2

It looks solid to me, but I can't comment on performance-wise. My issue was trying to read it. It took me a few minutes of figuring it out before I had to reformat it in Xcode:

extension NSManagedObjectContext {
 func fetchObjects <T: NSManagedObject>(_ entityClass: T.Type,
 sortBy: [NSSortDescriptor]? = nil,
 predicate: NSPredicate? = nil)
 throws -> [AnyObject] {
 var request: NSFetchRequest<NSFetchRequestResult>
 if #available(iOS 10.0, *) {
 request = entityClass.fetchRequest()
 } else {
 let entityClassName = NSStringFromClass(entityClass)
 let entityName = entityClassName.components(separatedBy: ".").last
 ?? entityClassName
 request = NSFetchRequest(entityName: entityName)
 }
 var fetchRequestError: Error?
 request.returnsObjectsAsFaults = false
 if let predicate = predicate {
 request.predicate = predicate
 }
 if let sortBy = sortBy {
 request.sortDescriptors = sortBy
 }
 var fetchedResult: [T]?
 do {
 fetchedResult = try self.fetch(request) as? [T]
 }
 catch let error {
 fetchRequestError = error
 //print(fetchRequestError)
 }
 guard let entityArray = fetchedResult else {
 throw fetchRequestError!
 }
 return entityArray
 }
}

I know your style is definitely different from mine, ( I would wrap each thing up in a labeled do block, or comment each section based on its purpose) but I think that mine is considerably easier to read, and I tried to respect your coding style and the Swift conventions.

A couple places you had inconsistent spacing and linebreaks

My two biggest issues were the single line func declaration, and your nil coalesce.. I didn't realize until after I'd reformatted that you had actually assigned a value to request after that (it all looked like one line to me)

Just my 2c.. I know I tend to over-linebreak in my code, but for me, it took me a while to figure out what was going on in your code initially. A few extra breaks can help emphasize when you are starting a new logic sequence, or when you are setting one one up vs actually defining it.

Overall an "A" I think! :D Not that mine is any better. Just my take on it.

Hope this helps.

---

PS, here is my personal rendition of it:

extension NSManagedObjectContext {
 func fetchObjects<T: NSManagedObject> (_ entityClass: T.Type,
 sortBy: [NSSortDescriptor]? = nil,
 predicate: NSPredicate? = nil)
 throws -> [AnyObject] {
 // Initial request:
 var request: NSFetchRequest<NSFetchRequestResult>
 if #available(iOS 10.0, *) {
 request = entityClass.fetchRequest()
 }
 else {
 let entityClassName = NSStringFromClass(entityClass)
 let entityName = entityClassName.components(separatedBy: ".").last
 ?? entityClassName
 request = NSFetchRequest(entityName: entityName)
 }
 // Fetch request:
 var fetchRequestError: Error?
 request.returnsObjectsAsFaults = false
 if let predicate = predicate { request.predicate = predicate }
 if let sortBy = sortBy { request.sortDescriptors = sortBy }
 var fetchedResult: [T]?
 do { fetchedResult = try self.fetch(request) as? [T] }
 catch let error { fetchRequestError = error }
 // Returner:
 guard let entityArray = fetchedResult
 else { throw fetchRequestError! }
 return entityArray
 }
}