Affichage des articles dont le libellé est Core Data. Afficher tous les articles
Affichage des articles dont le libellé est Core Data. Afficher tous les articles

dimanche 18 mars 2012

NSExpression

La classe NSExpression relativement nouveau est incroyablement puissant, pourtant pas vraiment utilisé très souvent. Une partie de cela est que ce n'est pas très bien documenté. Bien que la documentation de l'API pour NSExpression est assez bien détaillé, le «guide d'accompagnement" cotées (Introduction à la programmation Prédicats) A très peu d'informations sur la façon d'utiliser effectivement NSExpression.

NSExpression mérite d'être mieux documentés, car elle apporte à la programmation sous-jacente (y compris les données de base), un lot de fonctionnalités de la base de données relationnelle du monde que les gens se plaignent souvent de manque, comme unioning, se croisent, et en soustrayant resultsets et exécuter des opérations globales sans charger géré des objets ou des défauts dans la mémoire.

La fonctionnalité des agrégats est particulièrement important sur iOS donnée la mémoire limité sur la plupart des appareils iOS. Si vous avez un grand ensemble de données, et vous voulez obtenir un comptage d'objets, ou de calculer une moyenne ou la somme pour l'un des attributs, vous ne voulez vraiment pas avoir à tirer l'ensemble des données en mémoire. Même si elles sont tout simplement des défauts, ils vont manger de la mémoire vous n'avez pas besoin d'utiliser parce que le magasin sous SQLite persistante peut figurer ce genre de choses sans la surcharge d'objets.

Je n'ai pas le temps de faire un tutoriel NSExpression complet, mais je pense qu'il vaut au moins poster une catégorie sur NSManagedObject qui vous permet de profiter de certaines de ses fonctionnalités les plus utiles.

Avec cette catégorie, pour obtenir une somme de l'attribut bar sur l'entité Foo, Vous feriez ceci:
NSNumber *fooSum = [Foo aggregateOperation:@"sum:" onAttribute:@"bar" withPredicate:nil inManagedObjectContext:context];



Ce sera le calculer pour vous en utilisant les fonctionnalités de bases de données, et non par le chargement de tous les objets gérés dans la mémoire. Beaucoup plus de mémoire et un processeur efficace que de le faire manuellement.

Cheers. Catégorie suivante:

Fichier d'en-tête:
@interface NSManagedObject(MCAggregate)
+(NSNumber *)aggregateOperation:(NSString *)function onAttribute:(NSString *)attributeName withPredicate:(NSPredicate *)predicate inManagedObjectContext:(NSManagedObjectContext *)context
@end



Fichier Mise en œuvre:
+(NSNumber *)aggregateOperation:(NSString *)function onAttribute:(NSString *)attributeName withPredicate:(NSPredicate *)predicate inManagedObjectContext:(NSManagedObjectContext *)context
{
NSExpression *ex = [NSExpression expressionForFunction:function
arguments:[NSArray arrayWithObject:[NSExpression expressionForKeyPath:attributeName]]
]
;

NSExpressionDescription *ed = [[NSExpressionDescription alloc] init];
[ed setName:@"result"];
[ed setExpression:ex];
[ed setExpressionResultType:NSInteger64AttributeType];

NSArray *properties = [NSArray arrayWithObject:ed];
[ed release];

NSFetchRequest *request = [[NSFetchRequest alloc] init];
[request setPropertiesToFetch:properties];
[request setResultType:NSDictionaryResultType];

if (predicate != nil)
[request setPredicate:predicate];

NSEntityDescription *entity = [NSEntityDescription entityForName:[self className]
inManagedObjectContext:context
]
;
[request setEntity:entity];

NSArray *results = [context executeFetchRequest:request error:nil];
NSDictionary *resultsDictionary = [results objectAtIndex:0];
NSNumber *resultValue = [resultsDictionary objectForKey:@"result"];
return resultValue;

}

@end


samedi 17 mars 2012

Core Data partir de données

Hier, j'ai tweeté pour demander des conseils sur la meilleure façon de fournir un ensemble de départ de données dans une base de données basée sur l'application. Le soft, je travaille sur avaient commencé avec juste un petit ensemble de données de départ, donc la première fois le soft a été exécuté, j'ai simplement tiré dans les données de démarrage à partir d'un fichier plist dans le fond et créé des objets gérés en fonction du contenu et de tous était bon. L'utilisateur ne s'en aperçut et la charge était complète avant ils avaient besoin de faire quelque chose avec les données.

Alors l'ensemble des données a obtenu un peu plus grand et que la solution est devenue trop lente. Alors, j'ai demandé au Twitterverse d'opinions sur la meilleure façon de fournir une grande quantité de données à partir d'une application de données de base. Qu'est-ce que j'espérais trouver était de savoir si vous pourriez inclure un magasin persistant dans votre bundle application et l'utilisation plutôt que de créer de nouveaux magasins persistante la première fois l'application lancée.

La réponse est revenu de beaucoup, beaucoup de personnes que vous pourriez, en effet, la copie d'un magasin existant persistante de votre bundle soft. Vous pouvez même créer le stockage persistant en utilisant un Mac de base de cacao de données d'application aussi longtemps que le fichier utilisé xcdatamodel même que votre application iPhone.

Avant que je continue, je tiens à remercier toutes les personnes qui ont répondu avec des suggestions et des conseils. Un merci spécial à Dan Pasco de la boutique de dev excellente Noir Pixel qui a donné une aide très substantielle. Avec l'aide de la communauté iOS dev, il m'a fallu environ 15 minutes pour que ça marche dans une de mes applications actuelles. Plusieurs personnes ont demandé des détails sur Twitter. 140 caractères ne va pas le couper pour cela, mais voici ce que j'ai fait.

D'abord, j'ai créé un nouveau Mac / Cocoa projet dans Xcode. J'ai utilisé le modèle de cacao demande régulière, en veillant à utiliser des données de base. Plusieurs personnes ont également suggéré que vous pourriez utiliser une application Cocoa document-Based utilisant Core Data qui vous permettrait de sauver le magasin persistant partout que tu voulais. Je crée le projet Xcode dans un sous-répertoire de mon projet principal, et j'ai ajouté le fichier du modèle de données et toutes les classes d'objets gérés à partir de mon projet principal dans le nouveau projet en utilisant des références relatives au projet, en veillant à ne pas copier les fichiers dans le nouveau dossier du projet - je veux utiliser les mêmes fichiers que mon projet originel de sorte que toute modification apportée à celui-ci sont répercutées dans l'autre.

Si mes données de départ était changent fréquemment, je serais probablement faire de ce nouveau projet une dépendance de mon projet principal et ajouter une copie des fichiers construire phase qui va copier le stockage persistant dans le dossier du projet principal de ressources, mais mes données ne change pas très souvent, donc je suis juste de le faire manuellement. On peut certainement automatiser la tâche au sein de Xcode, et j'ai entendu de plusieurs personnes qui l'ont fait.

Dans le projet de nouvelle cacao, la première chose à faire est de modifier la méthode persistentStoreCoordinator du délégué app pour qu'il utilise un magasin persistant avec le même nom que votre application iOS. Ceci est la ligne de code dont vous avez besoin de modifier:

NSURL *url = [NSURL fileURLWithPath: [applicationSupportDirectory stringByAppendingPathComponent: @"My_App_Name.sqlite"]];


Assurez-vous d'ajouter l'extension. Sqlite au nom de fichier. Par défaut, le modèle d'application Cocoa utilise un magasin de données XML et aucune extension de fichier. Le nom du fichier que vous indiquez ici est utilisée exactement, donc si vous voulez une extension de fichier, vous devez le spécifier.

Depuis défaut de cacao du projet d'application d'un magasin basé sur XML persistants, vous devez également modifier le type de magasin de l'App cacao à SQLite. C'est quelques lignes plus tard. Cherchez cette ligne:

if (![persistentStoreCoordinator addPersistentStoreWithType:NSXMLStoreType 
configuration:nil
URL:url
options:nil
error:&error
]
){


Changement d'NSXMLStoreType NSSQLiteStoreType.

En option, vous pouvez aussi changer la méthode applicationSupportDirectory de revenir un autre endroit si vous voulez rendre le stockage persistant plus facile à trouver. Par défaut, il va aller dans les
~/Library/Application Support/[Cocoa App Name]/
qui peut être un peu un glisser pour naviguer.

Ensuite, vous devez faire vos importer des données. Ce code sera intrinsèquement spécifiques à l'application et dépendra de votre modèle de données et les données dont vous avez besoin d'importer. Voici un simple pseudo-méthode pour analyser un fichier texte délimité par des tabulations pour donner une idée à quoi cela pourrait ressembler. Cette méthode crée une NSAutoreleasePool et un contexte pour qu'il puisse être lancé dans un thread si vous le désirez. Vous pouvez également l'appeler directement - il ne dérange en rien.


- (void)loadInitialData
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSManagedObjectContext *context = [[NSManagedObjectContext alloc] init];
[context setPersistentStoreCoordinator:self.persistentStoreCoordinator];


NSString *path = [[NSBundle mainBundle] pathForResource:@"foo" ofType:@"txt"];

char buffer[1000];
FILE* file = fopen([path UTF8String], "r");

while(fgets(buffer, 1000, file) != NULL)
{
NSString* string = [[NSString alloc] initWithUTF8String:buffer];
NSArray *parts = [string componentsSeparatedByString:@"\t"]

MyManagedObjectClass *oneObject = [self methodToCreateObjectFromArray:parts];
[string release];
}

NSLog(@"Done initial load");
fclose(file);
NSError *error;
if (![context save:&error])
NSLog(@"Error saving: %@", error);

[context release];
[pool drain];
}


Vous pouvez ajouter le applicationDidFinishLaunching méthode déléguée: à votre délégué app et de mettre votre code là. Vous n'avez même pas vraiment besoin de vous soucier de combien de temps cela prend - il n'ya pas de processus de surveillance sur le Mac qui tue votre application si elle ne répond pas à des événements après une période de temps. Si vous préférez, vous pouvez avoir votre fonctionnalité d'importation des données de travail dans le fond, bien que depuis l'app ne fait rien d'autre, il n'y a aucun avantage réel, sauf le fait que c'est la «bonne» façon de coder une application.

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification
{
// Do import or launch threads to do import

// So, do this:
[self loadInitialData];

// or this:

[self performSelectorInBackground:@selector(loadInitialData) withObject:nil];

// But not both for the same method probably
}


Maintenant, lancez votre application. Quand c'est fait, l'importation, vous pouvez simplement copier le fichier de stockage persistant dans le projet de votre iOS app Xcode dans le groupe des ressources. Lorsque vous créez votre appli, ce fichier sera automatiquement copié dans votre application bundle. Maintenant, vous avez juste besoin de modifier le délégué app de votre application iOS d'utiliser ce magasin persistante au lieu de créer un nouveau magasin vide persistante la première fois l'application est exécutée.

Pour ce faire, il vous suffit de vérifier l'existence du magasin persistant dans le dossier de votre application / documents, et si elle n'y est pas, vous le copiez le paquet d'application dans le dossier de l'/ Documents avant de créer le magasin persistant. Dans le délégué app, la méthode persistentStoreCoordinator devrait ressembler à ceci:

- (NSPersistentStoreCoordinator *)persistentStoreCoordinator 
{
@synchronized (self)
{
if (persistentStoreCoordinator != nil)
return persistentStoreCoordinator;

NSString *defaultStorePath = [[NSBundle bundleForClass:[self class]] pathForResource:@"My_App_Name" ofType:@"sqlite"];
NSString *storePath = [[self applicationDocumentsDirectory] stringByAppendingPathComponent: @"My_App_Name.sqlite"];

NSError *error;
if (![[NSFileManager defaultManager] fileExistsAtPath:storePath])
{
if ([[NSFileManager defaultManager] copyItemAtPath:defaultStorePath toPath:storePath error:&error])
NSLog(@"Copied starting data to %@", storePath);
else
NSLog(@"Error copying default DB to %@ (%@)", storePath, error);
}


NSURL *storeURL = [NSURL fileURLWithPath:storePath];

persistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:[self managedObjectModel]];

NSDictionary *options = [NSDictionary dictionaryWithObjectsAndKeys:
[NSNumber numberWithBool:YES], NSMigratePersistentStoresAutomaticallyOption,
[NSNumber numberWithBool:YES], NSInferMappingModelAutomaticallyOption, nil
]
;

if (![persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:options error:&error])
{

NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
abort();
}


return persistentStoreCoordinator;
}

}


