Je voudrais ajouter des données de base à un projet iPhone existant, mais j'obtiens encore beaucoup d'erreurs de compilation:

- NSManagedObjectContext undeclared

 - Expected specifier-qualifier-list before 'NSManagedObjectModel'

 - ...

J'ai déjà ajouté le Core Data Framework à la cible (clic droit sur mon projet sous "Targets", "Add" - "Existing Frameworks", "CoreData.framework").

Mon fichier d'en-tête:

NSManagedObjectModel *managedObjectModel;
NSManagedObjectContext *managedObjectContext;       
NSPersistentStoreCoordinator *persistentStoreCoordinator;

[...]

@property (nonatomic, retain, readonly) NSManagedObjectModel *managedObjectModel;
@property (nonatomic, retain, readonly) NSManagedObjectContext *managedObjectContext;
@property (nonatomic, retain, readonly) NSPersistentStoreCoordinator *persistentStoreCoordinator;

Qu'est-ce que je rate? Démarrer un nouveau projet n'est pas une option ...

Merci beaucoup!

edit désolé, j'ai ces implémentations ... mais il semble que la bibliothèque soit manquante ... les méthodes d'implémentation sont pleines avec des erreurs de compilation comme " managedObjectContext undeclared", " NSPersistentStoreCoordinator undeclared", mais aussi avec "Attendu ')' avant NSManagedObjectContext" (bien qu'il semble que les parenthèses sont correctes) ...

#pragma mark -
#pragma mark Core Data stack

/**
 Returns the managed object context for the application.
 If the context doesn't already exist, it is created and bound to the persistent store         
coordinator for the application.
 */
- (NSManagedObjectContext *) managedObjectContext {

    if (managedObjectContext != nil) {
        return managedObjectContext;
    }

    NSPersistentStoreCoordinator *coordinator = [self persistentStoreCoordinator];
    if (coordinator != nil) {
        managedObjectContext = [[NSManagedObjectContext alloc] init];
        [managedObjectContext setPersistentStoreCoordinator: coordinator];
    }
    return managedObjectContext;
}


/**
 Returns the managed object model for the application.
 If the model doesn't already exist, it is created by merging all of the models found in    
 application bundle.
 */
- (NSManagedObjectModel *)managedObjectModel {

    if (managedObjectModel != nil) {
        return managedObjectModel;
    }
    managedObjectModel = [[NSManagedObjectModel mergedModelFromBundles:nil] retain];    
    return managedObjectModel;
}


/**
 Returns the persistent store coordinator for the application.
 If the coordinator doesn't already exist, it is created and the application's store added to it.
 */
- (NSPersistentStoreCoordinator *)persistentStoreCoordinator {

    if (persistentStoreCoordinator != nil) {
        return persistentStoreCoordinator;
    }

    NSURL *storeUrl = [NSURL fileURLWithPath: [[self applicationDocumentsDirectory] 
        stringByAppendingPathComponent: @"Core_Data.sqlite"]];

    NSError *error = nil;
    persistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc] 
    initWithManagedObjectModel:[self managedObjectModel]];
    if (![persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType 
    configuration:nil URL:storeUrl options:nil error:&error]) {
    /*
     Replace this implementation with code to handle the error appropriately.

     abort() causes the application to generate a crash log and terminate. You should 
    not use this function in a shipping application, although it may be useful during 
    development. If it is not possible to recover from the error, display an alert panel that 
    instructs the user to quit the application by pressing the Home button.

     Typical reasons for an error here include:
     * The persistent store is not accessible
     * The schema for the persistent store is incompatible with current managed object 
                model
     Check the error message to determine what the actual problem was.
     */
    NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
    abort();
}    

return persistentStoreCoordinator;
}

Tous les fichiers d'en-tête CoreData sont importés dans App_Prefix.pch, de sorte que les classes CoreData seront disponibles tout au long de votre projet, vous n'avez donc pas à importer manuellement l'en-tête dans les fichiers dont vous avez besoin.

Alors ouvrez Xcode et recherchez un fichier comme App_Prefix.pch, par défaut, il est dans le Other Sourcesgroupe. Après l' UIKitinstruction d'importation, ajoutez la ligne suivante:

#import <CoreData/CoreData.h>

Et vous devriez être prêt à partir.

Xcode 4

Pour les projets créés dans Xcode 4, le fichier de préfixe se trouve dans le Supporting Filesgroupe du navigateur Projet. Il s'appelle « projectname -Prefix.pch» par défaut.

Xcode 6+

À partir de Xcode 6, le fichier d'en-tête précompilé n'est plus inclus par défaut. Ceci est dû à l'introduction de modules, qui suppriment le besoin d'utiliser des en-têtes précompilés. Bien qu'il soit toujours possible d'ajouter manuellement un fichier PCH pour inclure globalement les en-têtes CoreData, pensez à spécifier la dépendance CoreData en utilisant @import CoreData;* dans chaque fichier qui utilise CoreData. Cela rend les dépendances explicites et, plus important encore, évitera le problème de cette question à l'avenir.

