Cómo filtrar NSFetchedResultsController (CoreData) con UISearchDisplayController/UISearchBar

Algunos han comentado que esto se puede hacer con un solo NSFetchedResultsController. Eso es lo que hice, y aquí están los detalles. Esta solución asume que solo desea filtrar la tabla y mantener todos los demás aspectos (orden de clasificación, diseño de celdas, etc.).) de los resultados de la búsqueda.

Primero, defina dos propiedades en su subclase UITableViewController (con el @synthesize apropiado y dealloc, si corresponde):

@property (nonatomic, retain) UISearchDisplayController *searchController;
@property (nonatomic, retain) NSString *searchString;

En segundo lugar, inicialice la barra de búsqueda en el método viewDidLoad: de su UITableViewController subclase:

UISearchBar *searchBar = [[UISearchBar alloc] initWithFrame:CGRectMake(0,0,self.tableView.frame.size.width,44)]; 
searchBar.placeholder = @"Search";
searchBar.delegate = self;
self.searchController = [[[UISearchDisplayController alloc] initWithSearchBar:searchBar contentsController:self] autorelease];
self.searchController.delegate = self;
self.searchController.searchResultsDataSource = self;   
self.searchController.searchResultsDelegate = self; 
self.tableView.tableHeaderView = self.searchController.searchBar;
[searchBar release];

Tercero, implementa los métodos de delegado UISearchDisplayController de esta manera:

// This gets called when you start typing text into the search bar
-(BOOL)searchDisplayController:(UISearchDisplayController *)_controller shouldReloadTableForSearchString:(NSString *)_searchString {
   self.searchString = _searchString;
   self.fetchedResultsController = nil;
   return YES;
}

// This gets called when you cancel or close the search bar
-(void)searchDisplayController:(UISearchDisplayController *)controller willUnloadSearchResultsTableView:(UITableView *)tableView {
   self.searchString = nil;
   self.fetchedResultsController = nil;
   [self.tableView reloadData];
}

Finalmente, en el método fetchedResultsController cambiar el NSPredicate dependiendo de si self.searchString se define:

-(NSFetchedResultsController *)fetchedResultsController {
   if (fetchedResultsController == nil) {

       // removed for brevity

      NSPredicate *predicate;

      if (self.searchString) {
         // predicate that uses searchString (used by UISearchDisplayController)
         // e.g., [NSPredicate predicateWithFormat:@"name CONTAINS[cd] %@", self.searchString];
          predicate = ... 
      } else {
         predicate = ... // predicate without searchString (used by UITableViewController)
      }

      // removed for brevity

   }

   return fetchedResultsController;
} 

Me llevó unos cuantos intentos hacer que esto funcionara...

Mi clave para entender fue darme cuenta de que hay dos TableViews trabajando aquí. Uno administrado por mi viewcontroller y otro administrado por el searchviewcontroller y luego pude probar para ver cuál está activo y hacer lo correcto. La documentación también fue útil:

Http://developer.apple.com/library/ios/#documentation/uikit/reference/UISearchDisplayController_Class/Reference/Reference.html

Aquí está lo que hice -

Se ha añadido la bandera searchIsActive:

@interface ItemTableViewController : UITableViewController <NSFetchedResultsControllerDelegate, UISearchDisplayDelegate, UISearchBarDelegate> {

    NSString *sectionNameKeyPath;
    NSArray *sortDescriptors;


@private
    NSFetchedResultsController *fetchedResultsController_;
    NSManagedObjectContext *managedObjectContext_;

    BOOL searchIsActive;

}

@property (nonatomic, retain) NSManagedObjectContext *managedObjectContext;
@property (nonatomic, retain) NSFetchedResultsController *fetchedResultsController;
@property (nonatomic, retain) NSString *sectionNameKeyPath;
@property (nonatomic, retain) NSArray *sortDescriptors;
@property (nonatomic) BOOL searchIsActive;

Se agregó la síntesis en el archivo de implementación.

Luego agregué estos métodos para buscar:

#pragma mark -
#pragma mark Content Filtering