Et `Voil a! Si vous exécutez l'application pour la première fois sur un périphérique, ou de l'exécuter sur le simulateur après la réinitialisation de contenu et les paramètres, vous devriez commencer avec les données qui ont été chargées dans votre application Cocoa.

Core Data Odds and Ends

J'ai fait un peu juste de travailler avec Core Data dernièrement, et ont ramassé quelques trucs pour rendre ma vie plus facile, alors j'ai pensé que je partagerais.

Mo 'alimentation


Retour dans le EOF jours, il y avait un grand morceau peu de logiciels tiers appelé EOGenerator que quelque chose appelé la mise en œuvre design pattern fossé des générations. Essentiellement, ce petit programme serait de créer vos classes personnalisées des EOGenericRecord (équivalent EOF de NSManagedObject) pour vous. Il ne serait pas juste de créer cela, cependant, il serait en fait créer deux classes pour chaque entité dans votre EOModel.

Un de ces deux classes a été le vôtre pour modifier comme bon vous semblait. Il ne serait jamais écrasé, même si vous avez exécuté le script EOGenerator encore, encore et encore. L'autre classe contient tout le code généré dérivé à partir de votre EOModel et a été conçu pour ne pas être touché par le programmeur. Vous avez eu votre classe, EOGenerator avait sa catégorie, et vous pourriez aussi bien le travail sans crainte de marcher sur les pieds. Vous pouvez ajouter des attributs et des entités de votre modèle de données et régénérer les classes lisibles à la machine sans aucune chance de perdre votre validation personnalisée ou de méthodes. Elle était belle.

Loup Rentzsch a réimplémenté cette idée pour Core Data, et le résultat est appelé MOGenerator. Si vous passez du temps avec les données de base et ne sont pas familiers avec MOGenerator, allez vous familiariser avec elle. Il vous rendra la vie beaucoup, beaucoup, beaucoup mieux.

SQLite pour vérifier les données


Le type de stockage par défaut persistant pour Core Data sous iOS est un magasin de SQLite, ce qui signifie que les données de base conserve l'ensemble de ses données à l'intérieur d'une seule base de données SQLite dans le dossier de votre application / Documents. Maintenant, le format du magasin persistant est sans papiers et vous ne devriez jamais, jamais, jamais, jamais, ne jamais changer les données dans le magasin persistant ou faire de suppositions sur la façon dont les données de base stocke les données. Cela fait partie des raisons pour lesquelles nous utilisons les données de base: Il s'agit d'une couche d'abstraction qui nous permet de ne pas se soucier des détails de stockage sous-jacent.

Mais, parfois, il peut être vraiment utile de savoir si des données est d'entrer dans le magasin persistant ou non. Je travaille souvent sur mon modèle de données avant que mon interface utilisateur, afin d'être en mesure de jeter un regard dans le magasin de données pour s'assurer que tout est bien, c'est vraiment utile.

La première chose que vous pourriez envisager de le faire, si vous prévoyez de le faire, est de créer un fichier config SQLite. Ceci est un fichier de commandes qui va exécuter chaque fois que vous lancez SQLite. Pour ce faire, il suffit de créer un fichier appelé .sqliterc dans votre répertoire home. Voici ce que la mine ressemble à:
.mode column
.header on
.table
Dans la mine, la première ligne indique SQLite pour imprimer les noms des colonnes quand je émettre une commande SELECT. La deuxième ligne indique SQLite pour présenter les données sous forme tabulaire. La dernière ligne affiche une liste de toutes les tables dans la base de données avant qu'il me montre la commande SQL rapide. C'est pratique, étant donné que les noms de table ne sont généralement pas correspondre exactement à votre entité ou les noms de classe.

Une fois que vous avez un fichier de configuration en place, vous pouvez ouvrir n'importe quel magasin persistante en utilisant la commande sqlite3 dans Terminal.app, comme ceci:
sqlite3 MyApplication.sqlite
Vous ne pouvez pas, bien sûr, exécuter cette base de données des fichiers directement contre sur votre téléphone, mais vous pouvez le faire dans le simulateur ainsi que sur les fichiers copiés à partir de votre téléphone en utilisant Xcode Organizer. Si vous utilisez le simulateur, vous pouvez rechercher vos bases de données SQLite à l'emplacement suivant:
/Users/[your account name]/Library/Application Support/iPhone Simulator/[SDK version #]/Applications/[application UUID]/Documents/[Application Name].sqlite


Lorsque je me connecte à une base de données avec mon fichier de config SQLite, c'est ce que je vois:
-- Loading resources from /Users/jeff/.sqliterc
ZHERO ZPOWER Z_METADATA Z_PRIMARYKEY
SQLite version 3.6.12
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>
Remarquez qu'il a jeté les noms de tous mes tableaux. Il est assez facile de trouver la table qui contient les données une fois qu'ils sont juste en face de vous. L'exemple ci-dessus est le stockage persistant de l'application du SuperDB Plus l'iPhone 3 de développement. L' Hero objets d'entité gérés sont stockés dans Zhero et les objets d'entité Puissance gérés sont stockés dans ZPOWER. Pour regarder le contenu d'une table, il vous suffit d'exécuter une commande SQL SELECT. Le plus simple est juste SELECT * FROM TABLENAME;, qui imprime le contenu entier de la table à la console, comme ceci:
sqlite> select * from ZPOWER;
Z_PK Z_ENT Z_OPT ZHERO ZSOURCE ZNAME
---------- ---------- ---------- ---------- ---------- ----------
1 2 2 1 Mutation Fire
sqlite>
Le format des données est assez facile à comprendre, mais là encore, vous devriez vraiment regarder et ne pas toucher. Ce serait très facile de détruire accidentellement un magasin persistant. Un changement pourrait apparemment sans obtenir les métadonnées détraqué et empêcher votre application d'utiliser le stockage persistant plus.

Mieux Descrption


J'ai remarqué il ya quelques jours que les Wil Shipley se plaignait du fait que beaucoup de UIKit livré Apple et objets de la Fondation n'ont pas annulé la description-méthode. Cette méthode est importante car c'est celle qui est utilisée dans les chaînes de format, NSLog (), et quand vous tapez la commande postale dans GDB. Au lieu d'obtenir une description significative de nombreux objets livrés, vous obtenez à la place du nom de classe et l'adresse mémoire de l'instance, ce qui est mise en œuvre NSObject offre, qui n'est pas très grande aide pendant le débogage.

Malheureusement, NSManagedObject est l'un des nombreux, de nombreuses classes qui ne possède pas sa propre implémentation significative de-description. Cela ne signifie pas que vous ne pouvez pas fournir un, cependant.

Une chose que vous pouvez faire est de créer une sous-classe abstraite de NSManagedObject et de mettre la description-il la méthode. Ensuite, si vous sous-classe de cette classe abstraite, tous vos objets gérés héritent de la méthode de la classe abstraite. Si j'ai d'autres fonctionnalités communes, je vais souvent faire exactement cela. Mais si je n'ai pas (et souvent vous ne serez pas) Personnellement, je déteste d'encombrer ma hiérarchie d'objets à ajouter des outils de débogage. Alors j'ai fait va tricher et faire quelque chose que vous n'êtes pas vraiment censé faire, ce qui est remplacer une méthode utilisant une catégorie. La raison c'est mauvais de faire cela parce que le langage Objective-C ne précise pas quelle méthode doit être utilisée, ce qui peut conduire à un comportement imprévisible. Mais, quand une classe hérite d'une méthode d'une superclasse, j'ai trouvé que c'est primordial dans une catégorie fonctionne toujours. Je ne suggère pas que vous devriez faire cela dans une application d'expédition, cependant. J'ai ma méthode envelopper dans le pré-compilateur définitions afin qu'il ne soit pas compilé dans la version de mon application.

Ma version de-description suppose que vous générez des propriétés de vos objets gérés (je fais toujours) et suppose également que vous utilisez les sous-classes personnalisées (mais vous êtes, parce que vous utilisez MOGenerator, Non??). La méthode itère sur toutes les propriétés de la classe et toutes ses super à NSManagedObject, puis les imprime sur la console. Les catégories que j'utilise ressemble à ceci:
#if DEBUG
@implementation NSObject(MCManagedObjectDebug)
+ (NSMutableArray *)MCproperties
{
NSMutableArray *properties = nil;

if ([self superclass] != [NSManagedObject class])
properties = [[self superclass] MCproperties];
else
properties = [NSMutableArray array];


unsigned int propCount;
objc_property_t * propList = class_copyPropertyList([self class], &propCount);
int i;

for (i=0; i < propCount; i++)
{
objc_property_t oneProp = propList[i];
NSString *propName = [NSString stringWithUTF8String:property_getName(oneProp)];
if (![properties containsObject:propName])
[properties addObject:propName];
}

return properties;
}

@end


@implementation NSManagedObject(MCManagedObjectDebug)
- (NSString *)description
{
NSArray *properties = [[self class] MCproperties];
NSMutableString *ret = [NSMutableString stringWithFormat:@"%@:", [self className]];
NSDictionary *myAttributes = [[self entity] attributesByName];

for (NSString *oneProperty in properties)
{
NSAttributeDescription *oneAttribute = [myAttributes valueForKey:oneProperty];
if (oneAttribute != nil) // If not, it's a relationship or fetched property
{
id value = [self valueForKey:oneProperty];
[ret appendFormat:@"\n\t%@ = %@", oneProperty, value];
}


}

return ret;
}


@end
#endif
La méthode MCProperties + utilise le runtime Objective-C à découvrir et à itérer sur les propriétés dans la définition de la classe, y compris les propriétés dynamiques @ qui ont été créés à l'exécution. Parce que les appels d'exécution bien ne comprennent pas les propriétés héritées de classes parentes, la méthode agit de façon récursive, itérer jusqu'à la hiérarchie des objets jusqu'à ce qu'il arrive à NSManagedObject. La méthode de description réelle-affiche simplement chacun des attributs et la valeur actuellement stockée pour cet attribut pour cette instance de l'objet. Une fois que vous faites cela, si vous utilisez NSLog () ou postale, le résultat est beaucoup plus riche d'informations sur les objets se imprimé sur la console. Cette version ne tient pas compte des relations et des propriétés récupérées, mais il ne serait pas difficile d'ajouter ceux si vous besoin d'eux.

lundi 12 mars 2012

Core Data Encryption

On m'a demandé un certain nombre de fois sur la meilleure façon de crypter un magasin de données de base persistante. Les réponses que j'ai eu à donner ont toujours été un peu kludgey au mieux. Apparemment, avec iOS 4, il ya une meilleure réponse, Et j'ai été complètement inconscients de ce changement. Si vous stockez n'importe quoi à distance sécurisé au Core Data, ça vaut quelques minutes de votre temps pour lire le message de Nick Harris.

par l'intermédiaire de Brent Simmons ranchero.com

Core Data et du threading

J'ai eu un certain nombre de gens me demandent ces derniers temps sur la meilleure façon de gérer l'aide des données de base dans une application multi-thread. J'ai commencé à mettre sur pied un didacticiel et des exemples de code basé sur Apple documentation, Qui conseille de passer entre les filets NSManagedObjectIDs pour contourner le fait que les discussions ne peuvent pas partager des instances de NSManagedObjectContext ou NSManagedObject. J'ai utilisé cette approche dans plusieurs projets et cela fonctionne.

Alors que googler autour d'effectuer des recherches, cependant, je suis tombé sur un post by Marcus Zarra sur le Mac Developer Network.

Marcus sait Core Data vraiment bien, après avoir écrit un livre sur le sujet, Alors j'ai pensé que j'avais jeter un oeil à ce que Marcus avait à dire sur la question. Je suis content que j'ai fait. Marcus illustre une approche vraiment grand à son poste qui évite la nécessité de passer ManagedObjectIDs autour entre le fil dans de nombreuses situations. Vous avez encore besoin de faire cela si vous avez besoin pour passer un objet spécifique entre les threads, mais si vous faites quelque chose comme le chargement ou la création d'objets gérés dans le fond pour être affichées dans un tableau, c'est tellement plus facile et mieux.

Je ne vais pas gâcher la surprise, mais c'est un outil pratique pour votre trousse à outils de base de données. Si vous avez pensé à utiliser des données de base dans une application multi-thread, vous devriez certainement le vérifier.

jeudi 8 mars 2012

Chapitre 4 et le conte de la NSFetchedResultsController

Bon, certaines personnes ont eu des problèmes sporadiques avec le chapitre 4 application comme décrit ici. La solution que je voudrais utiliser, il faudrait être capable de déterminer le nombre de cours, des encarts et supprime la section non engagés qui a une vue de table. Bien que je peux obtenir cette information, je ne peux le faire en accédant à une variable d'instance privée de UITableView. Évidemment, je ne veux pas vous donner tous une solution qui va devenir votre application rejetés au cours du processus d'examen.

Donc, je suis retourné à la planche à dessin. Je n'aime pas cette solution comme beaucoup depuis qu'il nous oblige à reproduire le travail que la vue de table est déjà fait en gardant un décompte ombre d'insertions et des suppressions, mais il semble bien fonctionner et ne pas ajouter trop de complexité. J'ai maintenant un cas de test assez approfondie pour l'insertion et la suppression de lignes dans une table qui utilise une NSFetchedResultsController et cette solution passe, alors croisons les doigts.

La solution


La première étape est d'ajouter une des variables d'instance privées @ NSUInteger à la classe contrôleur qui gère la table et alla chercher le contrôleur résultats. Cela permet de garder un compte courant du nombre de sections insérées et supprimées lors d'une lot de mises à jour de table.

Dans le contexte de l'application de chapitre 4, ce qui signifie en ajoutant la ligne suivante en gras du code HeroListViewController.h:

#import <UIKit/UIKit.h>

#define kSelectedTabDefaultsKey @"Selected Tab"
enum {
kByName = 0,
kBySecretIdentity,
}
;
@class HeroEditController;
@interface HeroListViewController : UIViewController <UITableViewDelegate, UITableViewDataSource, UITabBarDelegate, UIAlertViewDelegate, NSFetchedResultsControllerDelegate>{

UITableView *tableView;
UITabBar *tabBar;
HeroEditController *detailController;

@private
NSFetchedResultsController *_fetchedResultsController;
NSUInteger sectionInsertCount;
}

@property (nonatomic, retain) IBOutlet UITableView *tableView;
@property (nonatomic, retain) IBOutlet UITabBar *tabBar;
@property (nonatomic, retain) IBOutlet HeroEditController *detailController;
@property (nonatomic, readonly) NSFetchedResultsController *fetchedResultsController;
- (void)addHero;
- (IBAction)toggleEdit;
@end



Maintenant, nous devons passer à la mise en œuvre du fichier, HeroListViewController.m et ajouter une ligne de code pour réinitialiser le compteur d'insérer quand nous serons avisés par le contrôleur chercher des résultats que des changements sont à venir. Pour ce faire, nous ajoutons une ligne de code à l'controllerWillChangeContent méthode:, comme ceci:

- (void)controllerWillChangeContent:(NSFetchedResultsController *)controller {
sectionInsertCount = 0;
[self.tableView beginUpdates];
}

Ensuite, nous avons pour incrémenter cette variable lorsque nous insérer une section, et il décrémente chaque fois que nous supprimer une section dans le contrôleur: didChangeSection: atIndex: forChangeType:. Nous faisons cela en ajoutant le code en gras ci-dessous:

- (void)controller:(NSFetchedResultsController *)controller didChangeSection:(id <NSFetchedResultsSectionInfo>)sectionInfo atIndex:(NSUInteger)sectionIndex forChangeType:(NSFetchedResultsChangeType)type {
switch(type) {

case NSFetchedResultsChangeInsert:
if (!((sectionIndex == 0) && ([self.tableView numberOfSections] == 1))) {
[self.tableView insertSections:[NSIndexSet indexSetWithIndex:sectionIndex] withRowAnimation:UITableViewRowAnimationFade];
sectionInsertCount++;
}


break;
case NSFetchedResultsChangeDelete:
if (!((sectionIndex == 0) && ([self.tableView numberOfSections] == 1) )) {
[self.tableView deleteSections:[NSIndexSet indexSetWithIndex:sectionIndex] withRowAnimation:UITableViewRowAnimationFade];
sectionInsertCount--;
}


break;
case NSFetchedResultsChangeMove:
break;
case NSFetchedResultsChangeUpdate:
break;
default:
break;
}

}

Enfin, chaque fois que nous faisons notre vérification de la cohérence dans le contrôleur: didChangeObject: atIndexPath: forChangeType: newIndexPath: nous avons à prendre les inserts en attente et supprime en compte. Puisque nous ne l'cocher plus d'une fois et insérez de nouvelles sections lorsque la vérification échoue, nous avons également incrémenter la variable si nous ne nous insérer de nouvelles lignes. Nous faisons tout cela en ajoutant le code ci-dessous en gras dans cette méthode:

- (void)controller:(NSFetchedResultsController *)controller didChangeObject:(id)anObject atIndexPath:(NSIndexPath *)indexPath forChangeType:(NSFetchedResultsChangeType)type newIndexPath:(NSIndexPath *)newIndexPath {
switch(type) {
case NSFetchedResultsChangeInsert:
[self.tableView insertRowsAtIndexPaths:[NSArray arrayWithObject:newIndexPath] withRowAnimation:UITableViewRowAnimationFade];
break;
case NSFetchedResultsChangeDelete:
[self.tableView deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath] withRowAnimation:UITableViewRowAnimationFade];
break;
case NSFetchedResultsChangeUpdate: {
NSString *sectionKeyPath = [controller sectionNameKeyPath];
if (sectionKeyPath == nil)
break;
NSManagedObject *changedObject = [controller objectAtIndexPath:indexPath];
NSArray *keyParts = [sectionKeyPath componentsSeparatedByString:@"."];
id currentKeyValue = [changedObject valueForKeyPath:sectionKeyPath];
for (int i = 0; i < [keyParts count] - 1; i++) {
NSString *onePart = [keyParts objectAtIndex:i];
changedObject = [changedObject valueForKey:onePart];
}

sectionKeyPath = [keyParts lastObject];
NSDictionary *committedValues = [changedObject committedValuesForKeys:nil];

if ([[committedValues valueForKeyPath:sectionKeyPath] isEqual:currentKeyValue])
break;

NSUInteger tableSectionCount = [self.tableView numberOfSections];
NSUInteger frcSectionCount = [[controller sections] count];
if (tableSectionCount + sectionInsertCount != frcSectionCount) {
// Need to insert a section
NSArray *sections = controller.sections;
NSInteger newSectionLocation = -1;
for (id oneSection in sections) {
NSString *sectionName = [oneSection name];
if ([currentKeyValue isEqual:sectionName]) {
newSectionLocation = [sections indexOfObject:oneSection];
break;
}

}

if (newSectionLocation == -1)
return; // uh oh

if (!((newSectionLocation == 0) && (tableSectionCount == 1) && ([self.tableView numberOfRowsInSection:0] == 0))) {
[self.tableView insertSections:[NSIndexSet indexSetWithIndex:newSectionLocation] withRowAnimation:UITableViewRowAnimationFade];
sectionInsertCount++;
}


NSUInteger indices[2] = {newSectionLocation, 0};
newIndexPath = [[[NSIndexPath alloc] initWithIndexes:indices length:2] autorelease];
}

}

case NSFetchedResultsChangeMove:
if (newIndexPath != nil) {

NSUInteger tableSectionCount = [self.tableView numberOfSections];
NSUInteger frcSectionCount = [[controller sections] count];
if (frcSectionCount != tableSectionCount + sectionInsertCount) {
[self.tableView insertSections:[NSIndexSet indexSetWithIndex:[newIndexPath section]] withRowAnimation:UITableViewRowAnimationNone];
sectionInsertCount++;
}



[self.tableView deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath] withRowAnimation:UITableViewRowAnimationFade];
[self.tableView insertRowsAtIndexPaths: [NSArray arrayWithObject:newIndexPath]
withRowAnimation: UITableViewRowAnimationRight
]
;

}

else {
[self.tableView reloadSections:[NSIndexSet indexSetWithIndex:[indexPath section]] withRowAnimation:UITableViewRowAnimationFade];
}

break;
default:
break;
}

}


Je vais pousser ce nouveau code dans l'archive du projet dès que possible et obtenir qu'il affichés apress.com et iphonedevbook.com, mais voici la version actualisée du projet de chapitre 4 Xcode dans l'intervalle.

Ne vous inquiétez pas si vous ne comprenez pas tout ce qui se passe dans ce code. Ceci est du code conçu pour être méchant complètement générique de sorte que vous n'avez pas à vous soucier du tout. Espérons que ce sera la fin de nos ennuis avec NSFetchedResultsController.

Navigation basée sur Application Template Core Data Republiée

Basé sur la rétroaction d'une tôt après, J'ai été capable de fixer un autre bug dans ma version de Apple basés sur la navigation de base Application Data Xcode modèle. C'était une erreur off-by-celle causée par l'aide d'un> = quand j'aurais dû utiliser juste un>.

Nouvelle version de méthodes déléguées suivent:

- (void)controllerWillChangeContent:(NSFetchedResultsController *)controller {
[self.tableView beginUpdates];
}

- (void)controllerDidChangeContent:(NSFetchedResultsController *)controller {
[self.tableView endUpdates];
}

- (void)controller:(NSFetchedResultsController *)controller didChangeObject:(id)anObject atIndexPath:(NSIndexPath *)indexPath forChangeType:(NSFetchedResultsChangeType)type newIndexPath:(NSIndexPath *)newIndexPath {
switch(type) {
case NSFetchedResultsChangeInsert:
[self.tableView insertRowsAtIndexPaths:[NSArray arrayWithObject:newIndexPath] withRowAnimation:UITableViewRowAnimationFade];
break;
case NSFetchedResultsChangeDelete:
[self.tableView deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath] withRowAnimation:UITableViewRowAnimationFade];
break;
case NSFetchedResultsChangeUpdate: {
NSString *sectionKeyPath = [controller sectionNameKeyPath];
if (sectionKeyPath == nil)
break;
NSManagedObject *changedObject = [controller objectAtIndexPath:indexPath];
NSArray *keyParts = [sectionKeyPath componentsSeparatedByString:@"."];
id currentKeyValue = [changedObject valueForKeyPath:sectionKeyPath];
for (int i = 0; i < [keyParts count] - 1; i++) {
NSString *onePart = [keyParts objectAtIndex:i];
changedObject = [changedObject valueForKey:onePart];
}

sectionKeyPath = [keyParts lastObject];
NSDictionary *committedValues = [changedObject committedValuesForKeys:nil];

if ([[committedValues valueForKeyPath:sectionKeyPath] isEqual:currentKeyValue])
break;

NSUInteger tableSectionCount = [self.tableView numberOfSections];
NSUInteger frcSectionCount = [[controller sections] count];
if (tableSectionCount != frcSectionCount) {
// Need to insert a section
NSArray *sections = controller.sections;
NSInteger newSectionLocation = -1;
for (id oneSection in sections) {
NSString *sectionName = [oneSection name];
if ([currentKeyValue isEqual:sectionName]) {
newSectionLocation = [sections indexOfObject:oneSection];
break;
}

}

if (newSectionLocation == -1)
return; // uh oh

if (!((newSectionLocation == 0) && (tableSectionCount == 1) && ([self.tableView numberOfRowsInSection:0] == 0)))
[self.tableView insertSections:[NSIndexSet indexSetWithIndex:newSectionLocation] withRowAnimation:UITableViewRowAnimationFade];
NSUInteger indices[2] = {newSectionLocation, 0};
newIndexPath = [[[NSIndexPath alloc] initWithIndexes:indices length:2] autorelease];
}

}

case NSFetchedResultsChangeMove:
if (newIndexPath != nil) {

NSUInteger tableSectionCount = [self.tableView numberOfSections];
NSUInteger frcSectionCount = [[controller sections] count];
if (frcSectionCount > tableSectionCount)
[self.tableView insertSections:[NSIndexSet indexSetWithIndex:[newIndexPath section]] withRowAnimation:UITableViewRowAnimationNone];
else if (frcSectionCount < tableSectionCount && tableSectionCount > 1)
[self.tableView deleteSections:[NSIndexSet indexSetWithIndex:[indexPath section]] withRowAnimation:UITableViewRowAnimationNone];


[self.tableView deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath] withRowAnimation:UITableViewRowAnimationFade];
[self.tableView insertRowsAtIndexPaths: [NSArray arrayWithObject:newIndexPath]
withRowAnimation: UITableViewRowAnimationRight
]
;

}

else {
[self.tableView reloadSections:[NSIndexSet indexSetWithIndex:[indexPath section]] withRowAnimation:UITableViewRowAnimationFade];
}

break;
default:
break;
}

}

- (void)controller:(NSFetchedResultsController *)controller didChangeSection:(id <NSFetchedResultsSectionInfo>)sectionInfo atIndex:(NSUInteger)sectionIndex forChangeType:(NSFetchedResultsChangeType)type {
switch(type) {

case NSFetchedResultsChangeInsert:
if (!((sectionIndex == 0) && ([self.tableView numberOfSections] == 1)))
[self.tableView insertSections:[NSIndexSet indexSetWithIndex:sectionIndex] withRowAnimation:UITableViewRowAnimationFade];
break;
case NSFetchedResultsChangeDelete:
if (!((sectionIndex == 0) && ([self.tableView numberOfSections] == 1) ))
[self.tableView deleteSections:[NSIndexSet indexSetWithIndex:sectionIndex] withRowAnimation:UITableViewRowAnimationFade];
break;
case NSFetchedResultsChangeMove:
break;
case NSFetchedResultsChangeUpdate:
break;
default:
break;
}

}


SuperDB Core Data App avec les sections

Si vous avez obtenu grâce les premiers chapitres de la Plus l'iPhone 3 de développement, Vous pourriez vous demander pourquoi nous avons inclus un sectionNameKeyPath quand on n'a pas réellement diviser la table en sections. Quel est le point d'avoir récupéré le contrôleur résultats, utiliser des sections si elles ne sont pas affichées?

La vérité de l'affaire, c'est que nous avions initialement prévu de prendre l'application SuperDB plus loin que nous avons pu. Malheureusement, nous avons atteint un point où nous avons dû le couper et passer à d'autres sujets dans l'ordre à la fois à répondre à nos délais et à venir dans à un nombre de pages raisonnable (comme il était, nous sommes venus en 250 pages sur ce que nous contractés pour ). Bon, nous n'avons pas vraiment répondre à nos échéances, mais nous aurions manqué de plus.

Dave et moi avons convenu d'arrêter de travailler sur les données fondamentales pour obtenir le livre fait et laisser de la place pour les autres sujets, mais nous a laissé ouverte la possibilité d'étendre l'application davantage ici dans mon blog. Afin d'être capable de faire cela, nous avons laissé dans quelques vestiges du plan original pour le rendre plus facile d'étendre l'application ici.

Voici la première extension, qui est d'ajouter des sections à la table alphabétique, comme ceci:

Screen shot 2009-12-29 at 5.14.44 PM.png


Continuons à partir du code dans le 07 - SuperDB du projet. Vous pouvez télécharger la version révisée du here. Faire une nouvelle copie de celui-ci si vous le souhaitez. La première chose que nous devons faire est d'ajouter une méthode déléguée tableview qui renvoie le titre qui sera affiché dans chaque section. Pour ce faire, ajoutez le code suivant à la HeroListViewController.m, Près d'autres méthodes de tableau:

- (NSString *)tableView:(UITableView *)tableView 
titleForHeaderInSection:(NSInteger)section {

if (!(section == 0 && [self.tableView numberOfSections] == 1)) {
id <NSFetchedResultsSectionInfo> sectionInfo =
[[self.fetchedResultsController sections] objectAtIndex:section];
return [sectionInfo name];
}

return nil;
}

C'est une méthode très générique qui va utiliser les valeurs du contrôleur chercher les résultats. Cette méthode devient essentiellement un petit copier-coller de code que vous pouvez utiliser n'importe quel contrôleur inchangée en qui utilise un contrôleur chercher les résultats avec les sections.

Si vous exécutez votre application maintenant, cependant, vous allez obtenir une section distincte pour chaque ligne (il serait également crash, mais nous nous en occuperons aussi bien). Dans la version que vous avez maintenant, nous avons spécifié le nom ou secretIdentity que notre sectionNameKeyPath, de sorte que chaque nom unique ou de l'identité secrète devient sa propre section. En règle générale, pas ce que veux. Alors, la prochaine étape est d'ajouter de méthode d'accès virtuel à notre objet Héros de retourner la valeur que nous voulons utiliser à utiliser pour diviser la liste des héros en place. Faisons-le par ordre alphabétique, ce qui signifie que nous avons besoin pour créer des méthodes pour retourner la première lettre du nom et de l'identité secrète. Nous pouvons ensuite utiliser ces nouvelles méthodes accesseur virtuel comme nos chemins section nom de la clé, et le contrôleur de chercher les résultats seront divisons la liste par la première lettre.

In Hero.h, Ajoutez les deux déclarations de méthode, juste avant le mot-clé end @:

- (NSString *)nameFirstLetter;
- (NSString *)secretIdentityFirstLetter;

Save Hero.h et de passer à Hero.mEt insérez la mise en œuvre de ces deux méthodes, au-dessus du mot-clé end @ encore:

- (NSString *)nameFirstLetter {
return [self.name substringToIndex:1];
}

- (NSString *)secretIdentityFirstLetter {
return [self.secretIdentity substringToIndex:1];
}

Save Hero.m. Ensuite, nous devons faire quelques changements dans HeroListViewController.m. Tout d'abord, changement d'affectation de sectionKey pour refléter notre nouvelle méthodes d'accès virtuel. Recherchez le code suivant dans la méthode fetchedResultsController et modifiez les lignes en gras pour passer de l'aide au nom et secretIdentity utilisant notre nouvelle première lettre de méthodes:

...
case kByName: {
NSSortDescriptor *sortDescriptor1 = [[NSSortDescriptor alloc] initWithKey:@"name" ascending:YES];
NSSortDescriptor *sortDescriptor2 = [[NSSortDescriptor alloc] initWithKey:@"secretIdentity" ascending:YES];
NSArray *sortDescriptors = [[NSArray alloc] initWithObjects:sortDescriptor1, sortDescriptor2, nil];
[fetchRequest setSortDescriptors:sortDescriptors];
[sortDescriptor1 release];
[sortDescriptor2 release];
[sortDescriptors release];
sectionKey = @"nameFirstLetter";
break;
}

case kBySecretIdentity:{
NSSortDescriptor *sortDescriptor1 = [[NSSortDescriptor alloc] initWithKey:@"secretIdentity" ascending:YES];
NSSortDescriptor *sortDescriptor2 = [[NSSortDescriptor alloc] initWithKey:@"name" ascending:YES];
NSArray *sortDescriptors = [[NSArray alloc] initWithObjects:sortDescriptor1, sortDescriptor2, nil];
[fetchRequest setSortDescriptors:sortDescriptors];
[sortDescriptor1 release];
[sortDescriptor2 release];
[sortDescriptors release];
sectionKey = @"secretIdentityFirstLetter";
break;
}

...


C'est essentiellement cela. Eh bien, non vraiment. Dans les tests, j'ai trouvé qu'il s'est crashé. Pour cette nouvelle version, nous avons besoin de modifier les méthodes de chercher des résultats déléguée contrôleur qui nous vous avons donnés au chapitre 2. Remplacez vos implémentations existantes du contrôleur: didChangeSection: atIndex: forChangeType: et le contrôleur: didChangeObject: atIndexPath: forChangeType: newIndexPath: avec les versions suivantes de nouvelles:

- (void)controller:(NSFetchedResultsController *)controller didChangeObject:(id)anObject atIndexPath:(NSIndexPath *)indexPath forChangeType:(NSFetchedResultsChangeType)type newIndexPath:(NSIndexPath *)newIndexPath {
switch(type) {
case NSFetchedResultsChangeInsert:
[self.tableView insertRowsAtIndexPaths:[NSArray arrayWithObject:newIndexPath] withRowAnimation:UITableViewRowAnimationFade];
break;
case NSFetchedResultsChangeDelete:
[self.tableView deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath] withRowAnimation:UITableViewRowAnimationFade];
break;
case NSFetchedResultsChangeUpdate: {
NSString *sectionKeyPath = [controller sectionNameKeyPath];
if (sectionKeyPath == nil)
break;
NSManagedObject *changedObject = [controller objectAtIndexPath:indexPath];
NSArray *keyParts = [sectionKeyPath componentsSeparatedByString:@"."];
id currentKeyValue = [changedObject valueForKeyPath:sectionKeyPath];
for (int i = 0; i < [keyParts count] - 1; i++) {
NSString *onePart = [keyParts objectAtIndex:i];
changedObject = [changedObject valueForKey:onePart];
}

sectionKeyPath = [keyParts lastObject];
NSDictionary *committedValues = [changedObject committedValuesForKeys:nil];

if ([[committedValues valueForKeyPath:sectionKeyPath] isEqual:currentKeyValue])
break;

NSUInteger tableSectionCount = [self.tableView numberOfSections];
NSUInteger frcSectionCount = [[controller sections] count];
if (tableSectionCount != frcSectionCount) {
// Need to insert a section
NSArray *sections = controller.sections;
NSInteger newSectionLocation = -1;
for (id oneSection in sections) {
NSString *sectionName = [oneSection name];
if ([currentKeyValue isEqual:sectionName]) {
newSectionLocation = [sections indexOfObject:oneSection];
break;
}

}

if (newSectionLocation == -1)
return; // uh oh

if (!((newSectionLocation == 0) && (tableSectionCount == 1) && ([self.tableView numberOfRowsInSection:0] == 0)))
[self.tableView insertSections:[NSIndexSet indexSetWithIndex:newSectionLocation] withRowAnimation:UITableViewRowAnimationFade];
NSUInteger indices[2] = {newSectionLocation, 0};
newIndexPath = [[[NSIndexPath alloc] initWithIndexes:indices length:2] autorelease];
}

}

case NSFetchedResultsChangeMove:
if (newIndexPath != nil) {

NSUInteger tableSectionCount = [self.tableView numberOfSections];
NSUInteger frcSectionCount = [[controller sections] count];
if (frcSectionCount >= tableSectionCount)
[self.tableView insertSections:[NSIndexSet indexSetWithIndex:[newIndexPath section]] withRowAnimation:UITableViewRowAnimationNone];
else
if (tableSectionCount > 1)
[self.tableView deleteSections:[NSIndexSet indexSetWithIndex:[indexPath section]] withRowAnimation:UITableViewRowAnimationNone];


[self.tableView deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath] withRowAnimation:UITableViewRowAnimationFade];
[self.tableView insertRowsAtIndexPaths: [NSArray arrayWithObject:newIndexPath]
withRowAnimation: UITableViewRowAnimationRight
]
;

}

else {
[self.tableView reloadSections:[NSIndexSet indexSetWithIndex:[indexPath section]] withRowAnimation:UITableViewRowAnimationFade];
}

break;
default:
break;
}

}

- (void)controller:(NSFetchedResultsController *)controller didChangeSection:(id <NSFetchedResultsSectionInfo>)sectionInfo atIndex:(NSUInteger)sectionIndex forChangeType:(NSFetchedResultsChangeType)type {
switch(type) {

case NSFetchedResultsChangeInsert:
if (!((sectionIndex == 0) && ([self.tableView numberOfSections] == 1)))
[self.tableView insertSections:[NSIndexSet indexSetWithIndex:sectionIndex] withRowAnimation:UITableViewRowAnimationFade];
break;
case NSFetchedResultsChangeDelete:
if (!((sectionIndex == 0) && ([self.tableView numberOfSections] == 1) ))
[self.tableView deleteSections:[NSIndexSet indexSetWithIndex:sectionIndex] withRowAnimation:UITableViewRowAnimationFade];
break;
case NSFetchedResultsChangeMove:
break;
case NSFetchedResultsChangeUpdate:
break;
default:
break;
}

}

Depuis notre demande initiale a donné tous les rangs de sa propre section, nous n'avons pas eu ce problème, mais ce qui arrive, c'est quand nous recevons un avis qu'une ligne a été déplacée, nous devons faire en sorte que le nombre de sections dans la table et faire correspondre contrôleur. Il est possible que suite déménagé à une nouvelle section, voire provoquer une rangée pour être supprimé ou inséré dans le contrôleur, mais pas la table. Si une ligne est déplacé d'une section à l'autre, et nous ne sommes pas en rendre compte, l'application se bloque. Si la ligne avait été déplacé de la dernière rangée dans une section, nous avons besoin de supprimer la section de la table, sauf si elle a été la dernière section, car les tables doivent avoir au moins un article. Si le déplacement de la ligne a créé une nouvelle section dans le contrôleur, nous insérons une nouvelle ligne dans la table.

Et c'est vraiment, vous avez maintenant la liste de votre héros SuperDB de diviser par la première lettre soit le héros le nom ou l'identité secrète, selon l'onglet a été sélectionné.

Vous devez utiliser les méthodes chercher les résultats déléguée contrôleur à partir de cette annonce au lieu de ceux dans le livre. Ceux dans le livre très bien fonctionner pour l'application dans le livre, mais celui-ci est plus souple et gérera une grande variété de situations correctement.

mercredi 7 mars 2012

Un correctif pour NSFetchedResultsController Méthodes Délégué

J'ai testé hier après environ NSFetchedResultsController. Il fonctionne bien dans tous les scénarios que j'ai testé avec la section des chemins nom de la clé. Il provoque actuellement quelques problèmes lorsque vous n'utilisez pas un chemin de clé de noms des sections. Cela a été corrigé avec une seule ligne de code dans le contrôleur: didChangeObject: atIndexPath: forChangeType: newIndexPath: méthode.

J'ai mis à jour le Navigation basée sur des données de base de modèle de projet Application avec ce changement.

Voici la nouvelle version, avec le changement en gras:

- (void)controller:(NSFetchedResultsController *)controller didChangeObject:(id)anObject atIndexPath:(NSIndexPath *)indexPath forChangeType:(NSFetchedResultsChangeType)type newIndexPath:(NSIndexPath *)newIndexPath {
switch(type) {
case NSFetchedResultsChangeInsert:
[self.tableView insertRowsAtIndexPaths:[NSArray arrayWithObject:newIndexPath] withRowAnimation:UITableViewRowAnimationFade];
break;
case NSFetchedResultsChangeDelete:
[self.tableView deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath] withRowAnimation:UITableViewRowAnimationFade];
break;
case NSFetchedResultsChangeUpdate: {
NSString *sectionKeyPath = [controller sectionNameKeyPath];
if (sectionKeyPath == nil)
break;

NSManagedObject *changedObject = [controller objectAtIndexPath:indexPath];
NSArray *keyParts = [sectionKeyPath componentsSeparatedByString:@"."];
id currentKeyValue = [changedObject valueForKeyPath:sectionKeyPath];
for (int i = 0; i < [keyParts count] - 1; i++) {
NSString *onePart = [keyParts objectAtIndex:i];
changedObject = [changedObject valueForKey:onePart];
}

sectionKeyPath = [keyParts lastObject];
NSDictionary *committedValues = [changedObject committedValuesForKeys:nil];

if ([[committedValues valueForKeyPath:sectionKeyPath] isEqual:currentKeyValue])
break;

NSUInteger tableSectionCount = [self.tableView numberOfSections];
NSUInteger frcSectionCount = [[controller sections] count];
if (tableSectionCount != frcSectionCount) {
// Need to insert a section
NSArray *sections = controller.sections;
NSInteger newSectionLocation = -1;
for (id oneSection in sections) {
NSString *sectionName = [oneSection name];
if ([currentKeyValue isEqual:sectionName]) {
newSectionLocation = [sections indexOfObject:oneSection];
break;
}

}

if (newSectionLocation == -1)
return; // uh oh

if (!(newSectionLocation == 0 && tableSectionCount == 1))
[self.tableView insertSections:[NSIndexSet indexSetWithIndex:newSectionLocation] withRowAnimation:UITableViewRowAnimationFade];
NSUInteger indices[2] = {newSectionLocation, 0};
newIndexPath = [[[NSIndexPath alloc] initWithIndexes:indices length:2] autorelease];
}

}

case NSFetchedResultsChangeMove:
if (newIndexPath != nil) {
[self.tableView deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath] withRowAnimation:UITableViewRowAnimationFade];
[self.tableView insertRowsAtIndexPaths: [NSArray arrayWithObject:newIndexPath]
withRowAnimation: UITableViewRowAnimationRight
]
;

}

else {
[self.tableView reloadSections:[NSIndexSet indexSetWithIndex:[indexPath section]] withRowAnimation:UITableViewRowAnimationFade];
}

break;
default:
break;
}

}



Un correctif pour NSFetchedResultsController Méthodes Délégué

J'ai testé hier après environ NSFetchedResultsController. Il fonctionne bien dans tous les scénarios que j'ai testé avec la section des chemins nom de la clé. Il provoque actuellement quelques problèmes lorsque vous n'utilisez pas un chemin de clé de noms des sections. Cela a été corrigé avec une seule ligne de code dans le contrôleur: didChangeObject: atIndexPath: forChangeType: newIndexPath: méthode.

J'ai mis à jour le Navigation basée sur des données de base de modèle de projet Application avec ce changement.

Voici la nouvelle version, avec le changement en gras:

- (void)controller:(NSFetchedResultsController *)controller didChangeObject:(id)anObject atIndexPath:(NSIndexPath *)indexPath forChangeType:(NSFetchedResultsChangeType)type newIndexPath:(NSIndexPath *)newIndexPath {
switch(type) {
case NSFetchedResultsChangeInsert:
[self.tableView insertRowsAtIndexPaths:[NSArray arrayWithObject:newIndexPath] withRowAnimation:UITableViewRowAnimationFade];
break;
case NSFetchedResultsChangeDelete:
[self.tableView deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath] withRowAnimation:UITableViewRowAnimationFade];
break;
case NSFetchedResultsChangeUpdate: {
NSString *sectionKeyPath = [controller sectionNameKeyPath];
if (sectionKeyPath == nil)
break;

NSManagedObject *changedObject = [controller objectAtIndexPath:indexPath];
NSArray *keyParts = [sectionKeyPath componentsSeparatedByString:@"."];
id currentKeyValue = [changedObject valueForKeyPath:sectionKeyPath];
for (int i = 0; i < [keyParts count] - 1; i++) {
NSString *onePart = [keyParts objectAtIndex:i];
changedObject = [changedObject valueForKey:onePart];
}

sectionKeyPath = [keyParts lastObject];
NSDictionary *committedValues = [changedObject committedValuesForKeys:nil];

if ([[committedValues valueForKeyPath:sectionKeyPath] isEqual:currentKeyValue])
break;

NSUInteger tableSectionCount = [self.tableView numberOfSections];
NSUInteger frcSectionCount = [[controller sections] count];
if (tableSectionCount != frcSectionCount) {
// Need to insert a section
NSArray *sections = controller.sections;
NSInteger newSectionLocation = -1;
for (id oneSection in sections) {
NSString *sectionName = [oneSection name];
if ([currentKeyValue isEqual:sectionName]) {
newSectionLocation = [sections indexOfObject:oneSection];
break;
}

}

if (newSectionLocation == -1)
return; // uh oh

if (!(newSectionLocation == 0 && tableSectionCount == 1))
[self.tableView insertSections:[NSIndexSet indexSetWithIndex:newSectionLocation] withRowAnimation:UITableViewRowAnimationFade];
NSUInteger indices[2] = {newSectionLocation, 0};
newIndexPath = [[[NSIndexPath alloc] initWithIndexes:indices length:2] autorelease];
}

}

case NSFetchedResultsChangeMove:
if (newIndexPath != nil) {
[self.tableView deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath] withRowAnimation:UITableViewRowAnimationFade];
[self.tableView insertRowsAtIndexPaths: [NSArray arrayWithObject:newIndexPath]
withRowAnimation: UITableViewRowAnimationRight
]
;

}

else {
[self.tableView reloadSections:[NSIndexSet indexSetWithIndex:[indexPath section]] withRowAnimation:UITableViewRowAnimationFade];
}

break;
default:
break;
}

}