_{* Les modules doivent être activés pour que cela fonctionne.}

Juste pour expliquer toutes les étapes que vous devez réellement effectuer pour ajouter des données de base à un projet qui ne les avait pas auparavant:

Étape 1: ajouter le cadre

Cliquez sur la cible de votre application (sur le volet de gauche, c'est l'icône du haut avec le nom de votre application) puis allez dans l'onglet 'Build Phases' puis sur 'Link Binary With Libraries', cliquez sur le petit '+' en bas puis trouvez 'CoreData.framework' et ajoutez-le à votre projet

Ensuite, soit importez des coredata sur tous les objets dont vous avez besoin (de manière non sexy) en utilisant:

Rapide

import CoreData

Objectif c

#import <CoreData/CoreData.h>

ou ajoutez l'importation sous les importations courantes dans votre fichier .pch (beaucoup plus sexy) comme ceci:

#ifdef __OBJC__
    #import <UIKit/UIKit.h>
    #import <Foundation/Foundation.h>
    #import <CoreData/CoreData.h>
#endif

Étape 2: ajouter le modèle de données

Pour ajouter le fichier .xcdatamodel, faites un clic droit / contrôle-cliquez sur vos fichiers dans le volet de droite (comme dans un dossier Ressources pour une conservation en toute sécurité) et sélectionnez Ajouter un nouveau fichier, cliquez sur l'onglet Données de base lors de la sélection de votre type de fichier, puis cliquez sur ' Modèle de données ', donnez-lui un nom et cliquez sur Suivant et Terminer et il l'ajoutera à votre projet. Lorsque vous cliquez sur cet objet modèle, vous verrez l'interface pour ajouter les entités à votre projet avec les relations que vous souhaitez.

Étape 3: mettre à jour le délégué d'application

Dans Swift sur AppDelegate.swift

//replace the previous version of applicationWillTerminate with this
func applicationWillTerminate(application: UIApplication) {
    // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
    // Saves changes in the application's managed object context before the application terminates.
    self.saveContext()
}

func saveContext () {
    var error: NSError? = nil
    let managedObjectContext = self.managedObjectContext
    if managedObjectContext != nil {
        if managedObjectContext.hasChanges && !managedObjectContext.save(&error) {
            // Replace this implementation with code to handle the error appropriately.
            // abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
            //println("Unresolved error \(error), \(error.userInfo)")
            abort()
        }
    }
}

// #pragma mark - Core Data stack

// Returns the managed object context for the application.
// If the context doesn't already exist, it is created and bound to the persistent store coordinator for the application.
var managedObjectContext: NSManagedObjectContext {
    if !_managedObjectContext {
        let coordinator = self.persistentStoreCoordinator
        if coordinator != nil {
            _managedObjectContext = NSManagedObjectContext()
            _managedObjectContext!.persistentStoreCoordinator = coordinator
        }
    }
    return _managedObjectContext!
}
var _managedObjectContext: NSManagedObjectContext? = nil

// Returns the managed object model for the application.
// If the model doesn't already exist, it is created from the application's model.
var managedObjectModel: NSManagedObjectModel {
    if !_managedObjectModel {
        let modelURL = NSBundle.mainBundle().URLForResource("iOSSwiftOpenGLCamera", withExtension: "momd")
        _managedObjectModel = NSManagedObjectModel(contentsOfURL: modelURL)
    }
    return _managedObjectModel!
}
var _managedObjectModel: NSManagedObjectModel? = nil

// Returns the persistent store coordinator for the application.
// If the coordinator doesn't already exist, it is created and the application's store added to it.
var persistentStoreCoordinator: NSPersistentStoreCoordinator {
    if !_persistentStoreCoordinator {
        let storeURL = self.applicationDocumentsDirectory.URLByAppendingPathComponent("iOSSwiftOpenGLCamera.sqlite")
        var error: NSError? = nil
        _persistentStoreCoordinator = NSPersistentStoreCoordinator(managedObjectModel: self.managedObjectModel)
        if _persistentStoreCoordinator!.addPersistentStoreWithType(NSSQLiteStoreType, configuration: nil, URL: storeURL, options: nil, error: &error) == nil {
            /*
            Replace this implementation with code to handle the error appropriately.
            abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
            Typical reasons for an error here include:
            * The persistent store is not accessible;
            * The schema for the persistent store is incompatible with current managed object model.
            Check the error message to determine what the actual problem was.
            If the persistent store is not accessible, there is typically something wrong with the file path. Often, a file URL is pointing into the application's resources directory instead of a writeable directory.
            If you encounter schema incompatibility errors during development, you can reduce their frequency by:
            * Simply deleting the existing store:
            NSFileManager.defaultManager().removeItemAtURL(storeURL, error: nil)
            * Performing automatic lightweight migration by passing the following dictionary as the options parameter:
            [NSMigratePersistentStoresAutomaticallyOption: true, NSInferMappingModelAutomaticallyOption: true}
            Lightweight migration will only work for a limited set of schema changes; consult "Core Data Model Versioning and Data Migration Programming Guide" for details.
            */
            //println("Unresolved error \(error), \(error.userInfo)")
            abort()
        }
    }
    return _persistentStoreCoordinator!
}
var _persistentStoreCoordinator: NSPersistentStoreCoordinator? = nil