- (void)filterContentForSearchText:(NSString*)searchText scope:(NSString*)scope
{
    NSFetchRequest *aRequest = [[self fetchedResultsController] fetchRequest];

    NSPredicate *predicate = [NSPredicate predicateWithFormat:@"name BEGINSWITH[cd] %@", searchText];

    [aRequest setPredicate:predicate];

    NSError *error = nil;
    if (![[self fetchedResultsController] performFetch:&error]) {
        // Handle error
        NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
        abort();
    }  

}

#pragma mark -
#pragma mark UISearchDisplayController Delegate Methods

- (BOOL)searchDisplayController:(UISearchDisplayController *)controller shouldReloadTableForSearchString:(NSString *)searchString
{
    [self filterContentForSearchText:[self.searchDisplayController.searchBar text] scope:nil];

    return YES;
}

/*
- (BOOL)searchDisplayController:(UISearchDisplayController *)controller shouldReloadTableForSearchScope:(NSInteger)searchOption
{
    return YES;
}
*/

- (void)searchDisplayControllerWillBeginSearch:(UISearchDisplayController *)controller {
    [self setSearchIsActive:YES];
    return;
}

- (void)searchDisplayControllerDidEndSearch:(UISearchDisplayController *)controller 
{
    NSFetchRequest *aRequest = [[self fetchedResultsController] fetchRequest];

    [aRequest setPredicate:nil];

    NSError *error = nil;
    if (![[self fetchedResultsController] performFetch:&error]) {
        // Handle error
        NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
        abort();
    }  

    [self setSearchIsActive:NO];
    return;
}

Luego en controllerWillChangeContent:

- (void)controllerWillChangeContent:(NSFetchedResultsController *)controller 
{
    if ([self searchIsActive]) {
        [[[self searchDisplayController] searchResultsTableView] beginUpdates];
    }
    else  {
        [self.tableView beginUpdates];
    }
}

Y controllerDidChangeContent:

- (void)controllerDidChangeContent:(NSFetchedResultsController *)controller 
{
    if ([self searchIsActive]) {
        [[[self searchDisplayController] searchResultsTableView] endUpdates];
    }
    else  {
        [self.tableView endUpdates];
    }
}

Y borra la caché al restablecer el predicado.

Espero que esto ayude.

Me enfrenté a la misma tarea y encontré LA FORMA MÁS SIMPLE POSIBLE para resolverlo. En breve: necesita definir un método más, muy similar a -fetchedResultsController con un predicado compuesto personalizado.

En mi caso personal mi -fetchedResultsController se ve así:

- (NSFetchedResultsController *) fetchedResultsController
{
    if (fetchedResultsController != nil)
    {
        return fetchedResultsController;
    }
    NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];
    NSEntityDescription *entity = [NSEntityDescription entityForName:@"Client"
                                              inManagedObjectContext:[[PTDataManager sharedManager] managedObjectContext]];
    [fetchRequest setEntity:entity];

    NSPredicate *predicate = [NSPredicate predicateWithFormat:@"agency_server_id == %@", agency.server_id];
    fetchRequest.predicate = predicate;

    NSSortDescriptor *sortByName1Descriptor = [[NSSortDescriptor alloc] initWithKey:@"lastname" ascending:YES];
    NSSortDescriptor *sortByName2Descriptor = [[NSSortDescriptor alloc] initWithKey:@"firstname" ascending:YES];
    NSSortDescriptor *sortByName3Descriptor = [[NSSortDescriptor alloc] initWithKey:@"middlename" ascending:YES];
    NSArray *sortDescriptors = [[NSArray alloc] initWithObjects: sortByName1Descriptor, sortByName2Descriptor, sortByName3Descriptor, nil];

    fetchRequest.sortDescriptors = sortDescriptors;

    fetchedResultsController = [[NSFetchedResultsController alloc]initWithFetchRequest:fetchRequest managedObjectContext:[[PTDataManager sharedManager] managedObjectContext] sectionNameKeyPath:nil cacheName:nil];
    fetchedResultsController.delegate = self;
    return fetchedResultsController;
}

Como puede ver, estoy buscando clientes de una agencia filtrada por agency.server_id predicado. Como resultado, estoy recuperando mi contenido en un tableView (todo relacionado con la implementación del código tableView y fetchedResultsController es bastante estándar) como bien. Para implementar searchField estoy definiendo un método delegado UISearchBarDelegate. Lo estoy activando con el método de búsqueda, por ejemplo -reloadTableView:

- (void)searchBar:(UISearchBar *)searchBar textDidChange:(NSString *)searchText
{
    [self reloadTableView];
}

Y por supuesto la definición de -reloadTableView:

- (void)reloadTableView
{
    NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];
    NSEntityDescription *entity = [NSEntityDescription entityForName:@"Client"
                                              inManagedObjectContext:[[PTDataManager sharedManager] managedObjectContext]];
    [fetchRequest setEntity:entity];

    NSSortDescriptor *sortByName1Descriptor = [[NSSortDescriptor alloc] initWithKey:@"lastname" ascending:YES];
    NSSortDescriptor *sortByName2Descriptor = [[NSSortDescriptor alloc] initWithKey:@"firstname" ascending:YES];
    NSSortDescriptor *sortByName3Descriptor = [[NSSortDescriptor alloc] initWithKey:@"middlename" ascending:YES];
    NSArray *sortDescriptors = [[NSArray alloc] initWithObjects: sortByName1Descriptor, sortByName2Descriptor, sortByName3Descriptor, nil];
    fetchRequest.sortDescriptors = sortDescriptors;

    NSPredicate *idPredicate = [NSPredicate predicateWithFormat:@"agency_server_id CONTAINS[cd] %@", agency.server_id];
    NSString *searchString = self.searchBar.text;
    if (searchString.length > 0)
    {
        NSPredicate *firstNamePredicate = [NSPredicate predicateWithFormat:@"firstname CONTAINS[cd] %@", searchString];
        NSPredicate *lastNamePredicate = [NSPredicate predicateWithFormat:@"lastname CONTAINS[cd] %@", searchString];
        NSPredicate *middleNamePredicate = [NSPredicate predicateWithFormat:@"middlename CONTAINS[cd] %@", searchString];
        NSPredicate *orPredicate = [NSCompoundPredicate orPredicateWithSubpredicates:[NSArray arrayWithObjects:firstNamePredicate, lastNamePredicate, middleNamePredicate, nil]];
        NSPredicate *andPredicate = [NSCompoundPredicate andPredicateWithSubpredicates:[NSArray arrayWithObjects:idPredicate, nil]];
        NSPredicate *finalPred = [NSCompoundPredicate andPredicateWithSubpredicates:[NSArray arrayWithObjects:orPredicate, andPredicate, nil]];
        [fetchRequest setPredicate:finalPred];
    }
    else
    {
        [fetchRequest setPredicate:idPredicate];
    }

    self.fetchedResultsController = [[NSFetchedResultsController alloc]initWithFetchRequest:fetchRequest managedObjectContext:[[PTDataManager sharedManager] managedObjectContext] sectionNameKeyPath:nil cacheName:nil];
    self.fetchedResultsController.delegate = self;

    NSError *error = nil;
    if (![self.fetchedResultsController performFetch:&error])
    {
        NSLog(@"Unresolved error %@, %@", [error localizedDescription], [error localizedFailureReason]);
    }; 

    [self.clientsTableView reloadData];
}

Este montón de código es muy similar a first, "standard" -fetchedResultsController PERO dentro de la declaración if-else aquí está:

+andPredicateWithSubpredicates: - usando este método podemos establecer un predicado para guardar los resultados de nuestra primera búsqueda principal en el tableView

+orPredicateWithSubpredicates - usando este método estamos filtrando fetch existente por consulta de búsqueda desde searchBar

Al final estoy estableciendo una matriz de predicados como un predicado compuesto para este fetch particular. Y para predicados requeridos, O para opcional.

Y eso es todo! No necesitas implementar nada más. ¡Feliz programación!

¿Está utilizando una búsqueda en vivo?

Si NO lo está, probablemente desee un array (o un NSFetchedResultsController) con las búsquedas anteriores que usó, cuando el usuario presiona "search", le dice a su FetchedResults que cambie su predicado.

De cualquier manera, tendrá que reconstruir sus resultados obtenidos cada vez. Recomiendo usar solo un NSFetchedResultsController, ya que tendrás que duplicar mucho tu código y no necesitas desperdiciar memoria en algo que no eres exhibición.