// #pragma mark - Application's Documents directory

// Returns the URL to the application's Documents directory.
var applicationDocumentsDirectory: NSURL {
    let urls = NSFileManager.defaultManager().URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)
    return urls[urls.endIndex-1] as NSURL
}

Dans Objective C, assurez-vous d'ajouter ces objets à AppDelegate.h

 @property (nonatomic, retain, readonly) NSManagedObjectModel *managedObjectModel;
 @property (nonatomic, retain, readonly) NSManagedObjectContext *managedObjectContext;
 @property (nonatomic, retain, readonly) NSPersistentStoreCoordinator *persistentStoreCoordinator;

 - (NSURL *)applicationDocumentsDirectory; // nice to have to reference files for core data

Synthétisez les objets précédents dans AppDelegate.m comme ceci:

@synthesize managedObjectContext = _managedObjectContext;
@synthesize managedObjectModel = _managedObjectModel;
@synthesize persistentStoreCoordinator = _persistentStoreCoordinator;

Ajoutez ensuite ces méthodes à AppDelegate.m (assurez-vous de mettre le nom du modèle que vous avez ajouté dans les emplacements indiqués):

- (void)saveContext{
    NSError *error = nil;
    NSManagedObjectContext *managedObjectContext = self.managedObjectContext;
    if (managedObjectContext != nil) {
        if ([managedObjectContext hasChanges] && ![managedObjectContext save:&error]) {
            NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
            abort();
        }
    }
}

- (NSManagedObjectContext *)managedObjectContext{
    if (_managedObjectContext != nil) {
        return _managedObjectContext;
    }

    NSPersistentStoreCoordinator *coordinator = [self persistentStoreCoordinator];
    if (coordinator != nil) {
        _managedObjectContext = [[NSManagedObjectContext alloc] init];
        [_managedObjectContext setPersistentStoreCoordinator:coordinator];
    }
    return _managedObjectContext;
}

- (NSManagedObjectModel *)managedObjectModel{
    if (_managedObjectModel != nil) {
        return _managedObjectModel;
    }
    NSURL *modelURL = [[NSBundle mainBundle] URLForResource:@"NAMEOFYOURMODELHERE" withExtension:@"momd"];
    _managedObjectModel = [[NSManagedObjectModel alloc] initWithContentsOfURL:modelURL];
    return _managedObjectModel;
}

- (NSPersistentStoreCoordinator *)persistentStoreCoordinator
{
    if (_persistentStoreCoordinator != nil) {
        return _persistentStoreCoordinator;
    }

    NSURL *storeURL = [[self applicationDocumentsDirectory] URLByAppendingPathComponent:@"NAMEOFYOURMODELHERE.sqlite"];

    NSError *error = nil;
    _persistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:[self managedObjectModel]];
    if (![_persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:nil error:&error]) {

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

    return _persistentStoreCoordinator;
}

 #pragma mark - Application's Documents directory

// Returns the URL to the application's Documents directory.
- (NSURL *)applicationDocumentsDirectory{
    return [[[NSFileManager defaultManager] URLsForDirectory:NSDocumentDirectory inDomains:NSUserDomainMask] lastObject];
}

Étape 4: acheminez les objets de données vers les ViewControllers là où vous avez besoin des données

Option 1. Utilisez ManagedObjectContext du délégué d'application à partir de VC (préféré et plus facile)

Comme suggéré par @ brass-kazoo - Récupérez une référence à AppDelegate et à son managedObjectContext via:

Rapide

 let appDelegate = UIApplication.sharedApplication().delegate as! AppDelegate
 appDelegate.managedObjectContext

Objectif c

 [[[UIApplication sharedApplication] delegate] managedObjectContext];

dans votre ViewController

Option 2. Créez ManagedObjectContext dans votre VC et faites-le correspondre à AppDelegate de AppDelegate (Original)

Afficher uniquement l'ancienne version pour Objective C car il est beaucoup plus facile d'utiliser la méthode préférée

dans le ViewController.h

@property (nonatomic, retain) NSManagedObjectContext *managedObjectContext;

Dans le ViewController.m

@synthesize managedObjectContext = _managedObjectContext;

Dans l'AppDelegate, ou la classe où le ViewController est créé, définissez managedObjectContext pour qu'il soit identique à celui d'AppDelegate

ViewController.managedObjectContext = self.managedObjectContext;

Si vous voulez que le viewcontroller utilisant Core Data soit un FetchedResultsController, vous devez vous assurer que ce contenu est dans votre ViewController.h

@interface ViewController : UIViewController <NSFetchedResultsControllerDelegate> {
  NSFetchedResultsController *fetchedResultsController;
  NSManagedObjectContext *managedObjectContext;
}

 @property (nonatomic, retain) NSFetchedResultsController *fetchedResultsController;

Et c'est dans ViewController.m

@synthesize fetchedResultsController, managedObjectContext;

Après tout cela, vous pouvez maintenant utiliser ce managedObjectContext pour exécuter toutes les requêtes fetchRequests habituelles nécessaires à la bonté CoreData! Prendre plaisir

Pour Swift 3: INCLUT LA SAUVEGARDE ET LA RÉCUPÉRATION DES DONNÉES

Étape 1 : Ajouter un cadre

Étape 2: Ajouter un modèle de données

Fichier> Nouveau> Fichier> Données de base> Modèle de données

• Nommez le fichier comme SampleDatale fichier résultant seraitSampleData.xcdatamocelId

Étape 3: Ajoutez les fonctions ci-dessous à votre délégué d'application et ajoutez «importer CoreData» en haut

func applicationWillTerminate(_ application: UIApplication) {
    // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
    // Saves changes in the application's managed object context before the application terminates.
    self.saveContext()
}


// MARK: - Core Data stack

lazy var persistentContainer: NSPersistentContainer = {
    /*
     The persistent container for the application. This implementation
     creates and returns a container, having loaded the store for the
     application to it. This property is optional since there are legitimate
     error conditions that could cause the creation of the store to fail.
     */


    // SEE BELOW LINE OF CODE WHERE THE 'name' IS SET AS THE FILE NAME (SampleData) FOR THE CONTAINER

    let container = NSPersistentContainer(name: "SampleData")
    container.loadPersistentStores(completionHandler: { (storeDescription, error) in
        if let error = error as NSError? {
            // Replace this implementation with code to handle the error appropriately.
            // fatalError() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.

            /*
             Typical reasons for an error here include:
             * The parent directory does not exist, cannot be created, or disallows writing.
             * The persistent store is not accessible, due to permissions or data protection when the device is locked.
             * The device is out of space.
             * The store could not be migrated to the current model version.
             Check the error message to determine what the actual problem was.
             */
            fatalError("Unresolved error \(error), \(error.userInfo)")
        }
    })
    return container
}()

// MARK: - Core Data Saving support

func saveContext () {
    let context = persistentContainer.viewContext
    if context.hasChanges {
        do {
            try context.save()
        } catch {
            // Replace this implementation with code to handle the error appropriately.
            // fatalError() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
            let nserror = error as NSError
            fatalError("Unresolved error \(nserror), \(nserror.userInfo)")
        }
    }
}

ÉTAPE 4: Ajouter une entité et un attribut au modèle

a) Ajouter une entité

b) Ajouter un attribut

ÉTAPE 5: Sauvegarde des données

func saveItem(itemToSave: String){
    let context = (UIApplication.shared.delegate as! AppDelegate).persistentContainer.viewContext

//**Note:** Here we are providing the entityName **`Entity`** that we have added in the model
    let entity = NSEntityDescription.entity(forEntityName: "Entity", in: context)
    let myItem = NSManagedObject(entity: entity!, insertInto: context)

    myItem.setValue(itemToSave, forKey: "item")
    do {
        try context.save()
    }
    catch{
        print("There was an error in saving data")
    }
}

ÉTAPE 5: Récupération des données

override func viewWillAppear(_ animated: Bool) {
    // Obtaining data from model
    let context = (UIApplication.shared.delegate as! AppDelegate).persistentContainer.viewContext
    let fetchRequest = NSFetchRequest<NSFetchRequestResult>(entityName: "Entity")

    do {
        let results = try context.fetch(fetchRequest)
        let obtainedResults = results as! [NSManagedObject]
        let firstResult = obtainedResults[0]
        let myValue = firstResult.value(forKey: "item")

        print("myValue: \(myValue)")
    } catch {
        print("Error")
    }
}

Essayez de créer une application Cocoa basée sur Core Data et regardez AppDelegate. Vous y verrez des méthodes d'implémentation de la pile de données de base, ainsi qu'un fichier de modèle d'objet géré pour définir vos entités et d'autres éléments liés aux données de base.

Vous nous avez montré uniquement l'en-tête (c'est-à-dire la déclaration), mais pas l'implémentation (c'est-à-dire la définition) de la pile Core Data.