Solo asegúrese de tener una variable NSString" searchParameters " y su método FetchedResults la reconstruye según sea necesario, utilizando los parámetros de búsqueda si están disponibles, solo debe hacer:

A) establezca los "searchParameters" en algo (o nil, si desea todos los resultados).

B) libera y establece en nil el objeto NSFetchedResultsController actual.

C) datos de la tabla de recarga.

Aquí hay un código simple:

- (void)searchString:(NSString*)s {
    self.searchResults = s;
    [fetchedResultsController release];
    fetchedResultsController = nil;
    [self.tableView reloadData];
}

-(NSFetchedResultsController *)fetchedResultsController {
    if (fetchedResultsController != nil) {
        return fetchedResultsController;
    }

    NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];
    NSEntityDescription *entity = [NSEntityDescription entityForName:@"EntityName" inManagedObjectContext:self.context];
    [fetchRequest setEntity:entity];

    [fetchRequest setFetchBatchSize:20];

    // searchResults is a NSString*
    if (searchResults != nil) {
        NSPredicate *predicate = [NSPredicate predicateWithFormat:@"name LIKE %@",searchResults];
        [fetchRequest setPredicate:predicate];
    }

    fetchedResultsController = 
    [[NSFetchedResultsController alloc] initWithFetchRequest:fetchRequest 
        managedObjectContext:self.context sectionNameKeyPath:nil 
        cacheName:nil];
    fetchedResultsController.delegate = self;

    [fetchRequest release];

    return fetchedResultsController;    
}

Swift 3.0, UISearchController, NSFetchedResultsController y Core Data

Este código funcionará en Swift 3.0 con Core Data! Necesitará un único método delegado y unas pocas líneas de código para filtrar y buscar objetos del modelo. Nada será necesario si ha implementado todos los métodos FRC y sus delegate, así como searchController.

El método del protocolo UISearchResultsUpdating

func updateSearchResults(for searchController: UISearchController) {

    let text = searchController.searchBar.text

    if (text?.isEmpty)! {
       // Do something 
    } else {
        self.fetchedResultsController.fetchRequest.predicate = NSPredicate(format: "( someString contains[cd] %@ )", text!)
    }
    do {
        try self.fetchedResultsController.performFetch()
        self.tableView.reloadData()
    } catch {}
}

¡Eso es todo! Espero que te ayude! Gracias

SWIFT 3.0

Use un campo de texto, UISearchDisplayController está obsoleto a partir de iOS 8, tendría que usar un UISearchController. En lugar de tratar con el Controlador de búsqueda, ¿por qué no crear su propio mecanismo de búsqueda? Puede personalizarlo más y tener más control sobre él, y no tener que preocuparse de que SearchController cambie y/o esté en desuso.

Este método que utilizo funciona muy bien, y no requiere mucho código. Requiere que utilice Datos básicos y sin embargo, implementa NSFetchedResultsController.

Primero, crea un campo de texto y regístralo con un método:

searchTextField?.addTarget(self, action: #selector(textFieldDidChange), for: UIControlEvents.editingChanged)

Luego cree su método textFieldDidChange, descrito en el selector cuando se agregó el destino:

func textFieldDidChange() {
    if let queryString = searchTextField.text {
        filterList(queryString)
        self.tableView.reloadData()
    }
}

Luego desea filtrar la lista en el método filterList() utilizando el predicado NSPredicate o NSCompound si es más complejo. En mi método filterList, estoy filtrando basado en el nombre de la entidad, y el nombre de las entidades "subCategorías" objeto (a uno a muchas relaciones).

func filterList(_ queryString: String) {
    if let currentProjectID = Constants.userDefaults.string(forKey: Constants.CurrentSelectedProjectID) {
        if let currentProject = ProjectDBFacade.getProjectWithID(currentProjectID) {
            if (queryString != ""){
                let categoryPredicate = NSPredicate(format: "name CONTAINS[c] %@ && project == %@", queryString, currentProject)
                let subCategoryPredicate = NSPredicate(format: "subCategories.name CONTAINS[c] %@ && project == %@", queryString, currentProject)
                let orPredicate = NSCompoundPredicate(type: .or, subpredicates: [categoryPredicate, subCategoryPredicate])
                fetchedResultsController.fetchRequest.predicate = orPredicate
            }else{
                fetchedResultsController.fetchRequest.predicate = NSPredicate(format: "project == %@", currentProject)
            }

            do {
                try fetchedResultsController.performFetch()
            } catch {
                print("Error:  Could not fetch fetchedResultsController")
            }
        }
    }
}

Creo que Luka tiene un mejor enfoque para esto. Véase Una gran muestra y su razón

No usa FetchedResultsController, pero usa caché al buscar, por lo tanto, los resultados de búsqueda aparecen mucho más rápido cuando el usuario escribe más en searchBar

He utilizado su enfoque en mi aplicación y funciona bien. También recuerde si desea trabajar con objeto Modelo, hacerlo lo más simple posible, ver mi respuesta acerca de setPropertiesToFetch

Aquí hay una forma de manejar los resultados obtenidos con múltiples conjuntos de datos que es lo suficientemente simple y general como para aplicarse en casi cualquier lugar. Simplemente tome sus resultados principales a una matriz cuando alguna condición está presente.

NSArray *results = [self.fetchedResultsController fetchedObjects];

Consulta la matriz haciendo loop a través de ella o lo que desees para crear un subconjunto de tus resultados principales. Y ahora puede usar el conjunto completo o subconjunto cuando alguna condición está presente.

Realmente me gustó el enfoque de @Josh O'Connor donde no usa un UISearchController. Este controlador todavía (Xcode 9) tiene un error de diseño que muchos están tratando de solucionar.

Volví a usar un UISearchBar en lugar de un UITextField, y funciona bastante bien. Mi requisito para la búsqueda/filtro es producir un NSPredicate. Esto se pasa al FRC:

   class ViewController: UIViewController, UITableViewDelegate, 
 UITableViewDataSource, UISearchBarDelegate {

        @IBOutlet var searchBar: UISearchBar!

         func searchBar(_ searchBar: UISearchBar, textDidChange searchText: String) {

                shouldShowSearchResults = true

                if let queryString = searchBar.text {
                    filterList(queryString)

                    fetchData()
                }
            }



          func filterList(_ queryString: String) {
        if (queryString == "") {
            searchPredicate = nil
    }
        else {
            let brandPredicate = NSPredicate(format: "brand CONTAINS[c] %@", queryString)
            let modelPredicate = NSPredicate(format: "model CONTAINS[c] %@", queryString)
            let orPredicate = NSCompoundPredicate(type: .or, subpredicates: [brandPredicate, modelPredicate])
            searchPredicate = orPredicate
    }

}

...

let context = (UIApplication.shared.delegate as! AppDelegate).persistentContainer.viewContext
        let request = NSFetchRequest<NSFetchRequestResult>(entityName: filmEntity)
        request.returnsDistinctResults = true
        request.propertiesToFetch = ["brand", "model"]

        request.sortDescriptors = [sortDescriptor]
        request.predicate = searchPredicate

Finalmente, conecta la barra de búsqueda a su delegado.

Espero que esto ayude a otros

Enfoque simple para filtrar UITableView existente utilizando CoreData y que ya está ordenado como desee.

Esto literalmente también me 5 minutos para configurar y ponerse a trabajar.

Tenía un UITableView existente usando CoreData poblado con Datos de iCloud y que tiene interacciones de usuario bastante complicadas y no quería tener que replicar todo eso para un UISearchViewController. Pude simplemente agregar un predicado al FetchRequest existente ya utilizado por el FetchResultsController y que filtra el ya datos ordenados.

-(void)searchBar:(UISearchBar *)searchBar textDidChange:(NSString *)searchText
{
    NSPredicate *filterPredicate;

    if(searchText != nil && searchText.length > 0)
        filterPredicate = [NSPredicate predicateWithFormat:@"(someField CONTAINS[cd] %@) OR (someOtherField CONTAINS[cd] %@)", searchText, searchText];
    else
        filterPredicate = nil;

    _fetchedResultsController.fetchRequest.predicate = filterPredicate;

    NSError *error = nil;
    [_fetchedResultsController performFetch:&error];
    [self.tableView reloadData];
}