Si vous rencontrez ce même problème dans xcode 4, comme je l'ai fait. C'est différent: j'ai dû sélectionner le projet, puis dans les cibles développez "Link Binary With Libraries" qui montre les bibliothèques actuelles. De là, cliquez sur le + (signe plus) pour sélectionner les bibliothèques supplémentaires dont vous avez besoin. Je l'ai placé en haut du projet et j'ai dû le déplacer (glisser-déposer) vers le groupe Frameworks , mais c'était tout.

Comme Eimantas l'a déclaré, vous manquez l'implémentation de la Core Stack, comme

- (NSManagedObjectContext *) managedObjectContext;
- (NSManagedObjectModel *)managedObjectMode;
- (NSPersistentStoreCoordinator *)persistentStoreCoordinator;

La solution serait de créer un nouveau projet de pilote de données de base et de copier / coller l'implémentation dans votre projet.

Pour Swift 3:

Fichier-> nouveau fichier-> CoreData-> Modèle pour créer un modèle.

Reportez-vous à ce lien pour plus d'informations sur sa mise en œuvre.

// dans Swift 2.2, vous pouvez effectuer les opérations suivantes sans modifier le fichier AppDelegate.

1. Projet-> cibles -> frameworks et bibliothèques liés Ajoutez maintenant un nouveau framework (cliquez sur +) 'CoreData'
2. Fichier-> nouveau fichier-> CoreData-> DataModel le nommez comme A.xcdatamodelid
3. Dans A.xcdatamodelid, créez une nouvelle entité (cliquez sur entité +) nommez-la comme par exemple Bc et définissez sa classe comme 'Bc' dans la fenêtre de l'inspecteur à droite.
4. Maintenant, ajoutez des attributs à l'entité (cliquez sur attributs +), ajoutez un attribut par exemple: nom et son type sous forme de chaîne.
5. Maintenant, rédacteur -> créez une sous-classe NSManagedObject -> cliquez sur suivant dans la fenêtre contextuelle -> encore une fois sur suivant -> puis cliquez sur créer. Deux nouveaux fichiers seront créés 1. une nouvelle classe nommée Bc.swift et une extension nommée Bc + coredataproperties.swift.

6. Fichier-> nouveau fichier-> ios-> classe Cocoa Touch -> définissez sa sous-classe comme NSObject-> nommez-le comme DataController.swift Dans le fichier, incluez ///

   import UIKit importation de la classe CoreData DataController: NSObject {

   var managedObjectContext: NSManagedObjectContext
   
   override  init() {
       // This resource is the same name as your xcdatamodeld contained in your project.
       guard let modelURL = NSBundle.mainBundle().URLForResource("A", withExtension:"momd") else {
           fatalError("Error loading model from bundle")
       }
       // The managed object model for the application. It is a fatal error for the application not to be able to find and load its model.
       guard let mom = NSManagedObjectModel(contentsOfURL: modelURL) else {
           fatalError("Error initializing mom from: \(modelURL)")
       }
       let psc = NSPersistentStoreCoordinator(managedObjectModel: mom)
       self.managedObjectContext = NSManagedObjectContext(concurrencyType: .MainQueueConcurrencyType)
       self.managedObjectContext.persistentStoreCoordinator = psc
   
       let urls = NSFileManager.defaultManager().URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)
       let docURL = urls[urls.endIndex-1]
       /* The directory the application uses to store the Core Data store file.
       This code uses a file named "A.sqlite" in the application's documents directory.
       */
       let storeURL = docURL.URLByAppendingPathComponent("A.sqlite")
       do {
           try psc.addPersistentStoreWithType(NSSQLiteStoreType, configuration: nil, URL: storeURL, options: nil)
       } catch {
           fatalError("Error migrating store: \(error)")
       }
   
   }

   }

//////

7. Maintenant, dans le fichier viewcontroller, vous pouvez accéder à votre base de données en utilisant deux méthodes. Important: incluez l'instruction dans votre viewController "import CoreData" a. appelez seed () -> pour insérer une valeur dans db / entity b. appelez fetch () -> pour récupérer la valeur de la base de données / entité

/////// graine () -> def

func seedPerson() {

        // create an instance of our managedObjectContext
        let moc = DataController().managedObjectContext

        // we set up our entity by selecting the entity and context that we're targeting
        let entity = NSEntityDescription.insertNewObjectForEntityForName("Bc", inManagedObjectContext: moc) as! Bc

        // add our data
        entity.setValue("Meera", forKey: "name")


        // we save our entity
        do {
            try moc.save()
        } catch {
            fatalError("Failure to save context: \(error)")
        }
    }

// fetch () def

func fetch() {
        let moc = DataController().managedObjectContext
        let personFetch = NSFetchRequest(entityName: "Bc")

        do {
            let fetchedPerson = try moc.executeFetchRequest(personFetch) as! [Bc]
            print(fetchedPerson.first!.name!)

        } catch {
            fatalError("Failed to fetch person: \(error)")
        }
    }

view.h

  #import <UIKit/UIKit.h>
  #import <CoreData/CoreData.h>

    @interface ViewController :  
    UIViewController<UITableViewDataSource,UITableViewDelegate>

   @property (weak, nonatomic) IBOutlet UITableView *coreDataList;
   - (IBAction)addBtnClick:(id)sender;
   @property (strong, nonatomic) NSMutableArray *dataList;
   @end

detail.h

  #import <UIKit/UIKit.h>
  #import <CoreData/CoreData.h>

 @interface DetailViewController : UIViewController<UITextFieldDelegate>
@property (weak, nonatomic) IBOutlet UITextField *nameTxt;
@property (weak, nonatomic) IBOutlet UITextField *mobileTxt;
@property (weak, nonatomic) IBOutlet UITextField *emailIdTxt;
 - (IBAction)saveBtnClick:(id)sender;
@property (strong,nonatomic) NSManagedObject *userData;

@end

  - (void)viewDidLoad {
  [super viewDidLoad];
  // Do any additional setup after loading the view.
   if (self.userData) {
    [self.nameTxt setText:[self.userData valueForKey:@"name"]];
    [self.mobileTxt setText:[self.userData 
     valueForKey:@"mobileNumber"]];
    [self.emailIdTxt setText:[self.userData valueForKey:@"email"]];
    [self.imgView setImage:[UIImage imageWithData:[self.userData 
     valueForKey:@"imageView"]]];    }
        }

  - (void)didReceiveMemoryWarning {
[super didReceiveMemoryWarning];
// Dispose of any resources that can be recreated.
  }


  - (BOOL)textFieldShouldReturn:(UITextField *)textField
  {
   [textField resignFirstResponder];
return YES;
 }
  /*
  #pragma mark - Navigation



 - (IBAction)browseBtn:(id)sender
   {

  UIImagePickerController *imgpic =[[UIImagePickerController      
     alloc]init];     
  imgpic .delegate =self;
 imgpic .sourceType =UIImagePickerControllerSourceTypePhotoLibrary;
[self presentViewController:imgpic animated:YES completion:nil];

 }
 -(void)imagePickerController:(UIImagePickerController *)picker 
 didFinishPickingMediaWithInfo:(NSDictionary<NSString *,id> *)info
 {
  UIImage *choose = info[UIImagePickerControllerOriginalImage];
self.imgView.image=choose;
[picker dismissViewControllerAnimated:YES completion:nil];
}


  - (IBAction)saveBtnClick:(id)sender {

 NSManagedObjectContext *context = [self managedObjectContext];

 if (self.userData) {
    // Update existing data
    [self.userData setValue:self.nameTxt.text forKey:@"name"];
    [self.userData setValue:self.mobileTxt.text 
     forKey:@"mobileNumber"];        
   [self.userData setValue:self.emailIdTxt.text forKey:@"email"];

    UIImage *sampleimage = _imgView.image;
    NSData *dataImage = UIImageJPEGRepresentation(sampleimage, 1.0);
            [self.userData setValue:dataImage forKey:@"imageView"];

    } else {
    // Create a new data
    NSManagedObject *newDevice = [NSEntityDescription 
     insertNewObjectForEntityForName:@"Details" 
     inManagedObjectContext:context];
    [newDevice setValue:self.nameTxt.text forKey:@"name"];
    [newDevice setValue:self.mobileTxt.text forKey:@"mobileNumber"];
    [newDevice setValue:self.emailIdTxt.text forKey:@"email"];
    UIImage *sampleimage = _imgView.image;
    NSData *dataImage = UIImageJPEGRepresentation(sampleimage, 1.0);

    [newDevice setValue:dataImage forKey:@"imageView"];

  }

  NSError *error = nil;
 // Save the object to persistent store
 if (![context save:&error]) {
    NSLog(@"Can't Save! %@ %@", error, [error localizedDescription]);
 }

 [self dismissViewControllerAnimated:YES completion:nil];
 }
   @end

.h

 #import <UIKit/UIKit.h>
#import <CoreData/CoreData.h>

 @interface DetailViewController :
 UIViewController<UITextFieldDelegate,UINavigationControllerDelegate,            
     UIIma
    gePickerControllerDelegate>
         @property (weak, nonatomic) IBOutlet UITextField *nameTxt;
  @property (weak, nonatomic) IBOutlet UITextField *mobileTxt;
 @property (weak, nonatomic) IBOutlet UITextField *emailIdTxt;
  @property (weak, nonatomic) IBOutlet UIImageView *imgView;
 - (IBAction)browseBtn:(id)sender;
 - (IBAction)saveBtnClick:(id)sender;
@property (strong,nonatomic) NSManagedObject *userData;

@end

 let alert  = UIAlertController(title:"Error", message: "No Internet Connection", preferredStyle: .alert)
            alert.addAction(UIAlertAction(title: "Ok", style: .default, handler: { (action) in}))
            alert.addAction(UIAlertAction(title: "Try Again", style: .default, handler: { (action) in
                self.networkCall(text: self.daySelected)
            }))
            self.present(alert, animated: false, completion: nil)

+(void) insetPlusUpdate:(NSDictionary *)dataa {

    NSManagedObjectContext * context;

    if (![[NSThread currentThread] isMainThread]) {

        context = [[NSManagedObjectContext alloc] init];

        [context setPersistentStoreCoordinator:[APP_DELEGATE persistentStoreCoordinator]];
    } else {

        context = [APP_DELEGATE managedObjectContext];
    }

    NSFetchRequest * request = [[NSFetchRequest alloc] init];

    NSEntityDescription * entity = [NSEntityDescription entityForName:@"EntityName" inManagedObjectContext:context];

    [request setEntity:entity];

    NSPredicate * check = [NSPredicate predicateWithFormat:@"attribute == %@", Dict[@"key"]];

    [request setPredicate:check];

    NSError * error = nil;

    if ([context countForFetchRequest:request error:&error] == 0) {

Entity.attribute = @"";

    } else {


        NSArray * array = [context executeFetchRequest:request error:&error];

        EntityName * entity = [array firstObject];

  Entity.attribute = @"";

    }

}

+(NSString *)fetch:(NSString *)feed_id{

    NSManagedObjectContext * context;

    if(![[NSThread currentThread] isMainThread]){

        context = [[NSManagedObjectContext alloc] init];

        [context setPersistentStoreCoordinator:[APP_DELEGATE persistentStoreCoordinator]];

    } else {

        context = [APP_DELEGATE managedObjectContext];

    }

    NSFetchRequest * request = [[NSFetchRequest alloc] init];

    NSEntityDescription * entity = [NSEntityDescription entityForName:@"ENTITYNAME" inManagedObjectContext:context];

    [request setEntity:entity];

   NSPredicate * check = [NSPredicate predicateWithFormat:@"attribute == %@", Dict[@"key"]];

    [request setPredicate:check];

    NSError * error = nil;

    if ([context countForFetchRequest:request error:&error] > 0) {

        NSArray * array = [context executeFetchRequest:request error:&error];

        ENTITYNAME * fetchData = [array firstObject];

        NSString * string = fetchData.attribte[@"key"];

        return string;
    }

    return nil;
}


+(BOOL)delete{

    NSManagedObjectContext * context;

    if (![[NSThread currentThread] isMainThread]) {

        context = [[NSManagedObjectContext alloc] init];

        [context setPersistentStoreCoordinator:[APP_DELEGATE persistentStoreCoordinator]];

    } else {

        context = [APP_DELEGATE managedObjectContext];

    }

    NSFetchRequest * request = [[NSFetchRequest alloc] init];

    NSEntityDescription * entity = [NSEntityDescription entityForName:@"ENTITYNAME" inManagedObjectContext:context];

    [request setEntity:entity];

    NSError *error = nil;

    NSBatchDeleteRequest *deleteRequest = [[NSBatchDeleteRequest alloc] initWithFetchRequest: request];

    @try{

        [context executeRequest:deleteRequest error:&error];
        if([context save:&error]){

            NSLog(@"Deleted");

            return [context save:&error];

        }
        else{

            return [context save:&error];
        }

    }
    @catch(NSException *exception){

        NSLog(@"failed %@",exception);
        return [context save:&error];
    }    


}

exemple de vue de codage1

#import "ViewController.h"
#import "DetailViewController.h"

 @interface ViewController ()
 {
  NSInteger indexPathvalue;
 }
 @end

  @implementation ViewController

 - (NSManagedObjectContext *)managedObjectContext {
     NSManagedObjectContext *context = nil;
     id delegate = [[UIApplication sharedApplication] delegate];
     if ([delegate performSelector:@selector(managedObjectContext)]) {
       context = [delegate managedObjectContext];
     }
   return context;
  }

  - (void)viewDidLoad {
      [super viewDidLoad];
  // Do any additional setup after loading the view, typically from a nib.
    NSLog(@"call this one2");
 }

 - (void)viewDidAppear:(BOOL)animated
 {
   [super viewDidAppear:animated];
   NSManagedObjectContext *managedObjectContext = [self 
   managedObjectContext];
   NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] 
   initWithEntityName:@"Details"];
   self.dataList = [[managedObjectContext executeFetchRequest:fetchRequest   
   error:nil] mutableCopy];
   [_coreDataList reloadData];

    NSLog(@"call this one");
 }
    #pragma mark - Table view data source

   - (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView
   {
     return 1;
   }

     - (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:
   (NSInteger)section
    {
    return self.dataList.count;
    }

   - (UITableViewCell *)tableView:(UITableView *)tableView 
   cellForRowAtIndexPath:(NSIndexPath *)indexPath
   {
   static NSString *CellIdentifier = @"Cell";
   UITableViewCell *cell = [tableView     
   dequeueReusableCellWithIdentifier:CellIdentifier];

     if (cell == nil)
    {
    cell = [[UITableViewCell   
    alloc]initWithStyle:UITableViewCellStyleSubtitle 
    reuseIdentifier:CellIdentifier];
    }

   NSManagedObject *user = [self.dataList objectAtIndex:indexPath.row];
   cell.textLabel.text = [user valueForKey:@"name"];
      cell.detailTextLabel.text = [user valueForKey:@"mobileNumber"];
    cell.imageView.image = [UIImage imageWithData:[user
    valueForKey:@"imageView"]]; 
    return cell;
    }


    - (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:
    (NSIndexPath *)indexPath
    {
    indexPathvalue = indexPath.row;
    [self performSegueWithIdentifier:@"detailView" sender:self];
    }

     - (BOOL)tableView:(UITableView *)tableView canEditRowAtIndexPath:
    (NSIndexPath *)indexPath
    {
     return YES;
     }
     - (void)tableView:(UITableView *)tableView commitEditingStyle:
      (UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:
     (NSIndexPath *)indexPath
    {
    NSManagedObjectContext *context = [self managedObjectContext];
    if (editingStyle == UITableViewCellEditingStyleDelete)
    {
    [context deleteObject:[self.dataList objectAtIndex:indexPath.row]];
    NSError *error = nil;
    if (![context save:&error]) {
        NSLog(@"Can't Delete! %@ %@", error, [error localizedDescription]);
        return;
    }
    [self.dataList removeObjectAtIndex:indexPath.row];
    [_coreDataList reloadData];

     }

    }
   - (void)didReceiveMemoryWarning {
   [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
    }

   - (IBAction)addBtnClick:(id)sender {
    }


    #pragma mark - Navigation

    // In a storyboard-based application, you will often want to do a little      
    - (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender
     {
   // Get the new view controller using [segue destinationViewController].
   // Pass the selected object to the new view controller.
    if ([segue.identifier isEqualToString:@"detailView"])
   {
    NSManagedObject *obj = [self.dataList objectAtIndex:indexPathvalue];
    DetailViewController *detail = segue.destinationViewController;
    detail.userData = obj;
    }

    }
   @end

exemple de vue détaillée

       #import "DetailViewController.h"

       @interface DetailViewController ()

       @end

       @implementation DetailViewController

      - (NSManagedObjectContext *)managedObjectContext {
     NSManagedObjectContext *context = nil;
     id delegate = [[UIApplication sharedApplication] delegate];
     if ([delegate performSelector:@selector(managedObjectContext)]) {
    context = [delegate managedObjectContext];
     }
     return context;
    }

    - (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
     if (self.userData) {
    [self.nameTxt setText:[self.userData valueForKey:@"name"]];
    [self.mobileTxt setText:[self.userData valueForKey:@"mobileNumber"]];
    [self.emailIdTxt setText:[self.userData valueForKey:@"email"]];
    }
    }

     - (void)didReceiveMemoryWarning {
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
    }


   - (BOOL)textFieldShouldReturn:(UITextField *)textField
   {
    [textField resignFirstResponder];
    return YES;




}
     /*

savebutton

    - (IBAction)saveBtnClick:(id)sender {

     NSManagedObjectContext *context = [self managedObjectContext];

     if (self.userData) {
    // Update existing data
    [self.userData setValue:self.nameTxt.text forKey:@"name"];
    [self.userData setValue:self.mobileTxt.text forKey:@"mobileNumber"];
    [self.userData setValue:self.emailIdTxt.text forKey:@"email"];
    UIImage *sampleimage = [UIImage imageNamed:@"icon.png"];
    NSData *dataImage = UIImageJPEGRepresentation(sampleimage, 1.0);
    [self.userData setValue:dataImage forKey:@"imageView"];

     } else {
    // Create a new data
    NSManagedObject *newDevice = [NSEntityDescription   
    insertNewObjectForEntityForName:@"Details" 
    inManagedObjectContext:context];
    [newDevice setValue:self.nameTxt.text forKey:@"name"];
    [newDevice setValue:self.mobileTxt.text forKey:@"mobileNumber"];
    [newDevice setValue:self.emailIdTxt.text forKey:@"email"];
    UIImage *sampleimage = [UIImage imageNamed:@"icon.png"];
    NSData *dataImage = UIImageJPEGRepresentation(sampleimage, 1.0);
    [newDevice setValue:dataImage forKey:@"imageView"];

     }

     NSError *error = nil;
    // Save the object to persistent store
     if (![context save:&error]) {
    NSLog(@"Can't Save! %@ %@", error, [error localizedDescription]);
    }

    [self dismissViewControllerAnimated:YES completion:nil];
    }
   @end