IOS के लिए कोर डेटा। अध्याय संख्या 3। सैद्धांतिक भाग

हबरलायुदी, शुभ दोपहर!
आज मैं माइकल प्रिवैट और रॉबर्ट वार्नर "आईओएस के लिए प्रो कोर डेटा" पुस्तक पर व्यावहारिक अभ्यास के साथ व्याख्यान की एक श्रृंखला लिखना शुरू करना चाहता हूं, जिसे आप इस लिंक पर खरीद सकते हैं। प्रत्येक अध्याय में एक सैद्धांतिक और व्यावहारिक हिस्सा होगा।



सामग्री:

• अध्याय संख्या 1। आरंभ करना ( व्यावहारिक भाग )
• अध्याय संख्या 2। मास्टर कोर डेटा ( व्यावहारिक भाग )
• अध्याय संख्या 3। डेटा भंडारण: SQLite और अन्य विकल्प
• अध्याय संख्या 4। एक डेटा मॉडल बनाना
• अध्याय संख्या ५। डेटा ऑब्जेक्ट्स के साथ कार्य करना
• अध्याय संख्या 6। परिणाम सेट करना
• अध्याय संख्या 7। प्रदर्शन और स्मृति ट्यूनिंग
• अध्याय संख्या 8। संस्करण और प्रवासन
• अध्याय संख्या 9। NSFetchedResultsController का उपयोग कर तालिकाओं का प्रबंधन करें
• अध्याय संख्या 10। उन्नत अनुप्रयोगों में कोर डेटा का उपयोग करना

प्रविष्टि

इस अध्याय में, हम दो तालिकाओं और उनके बीच एक-से-कई संबंधों के साथ एक एप्लिकेशन बनाएंगे। कल्पना कीजिए कि आपने जूनियर फुटबॉल लीग और उनकी रचना से टीमों का पालन करने के लिए स्वेच्छा से काम किया। हमारे डेटा मॉडल में दो टेबल होंगे: टीम (टीम के नाम और उनके फॉर्म के रंग के बारे में जानकारी संग्रहीत करता है) और प्लेयर (टीम खिलाड़ी के बारे में जानकारी - मेलबॉक्स, नाम और उपनाम)। यह स्पष्ट है कि एक टीम में कई खिलाड़ी होते हैं, और खिलाड़ी एक टीम से संबंधित होता है।
हम पहले SQLite का उपयोग करके एक रिपॉजिटरी के रूप में इस एप्लिकेशन को बनाएंगे, और फिर हम अन्य विकल्पों (मेमोरी में स्टोरेज और आर्बिटरी रिपॉजिटरी (परमाणु स्टोर)) का उपयोग करने का प्रयास करेंगे।

इंटरफ़ेस

हम अपने एप्लिकेशन लीग मैनेजर को कॉल करेंगे और इसमें 4 स्क्रीन शामिल होंगे:

• टीम सूची
• टीम जोड़ें / संपादित करें
• खिलाड़ी सूची
• प्लेयर जोड़ें / संपादित करें

टीमों की सूची वाली एक स्क्रीन स्थानीय रूप से सहेजी गई फ़ुटबॉल टीमों को उनके फ़ॉर्म के रंगों के साथ प्रदर्शित करती है। हटाने के लिए एक नया आदेश और एक Edit बटन जोड़ने के लिए स्क्रीन पर एक + बटन है। यह स्क्रीन जैसा दिखता है:


एक फुटबॉल टीम के लिए एड / एडिट स्क्रीन में टीम के नाम और उनके फॉर्म के रंग में प्रवेश के लिए दो फ़ील्ड होते हैं। यह स्क्रीन एक नई कमांड जोड़ने के लिए "कमांड की सूची" स्क्रीन पर + बटन दबाने के बाद प्रदर्शित होती है, या जब आप इसे संपादित करने के लिए सूची में से किसी एक कमांड पर क्लिक करते हैं।


खिलाड़ियों की सूची वाली स्क्रीन एक निश्चित टीम के सभी खिलाड़ियों को प्रदर्शित करती है। प्रत्येक आदेश के विपरीत "आदेशों की सूची" पर नीले तीर पर क्लिक करने के बाद इस स्क्रीन पर परिवर्तन किया जाता है:


टीमों के साथ, जब आप + पर क्लिक करते हैं, तो टीम में एक नए खिलाड़ी को जोड़ने की स्क्रीन दिखाई देती है, और जब आप Edit पर क्लिक करते हैं Edit तो आप खिलाड़ी के बारे में जानकारी संपादित कर सकते हैं।


अब जब हम जानते हैं कि हमें क्या करना है, हम आगे बढ़ सकते हैं।

SQLite का उपयोग एक भंडार के रूप में

Hcode चलाएं और एक नया प्रोजेक्ट बनाएं।


हम इसे लीगमैन कहते हैं और कंपनी पहचानकर्ता के रूप में book.coredata लिखते हैं।


प्रोजेक्ट बनाने के बाद:


एप्लिकेशन बनाने के इस चरण में, सबसे महत्वपूर्ण घटक और भाग एक डेटा मॉडल का निर्माण है। ओपन *.xcdatamodeld में:


मौजूदा Event इकाई को हटाएं ( Delete कुंजी दबाएं), जो हमारे लिए उपयोगी नहीं होगी।

Team इकाई बनाकर शुरू करते हैं:


Team इकाई के लिए दो विशेषताएँ बनाएँ:

• नाम (स्ट्रिंग)
• वर्दी रंग (स्ट्रिंग)

हमें निम्न चित्र मिलते हैं:


एक विशेषता प्रकार को एक साथ कई विशेषताओं पर सेट करने के लिए, आपको बस उन्हें चुनना होगा और दाईं ओर सही प्रकार का चयन करना होगा:


इसके बाद, तीन विशेषताओं के साथ एक Player इकाई बनाएँ:

• पहला नाम (स्ट्रिंग)
• अंतिम नाम (स्ट्रिंग)
• ईमेल (स्ट्रिंग)

एक से कई रिश्ते

Team और Player संस्थाओं के बीच एक नया संबंध बनाने के लिए, आपको पहले Team इकाई का चयन करना होगा और Relationships अनुभाग में + क्लिक करें और नए खिलाड़ियों के संघ का नाम दें Destination Player इकाई का चयन करें। दाईं ओर, चयनित खिलाड़ियों के लिंक के साथ "टू-कई रिलेशनशिप" ध्वज सेट करें। Cascade को विलोपन नियम के रूप में चुनें (जब कोई टीम हटा दी जाती है, तो सभी टीम के खिलाड़ी स्वचालित रूप से हटा दिए जाएंगे)


अब आपको खिलाड़ी ( Player इकाई) की तरफ से एक कनेक्शन बनाने की आवश्यकता है। हम Destination क्षेत्र में team नामक रिश्ते के लिए एक Player इकाई जोड़ते हैं, Team चयन करते हैं, और Invers फ़ील्ड में Invers players चयन players (उसके बाद, Team इकाई के players रिश्ते के लिए Inverse क्षेत्र सेट करना न भूलें)

उपयोगकर्ता इंटरफ़ेस निर्माण

डेटा मॉडल के निर्माण को पूरा करने के बाद, आपको इस डेटा को प्रदर्शित करने के लिए कोड लिखना होगा। एचकेओडी स्वचालित रूप से आदेशों की सूची प्रदर्शित करने के लिए सभी आवश्यक कोड उत्पन्न करता है; अगला कार्य Team संस्थाओं के साथ काम करने के लिए इसे थोड़ा समायोजित करना होगा, Event नहीं।

हमें रिपॉजिटरी में कमांड जोड़ने के लिए एक विधि की आवश्यकता है, चलो इसे MasterViewController.m फाइल में MasterViewController.m हैं, पहले MasterViewController.h में इसका वर्णन करना भूल जाते हैं।
MasterViewController.h में कोड अब इस तरह दिखता है:

 #import <UIKit/UIKit.h> #import <CoreData/CoreData.h> @interface MasterViewController : UITableViewController <NSFetchedResultsControllerDelegate> @property (nonatomic, strong) NSFetchedResultsController *fetchedResultsController; @property (nonatomic, strong) NSManagedObjectContext *managedObjectContext; - (void)insertTeamWithName:(NSString *)name uniformColor:(NSString *)uniformColor; - (void)saveContext; @end 

MasterViewController.m खोलें और स्क्रीन नाम को निम्नानुसार समायोजित करें:

 self.title = NSLocalizedString(@"League Manager", @"League Manager"); 

अब हम एक नई कमांड जोड़ने की विधि को लागू करते हैं:

 - (void)insertTeamWithName:(NSString *)name uniformColor:(NSString *)uniformColor { NSManagedObjectContext *context = [self.fetchedResultsController managedObjectContext]; NSEntityDescription *entity = [[self.fetchedResultsController fetchRequest] entity]; NSManagedObject *newManagedObject = [NSEntityDescription insertNewObjectForEntityForName:[entity name] inManagedObjectContext:context]; [newManagedObject setValue:name forKey:@"name"]; [newManagedObject setValue:uniformColor forKey:@"uniformColor"]; [self saveContext]; } 

अब हम निम्नलिखित सामग्री के साथ एक पंक्ति पाते हैं:

 NSEntityDescription *entity = [NSEntityDescription entityForName:@"Event" inManagedObjectContext:self.managedObjectContext]; 

और इसके साथ बदलें:

 NSEntityDescription *entity = [NSEntityDescription entityForName:@"Team" inManagedObjectContext:self.managedObjectContext]; 

अगला, आपको मौजूदा कोड में एक और छोटा परिवर्तन करने की आवश्यकता है, इस पंक्ति को प्रतिस्थापित करें:

 NSSortDescriptor *sortDescriptor = [[NSSortDescriptor alloc] iniWithKey:@"timestamp" ascending:NO]; 

पर:

 NSSortDescriptor *sortDescriptor = [[NSSortDescriptor alloc] iniWithKey:@"name" ascending:NO]; 

एक नई वस्तु बनाने के बाद, हमने इसके गुणों को उन मानों के लिए निर्धारित किया है जो पारित किए गए थे:

  [newManagedObject setValue:name forKey:@"name"]; [newManagedObject setValue:uniformColor forKey:@"uniformColor"]; 

ऑब्जेक्ट के गुणों को बदलने के बाद, हमें इसे बचाने की आवश्यकता है, इसलिए saveContext विधि को saveContext ।

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

हम इस प्रकार एक और विधि को ठीक करेंगे:

 - (void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath { if (editingStyle == UITableViewCellEditingStyleDelete) { [self saveContext]; } } 

टेबल सेटिंग

टेबल सेल को आवश्यक संस्थाओं के बजाय Event एंटिटीज़ को प्रदर्शित करने के लिए अभी भी कॉन्फ़िगर किया गया है। हमें तालिका के एक सेल में दो घटकों को प्रदर्शित करने की आवश्यकता है: टीम का नाम और फॉर्म का रंग जिसमें यह टीम खेलती है। इसे प्राप्त करने के लिए, आपको पहले प्रदर्शित तालिका सेल की शैली को बदलना होगा, साथ ही cellForRowAtIndexPath: उपयोग CellIdentifier cellForRowAtIndexPath: विधि में किया जाना चाहिए।
इस पंक्ति को बदलें:

 static NSString* CellIdentifier = @"Cell"; 

पर:

 static NSString* CellIdentifier = @"TeamCell"; 

और हम निम्न से निर्मित कोशिकाओं के प्रकार को बदलते हैं:

 cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier]; 

पर:

 cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleValue1 reuseIdentifier:CellIdentifier]; 

एक configureCell:atIndexPath: जनरेट किए गए कोड में विधि, जिसमें सेल खुद को डिस्प्ले के लिए कॉन्फ़िगर किया गया है। लेकिन अपने वर्तमान रूप में, विधि Team साथ काम करती है, Team नहीं, इसलिए कुछ समायोजन करने की आवश्यकता है।

 - (void)configureCell:(UITableViewCell *)cell atIndexPath:(NSIndexPath *)indexPath { NSManagedObject *managedObject = [self.fetchedResultsController objectAtIndexPath:indexPath]; cell.textLabel.text = [[managedObject valueForKey:@"name"] description]; cell.detailTextLabel.text = [[managedObject valueForKey:@"uniformColor"] description]; cell.accessoryType = UITableViewCellAccessoryDetailDisclosureButton; } 

टीम बिल्डिंग

अब तक, हमारा आवेदन बहुत कम है। यह एक टीम नहीं बना सकता है, एक खिलाड़ी नहीं बना सकता है। अब यह सुनिश्चित करने के लिए आवेदन चलाने का सही समय है कि हम सही रास्ते पर हैं और सब कुछ काम करता है। यदि किसी कारण से एप्लिकेशन बनाते समय आपके पास त्रुटियां हैं, तो सभी चरणों के माध्यम से फिर से जाने की कोशिश करें, डेटा मॉडल का पुन: परीक्षण करें।

जब आप Master-Details View Application टेम्पलेट से कोई एप्लिकेशन बनाते हैं, तो एक और नियंत्रक को DetailViewController कहा जाता है। आप इस वर्ग का उपयोग कर सकते हैं, लेकिन चूंकि हमें टीम और खिलाड़ियों के बारे में जानकारी प्रदर्शित करने की आवश्यकता है, इसलिए इस नियंत्रक से छुटकारा पाने और संबंधित नामों के साथ नए नियंत्रक बनाने के लिए बेहतर है।
#import DetailViewController.h से लाइन #import DetailViewController.h निकालें। tableView:didSelectRowAtIndexPath: विधि और इसके शरीर को शुद्ध करें। यह इस तरह दिखता है:

 - (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath { } 

फिर हम सभी तीन DetailViewController (.h, .m, .xib) को सुरक्षित रूप से हटा सकते हैं। यदि हम एप्लिकेशन लॉन्च करते हैं और + बटन पर क्लिक करते हैं, तो एप्लिकेशन क्रैश हो जाता है। यह + अभी भी insertNewObject: गया है। हमें इस बटन के लिए एक नई टीम बनाने की क्षमता संलग्न करने की आवश्यकता है, या बल्कि, नई टीम के बारे में जानकारी (टीम का नाम और फॉर्म रंग) दर्ज करने के लिए फ़ील्ड के साथ एक मोडल विंडो दिखाएं। जब आप किसी सेल पर कमांड स्क्रीन की सूची पर कमांड के साथ क्लिक करते हैं, तो उसी विंडो का उपयोग मौजूदा कमांड को संपादित करने के लिए किया जाएगा।
हम एक नया वर्ग बनाते हैं, हमारी कक्षा का जनक UIViewController :

हम इस वर्ग को TeamViewController कहेंगे और With XIB for user interface विकल्प के With XIB for user interface जांच करना न भूलें।


Open TeamViewController.h खोलें। लीग मैनेजर में, MasterViewController क्लास NSManagedObjectContext प्रबंधन करता है, इसलिए TeamViewController को इस ऑब्जेक्ट प्रबंधन वातावरण और संबंधित इनिशियलाइज़ेशन विधि के संदर्भ की आवश्यकता होगी। चूंकि यह नियंत्रक कमांड के बारे में जानकारी संपादित करने के लिए भी ज़िम्मेदार होगा, यह आरंभीकरण के दौरान कमांड ऑब्जेक्ट को पारित करने के लायक है (इसके लिए हमें एक संपत्ति बनाने और इसे इनिशियलाइज़ेशन विधि में जोड़ने की आवश्यकता होगी)। ऐड / एडिट स्क्रीन के यूजर इंटरफेस में दो टेक्स्ट फील्ड होंगे - टीम के नाम और उनके फॉर्म के रंग के लिए, आपको टीम TeamViewController में उनके लिए उपयुक्त प्रॉपर्टी बनाने की जरूरत है। इस स्क्रीन पर दो बटन भी होंगे - नए कमांड के लिए सेव बटन और कैंसल बटन। TeamViewController पास इन बटनों पर क्लिक करने के लिए हैंडलर विधियाँ होनी चाहिए।

TeamViewController.h

 #import <UIKit/UIKit.h> @class MasterViewController; @interface TeamViewController : UIViewController { IBOutlet UITextField *name; IBOutlet UITextField *uniformColor; NSManagedObject *team; MasterVIewController *masterController; } @property (nonatomic, retain) UITextField *name; @property (nonatomic, retain) UITextField *uniformColor; @property (nonatomic, retain) NSManagedObject *team; @property (nonatomic, retain) MasterViewController *masterController; - (IBAction)save:(id)sender; - (IBAction)cancel:(id)sender; - (id)initWithMasterController:(MasterViewController *)aMasterController team:(NSManagedObject *)aTeam; @end 

Open TeamViewController.m खोलें, MasterViewController.h आयात MasterViewController.h , initWithNibName: हटाएँ initWithNibName: , name , team और masterController लिए सिंथेसाइज़ जोड़ें। यह आरंभ विधि जोड़ें:

 - (id)initWithMasterController:(MasterController *)aMasterController team:(NSManagedObject *)aTeam { if((self = [super init])){ self.masterController = aMasterController; self.team = aTeam; } return self; } 

यदि एप्लिकेशन उपयोगकर्ता एक नई टीम बनाना चाहता है, तो aTeam पैरामीटर शून्य हो जाएगा, और एक नया NSManagedObject ऑब्जेक्ट बनाने के लिए TeamViewController.m नियंत्रक जिम्मेदार होगा। यदि उपयोगकर्ता संपादन के लिए मौजूदा कमांडों में से एक का चयन करता है, तो कंट्रोलर कमांड ऑब्जेक्ट (कमांड नाम और फॉर्म रंग) से संबंधित डेटा के साथ स्क्रीन पर पाठ फ़ील्ड में भरने के लिए जिम्मेदार रहता है। हम अंतिम कार्यक्षमता को viewDidLoad विधि में जोड़ देंगे:

 - (void)viewDidLoad{ [super viewDidLoad]; if(team != nil){ name.text = [team valueForKey:@"name"]; uniformColor.text = [team valueForKey:@"uniformColor"]; } } 

अब यह सहेजें और रद्द करें बटन पर क्लिक करने पर ईवेंट हैंडलर्स को लागू करने के लिए रहता है:

 - (IBAction)save:(id)sender { if(masterController != nil){ if(team != nil){ [team setValue:name.text forKey:@"name"]; [team setValue:uniformColor.text forKey:@"uniformColor"]; [masterController saveContext]; } else { [masterController insertNewTeamWithName:name.text uniformColor:uniformColor.text]; } } [self dismissModalViewControllerAnimated:YES]; } 

cancel: करने की विधि cancel: बस संपादित करें / कमांड विंडो जोड़ें।
TeamViewController.m

 #import "TeamViewController.h" #import "MasterViewController.h" @implementation TeamViewController @synthesize name; @synthesize uniformColor; @synthesize team; @synthesize masterController; - (id)initWithMasterController:(MasterController *)aMasterController team:(NSManagedObejct *)aTeam { if((self = [super init])){ self.masterController = aMasterController; self.team = aTeam; } return self; } - (void)didReceiveMemoryWarning{ [super didReceiveMemoryWarning]; } #pragma mark - View lifecycle - (void)viewDidLoad{ [super viewDidLoad]; if(team != nil){ name.text = [team valueForKey:@"name"]; uniformColor.text = [team valueForKey:@"uniformColor"]; } } - (void)viewDidUnload{ [super viewDidUnload]; } - (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation { return (interfaceOrientation == UIInterfaceOrientationPortrait); } #pragma mark - Button handlers - (IBAction)save:(id)sender{ if(masterController != nil){ if(team != nil){ [team setValue:name.text forKey:@"name"]; [team setValue:uniformColor.text forKey:@"uniformColor"]; [masterController saveContext]; } else { [masterController insertTeamWithName:name.text uniformColor:uniformColor.text]; } } [self dismissModalViewControllerAnimated:YES]; } - (IBAction)cancel:(id)sender{ [self dismissModalViewControllerAnimated:YES]; } @end 

उपयोगकर्ता इंटरफ़ेस तत्वों के साथ बातचीत करने के लिए कोड लिखे जाने के बाद, हम वास्तव में इस उपयोगकर्ता इंटरफ़ेस को स्वयं बनाना शुरू कर सकते हैं। हम TeamViewController.xib खोलते हैं, यह शुरू में हमसे खाली होना चाहिए। हमने दो लेबल, दो टेक्स्ट इनपुट फ़ील्ड और दो बटन सेट किए हैं, हम बटन की क्रियाओं को संबंधित हैंडलर विधियों से जोड़ते हैं। अंतिम दृश्य कुछ इस प्रकार है:


निष्पादन के लिए आवेदन शुरू करने से पहले, आइए MasterViewController वापस MasterViewController और कमांड के बारे में जानकारी के साथ स्क्रीन प्रदर्शित करने के लिए कोड जोड़ें। हमें दो मामलों में कमांड संपादन स्क्रीन प्रदर्शित करनी चाहिए: 1) उपयोगकर्ता ने + 2) क्लिक किया उपयोगकर्ता ने सूची से एक कमांड पर क्लिक किया। + बटन पर क्लिक करके शुरू करते हैं। MasterViewController.h में एक नई विधि घोषित करें:

 - (void)showTeamView; 

MasterViewController.m जाएं, TeamViewController.h आयात करें और उपरोक्त विधि को निम्नानुसार लागू करें:

 - (void)showTeamView{ TeamViewController *teamViewController = [[TeamViewController alloc] initWithMasterController:self team:nil]; [self presentModalViewController:teamViewController animated:YES]; } 

अब यह कार्रवाई के लिए "लिंक" को दबाए रखता है। viewDidLoad विधि पर जाएं और इस कोड को बदलें:

 UIBarButtonItem *addButton = [[UIBarButtonItem alloc] initWithBarButtonSystemItem:UIBarButtonSystemItemAdd target:self action:@selector(insertNewObject)]; 

इस एक पर:

 UIBarButtonItem *addButton = [[UIBarButtonItem alloc] initWithBarButtonSystemItem:UIBarButtonSystemItemAdd target:self action:@selector(showTeamView)]; 

इस स्तर पर, एप्लिकेशन पहले से ही कमांड बना सकता है, लेकिन निष्पादन के लिए आवेदन शुरू करने से पहले, मैं तुरंत कमांड संपादित करने के लिए कोड जोड़ने का सुझाव देता हूं:

 - (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath)indexPath{ NSManagedObject *team = [[self fetchedResultsController] objectAtIndexPath:indexPath]; TeamViewController *teamViewController = [[TeamViewController alloc] initWithMasterController:self team:team]; [self presentModalViewController:teamViewController animated:YES]; } 

चलाने के लिए एप्लिकेशन चलाएँ:


अब हम कमांड जोड़ सकते हैं, उन्हें संपादित कर सकते हैं। कुछ कमांड जोड़ें, सूची में उन्हें लेक्सिकोग्राफिक क्रम में क्रमबद्ध किया जाएगा।



आप देख सकते हैं कि हम खाली नामों वाली टीम बना सकते हैं या रंग बना सकते हैं। यदि यह एक वास्तविक एप्लिकेशन था, तो हमें खराब उपयोगकर्ता डेटा से कुछ सुरक्षा उपाय करने की आवश्यकता है। हमने डेटा सत्यापन के साथ जानबूझकर ऐसी "गलती" छोड़ दी है, क्योंकि अध्याय 5 में हम डेटा सत्यापन के तरीकों का अध्ययन करेंगे।
एप्लिकेशन को बंद करें, फिर से शुरू करें ... अपने काम का आनंद लें ... लेकिन, हमने केवल टीमों के साथ काम करना समाप्त कर दिया है, और अभी भी खिलाड़ियों के साथ काम करना बाकी है। यह हम अगले भाग में करेंगे।

प्लेयर प्रबंधन उपयोगकर्ता इंटरफ़ेस

खिलाड़ी प्रबंधन उपयोगकर्ता इंटरफ़ेस को लागू करने के लिए, हमें दो स्क्रीन और संबंधित नियंत्रकों की आवश्यकता होती है: एक टीम में खिलाड़ियों की सूची प्रदर्शित करने के लिए, और दूसरा एक नए खिलाड़ी को जोड़ने या किसी मौजूदा को संपादित करने के लिए। अधिकांश भाग के लिए ये नियंत्रक आदेशों के साथ काम करने के लिए नियंत्रित किए गए नियंत्रक हैं, हालांकि उनके पास NSFetchedResultsController और कोर डेटा के साथ काम करने के लिए कोड के बाकी नहीं हैं, इसके बजाय वे कोर डेटा MasterViewController साथ बातचीत को MasterViewController ।

सबसे पहले, टीम के खिलाड़ियों की सूची प्रदर्शित करने के लिए एक नियंत्रक और एक स्क्रीन बनाएं। हम एक नया PlayerListViewController नियंत्रक बनाते हैं, इसका मूल वर्ग UITableViewController सेट करते हैं और "यूजर इंटरफेस के लिए XIB के साथ" विकल्प को अनचेक करते हैं। फ़ाइल खोलें PlayerListViewController.h । यह वर्ग टीम के खिलाड़ियों की सूची प्रदर्शित करने के लिए जिम्मेदार है, जिसका अर्थ है कि इस वर्ग में टीम ऑब्जेक्ट का लिंक आवश्यक है। इसके अलावा, इस तथ्य को देखते हुए कि यह वर्ग MasterViewController को कोर डेटा के साथ बातचीत को MasterViewController , नियंत्रक के लिए एक लिंक भी आवश्यक है।
नए खिलाड़ी को जोड़ने के लिए स्क्रीन पर एक + बटन होगा। इसी क्लिक हैंडलर विधि की घोषणा करें।

PlayerListViewController.h

 #import <UIKit/UIKit.h> @class MasterViewController; @interface PlayerListViewController : UITableVIewController { NSManagedObject *team; MasterViewController *masterViewController; } @property (nonatomic, retain) NSManagedObject *team; @property (nonatomic, retain) MasterViewController *masterController; - (id)initWithMasterController:(MasterViewController *)aMasterController team:(NSManagedObject *)aTeam; - (void)showPlayerView; - (NSArray *)sortPlayers; @end 

PlayerListViewController.m फ़ाइल खोलें और PlayerListViewController.m आयात MasterVIewController.h , team और masterController संश्लेषित करें। उत्पन्न initWithStyle: बदलें initWithStyle: initWithMasterController: जो दो गुणों और स्टोरों को स्वीकार करता है:

 - (id)initWithMasterController:(MasterVIewController *)aMasterVIewController team:(NSManagedObject *)aTeam { if((self = [super init])){ self.masterController = aMasterController; self.team = aTeam; } return self; } 

स्वचालित रूप से जेनरेट किया गया viewDidLoad विधि इस प्रकार viewDidLoad गया है:

 - (void)viewDidLoad{ [super viewDidLoad]; self.title = @"Player"; UIBarButtonItem *addButton = [[UIBarButtonItem alloc] initWithBarButtonSystemItem:UIBarButtonSystemItemAdd target:self action:@selector(showPlayerView)]; self.navigationItem.rightBarButtonItem = addButton; } 

और अभी के लिए, showPlayerView खाली छोड़ दें:

 - (void)showPlayerView{ } 

व्यूप्लेयर विधि को समायोजित करें: इस प्रकार है:

 - (void)viewWillAppear:(BOOL)animated{ [super viewWillAppear:animated]; [self.tableView reloadData]; } 

तालिका में खिलाड़ियों की सूची को एकल खंड (अनुभाग) में वर्णानुक्रम से क्रमबद्ध किया जाएगा। सभी टीम के खिलाड़ियों की सूची प्राप्त करने के लिए, आपको valueForKey:@"players" को कॉल करना valueForKey:@"players" टीम ऑब्जेक्ट का तरीका, जो NSSet* खिलाड़ियों को हमारे पास लौटा देगा। नीचे तालिका का प्रदर्शन सेट करने के लिए कोड है:

 - (NSUInteger)numberOfSectionInTableView:(UITableView *)tableView { return 1; } - (NSInteger)tableView:(UITableVIew *)tableView numberOfRowsInSection:(NSInteger)section { return [(NSSet *)[team valueForKey:@"players"] count]; } - (UITableViewCell *)tableView:(UITableVIew *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath { static NSString *CellIdentifier = @"PlayerCell"; UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier]; if(cell == nil){ cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleValue1 reuseIdentifier:CellIdentifier]; } NSManagedObject *player = [[self sortPlayers] objectAtIndex:indexPath.row]; cell.textLabel.text = [NSString stringWithFormat:@"%@ %@", [[player valueForKey:@"firstName"] description], [[player valueForKey:@"lastName"] description]]; cell.detailTextLabel.text = [[player valueForKey:@"email"] description]; return cell; } 

इसके बाद sortPlayers विधि के लिए एक कॉल है, जो खिलाड़ियों की एक क्रमबद्ध सरणी देता है:

 - (NSArray *)sortPlayers{ NSSortDescriptor *sortLastNameDescriptor = [[NSSortDescriptor alloc] initWithKey:@"lastName" ascending:YES]; NSArray *sortDescriptors = [NSArray arrayWithObjects:sortLastNameDescriptor, nil]; return [[(NSSet *)[team valueForKey:@"players"] allObjects] sortedArrayUsingDescriptors:sortDescriptors]; } 

टीम के खिलाड़ियों की सूची प्रदर्शित करने के लिए, हम MasterViewController.m पर लौटेंगे और एक ऐसा तरीका जोड़ेंगे जो अतिरिक्त एक्सेसरी (ब्लू सेल एलिमेंट) पर क्लिक करने में सक्षम होगा:

 - (void)tableView:(UITableVIew *)tableView accessoryButtonTappedForRowWithIndexPath:(NSIndexPath *)indexPath{ NSManagedObject *team = [self.fetchedResultsController objectAtIndexPath:indexPath]; PlayerListViewController *playerListViewController = [[PlayerListViewController alloc] initWithMasterController:self team:team]; [self.navigationController pushViewController:playerListViewController animated:YES]; } 

PlayerListViewController.h के आयात को PlayerListViewController.h में MasterViewController.m । अब एप्लिकेशन को इकट्ठा करें और चलाएं। टीमों की सूची में हम उन टीमों को देखते हैं जिन्हें हमने पहले बनाया था, जब आप एक्सेसरी बटन पर क्लिक करते हैं, तो चयनित टीम के खिलाड़ियों की सूची खुलती है (जब तक कि खिलाड़ी सूची खाली नहीं होती है, क्योंकि हमने एक नए खिलाड़ी को शामिल नहीं किया है)।

खिलाड़ियों को जोड़ें, संपादित करें और हटाएं

आवेदन लगभग तैयार है; लागू करने लायक एकमात्र चीज खिलाड़ियों को जोड़ना / संपादित करना / हटाना है।
उपयुक्त XIB के साथ एक नया नियंत्रक ( UIViewController ) बनाएं और इसे PlayerViewController । यह TeamViewController समान होगा, लेकिन इसमें तीन फ़ील्ड होंगे: lastName , firstName और email । नियंत्रक में MasterViewController एक लिंक भी होता है ताकि कोर डेटा के साथ काम करने के लिए पहले से लिखी गई विधियों का उपयोग किया जा सके। दो और गुण भी मौजूद होंगे: वह टीम जिसमें खिलाड़ी खेलता है और खिलाड़ी खुद। यदि खिलाड़ी ऑब्जेक्ट nil , तो PlayerViewController जानता है कि एक नया खिलाड़ी बनाना आवश्यक है, अन्यथा, खिलाड़ी के डेटा को संपादित करना। स्क्रीन पर हमारे पास तीन बटन होंगे: सेव, कैंसिल और डिलीट। किसी खिलाड़ी को हटाने का अनुरोध करते समय, हम उपयोगकर्ता से PlayerViewController प्रदर्शन के रूप में पुष्टि करने के लिए कहेंगे, इसलिए यह आवश्यक है कि PlayerViewController प्रोटोकॉल UIActionSheetDelegate लागू करता है।

PlayerViewController.h

 #import <UIKit/UIKit.h> @class MasterViewController; @interface PlayerViewController : UIViewController <UIActionSheetDelegate> { IBOutlet UITextField *firstName; IBOutlet UITextField *lastName; IBOutlet UITextField *email; NSManagedObject *team; NSManagedObject *player; MasterViewController *masterViewController; } @property (nonatomic, retain) UITextField *firstName; @property (nonatomic, retain) UITextField *lastName; @property (nonatomic, retain) UITextField *email; @property (nonatomic, retain) NSManagedObject *team; @property (nonatomic, retain) NSManagedObject *player; @property (nonatomic, retain) MasterViewController *masterController; - (IBAction)save:(id)sender; - (IBAction)cancel:(id)sender; - (IBAction)confirmDelete:(id)sender; - (id)initWithMasterController:(MasterViewController *)aMasterController team:(NSManagedObject *)aTeam player:(NSManagedObject *)aPlayer; @end 

अब PlayerViewController.m खोलें, PlayerViewController.m आयात MasterViewController.h और इंटरफ़ेस से सभी गुणों के लिए @synthesize जोड़ें।एक आरंभिक विधि जोड़ें जो PlayerVIewController.mवर्ग MasterViewController, कमांड और संभवतः एक खिलाड़ी ऑब्जेक्ट का एक उदाहरण प्राप्त करेगा ।

 - (id)initWithMasterController:(MasterViewController *)aMasterController team:(NSManagedObject *)aTeam player:(NSManagedObject *)aPlayer{ if((self = [super init])){ self.masterController = aMasterController; self.team = team; self.player = player; } return self; } 

viewDidLoadखिलाड़ी के डेटा के साथ पाठ फ़ील्ड में भरने के लिए विधि में एक कोड जोड़ें , अगर यह बराबर नहीं है nil।

 - (void)viewDidLoad { [super viewDidLoad]; if(player != nil){ firstName.text = [player valueForKey:@"firstName"]; lastName.text = [player valueForKey:@"lastName"]; email.text = [player valueForKey:@"email"]; } } 

हमारा अगला कदम बटन क्लिक हैंडलर विधियों का कार्यान्वयन होगा:

 - (IBAction)save:(id)sender{ if(masterController != nil){ if(player != nil){ [player setValue:firstName.text forKey:@"firstName"]; [player setValue:lastName.text forKey:@"lastName"]; [player setValue:email.text forKey:@"email"]; } else { [masterController insertPlayerWithTeam:team firstName:firstName.text lastName:lastName.text email:email.text]; } } [self dismissModelViewControllerAnimated:YES]; } - (IBAction)cancel:(id)sender{ [self dismissModalViewControllerAnimated:YES]; } 

insertPlayerWithTeam:firstName:lastName:email:नियंत्रक में MasterViewControllerकोई विधि अभी तक नहीं है, लेकिन हम इसे कुछ मिनटों में शाब्दिक रूप से लिखेंगे। सबसे पहले, हम उस confirmDelete:विधि को लागू करते हैं जिसे "हटाएं" बटन पर क्लिक करने पर कहा जाता है। यह विधि तुरंत खिलाड़ी को नहीं हटाएगी, लेकिन यह उपयोगकर्ता को इस कार्रवाई के निष्पादन पर पुष्टि करने के लिए कहेंगी (यह आकस्मिक क्लिक और खिलाड़ियों के विलोपन से बचने के लिए किया जाता है)। यहाँ क्या विधि की तरह दिखेगा confirmDelete::

 - (IBAction)confirmDelete:(id)sender{ if(player != nil){ UIActionSheet *confirm = [[UIActionSheet alloc] initWithTitle:nil delegate:self cancelButtonTitle:@"Cancel" destructiveButtonTitle:@"Delete Player" otherButtonTitles:nil]; confirm.actionSheetStyle = UIActionSheetStyleBlackTranslucent; [confirm showInView:self.view]; } } 

जो प्रतिनिधि कार्रवाई UIActionSheetकरेगा, वह वर्तमान वर्ग होगा। जब आप बटन पर क्लिक करते हैं, तो UIActionSheetविधि को बुलाया जाएगा clickedButtonAtIndex:, जिसका अर्थ है कि आपको इसे लागू करने की आवश्यकता है। विधि यह जांचेगी कि कौन सा बटन दबाया गया था और यदि हटाएं बटन, खिलाड़ी को हटाने के लिए विधि (जिसे हम बाद में लागू करेंगे) कहा जाएगा:

 - (void)actionSheet:(UIActionSheet *)actionSheet clickedButtonAtIndex:(NSInteger)buttonIndex{ if(buttonIndex == 0 && masterController != nil){ [masterController deletePlayer:player]; [self dismissModalViewControllerAnimated:YES]; } } 

आइए MasterViewController.hहम उन दो तरीकों की घोषणा करते हैं, जिन्हें हमने अभी तक लागू नहीं किया है, लेकिन पहले ही उपयोग कर चुके हैं:

 - (void)insertPlayerWithTeam:(NSManagedObject *)team firstName:(NSString *)firstName lastName:(NSString *)lastName email:(NSString *)email; - (void)deletePlayer:(NSManagedObject *)player; 

अब MasterViewController.mविधियों को खोलें और कार्यान्वित करें:

 - (void)insertPlayerWithTeam:(NSManagedObject *)team firstName:(NSString *)firstName lastName:(NSString *)lastName email:(NSString *)email{ NSManagedObjectContext *context = [self.fetchedResultsController managedObjectContext]; NSManagedObject *player = [NSEntityDescription insertNewObjectForEntityForName:@"Player" inManagedObjectContext:context]; [player setValue:firstName forKey:@"firstName"]; [player setValue:lastName forKey:@"lastName"]; [player setValue:email forKey:@"email"]; [player setValue:team forKey:@"team"]; [self saveContext]; } - (void)deletePlayer:(NSManagedObject *)player{ NSManagedObjectContext *context = [self.fetchedResultsController managedObjectContext]; [context deleteObject:player]; [self saveContext]; } 

अंतिम चरण खिलाड़ी को जोड़ने / संपादित करने के लिए एक कस्टम स्क्रीन बनाना है। चयन करें PlayerViewController.xib, इसे नीचे दी गई तस्वीर में दिखाए गए फॉर्म में लाएं और सभी क्रियाओं को संबंधित बटन के साथ कनेक्ट करें।


इस स्क्रीन को प्रदर्शित करने के लिए, उस पद्धति के कार्यान्वयन पर वापस लौटना आवश्यक है showPlayerView:जिसका हमने पहले उपयोग किया था। एक PlayerListViewController.mफ़ाइल को आयात करें PlayerViewController.h।

 - (void)showPlayerVIew{ PlayerVIewController *playerViewController = [[PlayerVIewController alloc] initWithMasterController:masterController team:team player:nil]; [self presentModalViewController:playerVIewController animated:YES]; } 

हमें खिलाड़ी सूची की तालिका में कोशिकाओं पर क्लिक करने की भी आवश्यकता है। हम PlayerListViewController.mस्वचालित रूप से उत्पन्न विधि में पाते हैं didSelectRowAtIndexPath:और इसे निम्न रूप में लाते हैं:

 - (void)tableView:(UITableVIew *)tableVIew didSelectRowAtIndexPath:(NSIndexPath *)indexPath{ NSManagedObject *player = [[self sortPlayers] objectAtIndex:indexPath.row]; PlayerViewController *playerViewController = [[PlayerVIewController alloc] initWithMasterController:masterController team:team player:player]; [self presentModalVIewController:playerViewController animated:YES]; } 

इसके लिए, टीम और खिलाड़ी प्रबंधन एप्लिकेशन का कार्यान्वयन पूरा हो चुका है। ऐप लॉन्च करें। खिलाड़ियों को जोड़ें, खिलाड़ियों को निकालें, खिलाड़ियों के साथ टीमों को हटाएं।

संग्रहण डेटा की जाँच करना

दूसरे अध्याय में, हमने पहले ही यह पता लगा लिया था sqlite3कि कोर डेटा उत्पन्न करने वाले डेटाबेस संरचना का अध्ययन कैसे करें । SQLite- प्रकार के भंडारण के साथ काम करने वाले अनुभाग के अंत में, हम अपने डेटाबेस को ढूंढेंगे League_Manager.sqlite3और sqlite3इनपुट डेटाबेस के रूप में हमारे डेटाबेस के नाम से गुजरेंगे।

 sqlite3 ./5.0/Applications/CE79C20B-4CBF-47C3–9E7C- 9EC24FA22488/Documents/League_Manager.sqlite 

अपने लीग मैनेजर ऐप को चालू रखें ताकि आप sqlite3उनके बीच स्विच कर सकें और जो हो रहा है उसका ट्रैक रख सकें।
शुरुआत करने के लिए, आइए देखें कि क्या टेबल बनाए गए थे:

 sqlite> .tables ZPLAYER ZTEAM Z_METADATA Z_PRIMARYKEY 

ZPLAYERस्टोर डेटा Player; ZTEAM- स्टोर डेटा Team।
तीन टीमें बनाएं: क्रू (ब्लू), फायर (रेड), रेवोल्यूशन (ग्रीन)।
SQLite डेटाबेस में, वे कुछ इस तरह दिखेंगे (यह इस पर निर्भर करता है कि आपने कितने कमांड बनाए और डिलीट किए हैं):

 sqlite> select * from ZTEAM; 1|2|3|Crew|Blue 2|2|1|Fire|Red 3|2|1|Revolution|Green 

एक त्वरित चेक शो के रूप में, लीग मैनेजर आवेदन में अभी तक कोई खिलाड़ी नहीं हैं:

 sqlite> select * from ZPLAYER; 

अनुप्रयोग में क्रू खिलाड़ियों की सूची खोलें और तीन नए जोड़े: जॉर्डन गॉर्डन, पैट स्प्राट, बैली स्टेली। खिलाड़ियों को जोड़ने के बाद आपको उन्हें सूची में देखना होगा।



हम sqlite3आवेदन में सभी खिलाड़ियों को प्रदर्शित करने के लिए कमांड को ओवरफिल करेंगे :

 sqlite> select * from ZPLAYER; 1|1|1|1|Jordan|Gordan|jgordon@example.com 2|1|1|1|Pat|Sprat|psprat@example.com 3|1|1|1|Bailey|Staley|bstaley@example.com 

अब फायर टीम में एक नया खिलाड़ी जोड़ें और उसे टेरी गैरी कहें। हम सभी टीम के खिलाड़ियों और उस टीम का नाम सूचीबद्ध करते हैं जिसमें वह खेलता है:

 sqlite> select ZTEAM.ZNAME, ZPLAYER.ZFIRSTNAME, ZPLAYER.ZLASTNAME from ZTEAM, ZPLAYER where ZTEAM.Z_PK = ZPLAYER.ZTEAM; Crew|Jordan|Gordon Crew|Pat|Sprat Crew|Bailey|Staley Fire|Terry|Gary 

एप्लिकेशन खोलें, क्रू के पैट स्प्रैट की स्थापना रद्द करें, और अनुरोध को फिर से चलाएँ:

 sqlite> select ZTEAM.ZNAME, ZPLAYER.ZFIRSTNAME, ZPLAYER.ZLASTNAME from ZTEAM, ZPLAYER where ZTEAM.Z_PK = ZPLAYER.ZTEAM; Crew|Jordan|Gordon Crew|Bailey|Staley Fire|Terry|Gary 

अंत में, फायर टीम को हटा दें और, यह ध्यान देने योग्य है कि केवल टीम ही नहीं, बल्कि इसके एकमात्र खिलाड़ी टेरी गैरी भी बचे:

 sqlite> select ZTEAM.ZNAME, ZPLAYER.ZFIRSTNAME, ZPLAYER.ZLASTNAME from ZTEAM, ZPLAYER where ZTEAM.Z_PK = ZPLAYER.ZTEAM; Crew|Jordan|Gordon Crew|Bailey|Staley 

कोर डेटा के हुड के नीचे देखने से डरो मत।
ज्यादातर मामलों में, आपका एप्लिकेशन अपने डेटा वेयरहाउस के रूप में एक SQLite डेटाबेस का उपयोग करेगा, इसलिए यह समझना कि कोर डेटा इसके साथ कैसे काम करता है, आपको कठिनाइयों से बचने और एप्लिकेशन प्रदर्शन में सुधार करने में मदद कर सकता है।

इन-मेमोरी परसेंट स्टोर का उपयोग करना

पिछले अनुभाग में, हमने कोर डेटा और SQLite को डेटा वेयरहाउस के रूप में उपयोग करके एक एप्लिकेशन बनाया। यह खंड एक वैकल्पिक प्रकार के भंडारण पर चर्चा करता है: इन-मेमोरी मेमोरी। आइए एक नज़र डालते हैं कि आप किस प्रकार उपयोग किए गए डेटा स्टोर को बदल सकते हैं।

उपयोग किए गए भंडारण के प्रकार को बदलना सरल है, इसे बनाते समय केवल NSPersistentStoreCoordinatorएक अलग प्रकार निर्दिष्ट करने के लिए पर्याप्त है NSSQLiteStoreType।
यहाँ फ़ाइल persistentStoreCoordinator:में संशोधित विधि क्या होगी League_ManagerAppDelegate.m:

 - (NSPersistentStoreCoordinator *)persistentStoreCoordinator { if(_persistentStoreCoordinator != nil) return _persistentStoreCoordinator; // NSURL *storeURL = [[self applicationDocumentsDirectory] URLByAppendingPathComponent:@"League_Manager.sqlite"]; NSError *error = nil; _persistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:[self managedObjectModel]]; if(![_persistentStoreCoordinator addPersistentStoreWithType:NSInMemoryStoreType configuration:nil URL:nil options:nil error:&error]){ NSLog(@"Unresolved error %@, %@", error, [error userInfo]); abort(); } return _persistentStoreCoordinator; } 

डेटा स्टोर प्रकार को मेमोरी मेमोरी में बदल दिया गया है।
पहली बार जब हम अगली बार एप्लिकेशन लॉन्च होने पर ध्यान देंगे, यह है कि पहले के सभी जोड़े गए डेटा गायब हो गए हैं। ऐसा इसलिए हुआ क्योंकि हमने डेटा वेयरहाउस का प्रकार बदल दिया और पुराने से नए में डेटा को माइग्रेट नहीं किया। अध्याय 8 में, हम देखेंगे कि दो रिपॉजिटरी के बीच डेटा को कैसे माइग्रेट किया जा सकता है।
मेमोरी में भंडारण जीवन चक्र तब शुरू होता है जब कोर डेटा स्टैक को इनिशियलाइज़ किया जाता है और जब अनुप्रयोग बंद हो जाता है तो समाप्त हो जाता है।

टिप्पणी

IOS 4 के साथ शुरू होने और मल्टीटास्किंग की शुरुआत, किसी अन्य एप्लिकेशन पर स्विच करने से जरूरी नहीं कि आपका एप्लिकेशन समाप्त हो जाए। समाप्त होने के बजाय, हमारा एप्लिकेशन पृष्ठभूमि में चलता रहता है, जिसका अर्थ है कि मेमोरी में डेटा बना रहता है।

डिफ़ॉल्ट रूप से प्रदान किए जाने वाले विभिन्न प्रकार के डेटा स्टोरेज के बारे में सोचना, पहली बार ऐसी स्थिति के बारे में सोचना मुश्किल है जिसमें यह मेमोरी मेमोरी का उपयोग करने के लायक होगा, लेकिन ऐसी परिस्थितियां हैं। उदाहरण के लिए, दूरस्थ सर्वर से प्राप्त डेटा की स्थानीय कैशिंग। ऐसी स्थिति की कल्पना करें जहां आपका एप्लिकेशन दूरस्थ सर्वर से डेटा संसाधित करता है। यदि आपका एप्लिकेशन बहुत सारे अनुरोधों का उत्पादन करता है, तो इन अनुरोधों के उत्तर को "उत्तरदायी" प्रकार के भंडारण को चुनकर गति प्रदान करना अच्छा है। रिमोट सर्वर डेटा को एक संपीड़ित रूप में स्थानांतरित कर सकता है, मोबाइल डिवाइस पर, डेटा को अनपैक किया जाएगा और बाद के अनुरोधों को गति देने के लिए मेमोरी में लोड किया जाएगा। उस मामले में आप चाहते हैंताकि हर बार डेटा को अपडेट किया जाए (या कुछ अंतराल पर अपडेट किया जाए) और एप्लिकेशन शटडाउन पर डेटा हानि एक समस्या नहीं है।


कोर डेटा का उपयोग करके अपने बाद के अनुप्रयोगों को विकसित करते समय, इन-मेमोरी स्टोरेज का उपयोग करने पर विचार करें, जब एप्लिकेशन को रन के बीच डेटा स्टोर करने की आवश्यकता नहीं होती है। पारंपरिक अनुप्रयोगों में जिसमें उपयोगकर्ता डेटा संग्रहीत करना आवश्यक है, इस प्रकार का भंडारण लोकप्रिय नहीं होगा।

अपने स्वयं के भंडारण प्रकार का विकास करना

कोर डेटा का मूल सिद्धांत वास्तविक भंडारण के प्रकार से सार है। इस तरह की अमूर्तता आपको एक पंक्ति से अधिक बदलने की आवश्यकता के बिना डिफ़ॉल्ट रूप से प्रदान किए गए आंतरिक भंडारण के प्रकार (NSSQLiteStoreType, NSInMemoryStoreType, NSBinaryStoreType) को बदलने की अनुमति देती है। कुछ मामलों में, डिफ़ॉल्ट डेटा वेयरहाउस आपकी आवश्यकताओं के अनुरूप नहीं हो सकता है। इस मामले में, कोर डेटा आपके लिए एक उपहार है - स्वयं डेटा वेयरहाउस का एक मनमाना प्रकार बनाने की क्षमता। इस अनुभाग में, हम एक नया संग्रहण प्रकार बनाएंगे और इसका उपयोग हमारे लीग मैनेजर एप्लिकेशन में करेंगे।

इससे पहले कि हम कार्यान्वयन में गोता लगाएँ, यह याद रखने योग्य है कि कोर डेटा आपको केवल परमाणु बनाने की अनुमति देता हैभंडारण के प्रकार। परमाणु प्रकार का भंडारण वह प्रकार है जिसमें सेव ऑपरेशन अपनी प्रत्येक कॉल के सभी डेटा को उसकी संपूर्णता में सहेजता है। दुर्भाग्य से, इस तरह के प्रतिबंध SQLite डेटाबेस की तुलना में कुछ अधिक कुशल बनाने और उपयोग करने की अनुमति नहीं देते हैं। इस खंड में हम एक फ़ाइल प्रकार का भंडारण विकसित करेंगे, इसमें डेटा कॉमा सीमांकक (CSV) का उपयोग करके संग्रहीत किया जाएगा, और हम मानों को अलग करने के लिए एक ऊर्ध्वाधर बार (!) का उपयोग करेंगे।

कस्टम डेटा स्टोर को एक NSAtomicStoreवर्ग (उपवर्ग NSPersistentStore) से प्राप्त होना चाहिए जो डेटा के साथ काम करने के लिए आवश्यक क्षमताओं (विधियों) को प्रदान करता है। यह कैसे काम करता है, यह बेहतर ढंग से समझने के लिए, कोर डेटा फ्रेमवर्क के अंदर दो आंतरिक परतों की कल्पना करें, जैसा कि नीचे दी गई तस्वीर में दिखाया गया है:


उपयोगकर्ता के साथ NSManagedObjectऔर बातचीत करता है NSManagedObjectContext। दूसरी परत सीधे डेटा को बचाती है और इसमें डेटा वेयरहाउस और डेटा वेयरहाउस समन्वयक होते हैं। कस्टम प्रकार के स्टोरेज के मामले में, डेटा वेयरहाउस के साथ परत भी शामिल होती है NSAtomicStoreCacheNodeजो ऑब्जेक्ट्स को संग्रहीत करती है जिसमें डेटा स्वयं होता है। रिश्ता NSAtomicStoreCacheNodeकरने के लिए NSAtomicStoreके रूप में ही NSManagedObjectएक NSManagedObjectContext।

कस्टम संग्रहण को प्रारंभ करना

नया कस्टम डेटा वेयरहाउस डिवाइस स्टोरेज और NSAtomicStoreCacheNodes के बीच डेटा ट्रांसफर करने के साथ-साथ NSManagedObjects और NSAtomicStoreCacheNodes के बीच डेटा ट्रांसफर करने के लिए जिम्मेदार है।

कस्टम डेटा वेयरहाउस बनाने की दिशा में पहला कदम नए स्टोरेज प्रकार के लिए एक क्लास बनाना है। इस खंड में विकसित किए जाने वाले कस्टम भंडार पूरी तरह से कक्षा में होंगे CustomStore। लीग मैनेजर में एक नया वर्ग जोड़ें जो NSAtomicStore से इनहेरिट करेगा।

CustomStore.h

 #import <Foundation/Foundation.h> @interface CustomStore : NSAtomicStore { } @end 

CustomStore.m

 #import "CustomStore.h" @implementation CustomStore #pragma mark - NSPersistentStore - (NSString *)type { return [[self metadata] objectForKey:NSStoreTypeKey]; } - (NSString *)identifier { return [[self metadata] objectForKey:NSStoreUUIDKey]; } - (id)initWithPersistentStoreCoordinator:(NSPersistentStoreCoordinator *)coordinator configurationName:(NSString *)configurationName URL:(NSURL *)url options:(NSDictionary *)options { self = [super initWithPersistentStoreCoordinator:coordinator configurationName:configurationName URL:url options:options]; return self; } + (NSDictionary *)metadataForPersistentStoreWithURL:(NSURL *)url error:(NSError **)error { return nil; } #pragma mark - NSAtomicStore - (BOOL)load:(NSError **)error { return YES; } - (id)newReferenceObjectForManagedObject:(NSManagedObject *)managedObject { return nil; } - (NSAtomicStoreCacheNode *)newCacheNodeForManagedObject:(NSManagedObject *)managedObject { return nil; } - (BOOL)save:(NSError **)error { return YES; } - (void)updateCacheNode:(NSAtomicStoreCacheNode *)node fromManagedObject:(NSManagedObject *)managedObject { } @end 

कोर डेटा के सभी स्टोरेज में मेटाडेटा का एक निश्चित सेट होता है जो आपको NSPersistentStoreCoordinator'विभिन्न प्रकार के स्टोरेज को प्रबंधित करने की अनुमति देता है । NSPersistentStoreमेटाडाटा एक शब्दकोश के रूप में प्रस्तुत कर रहे हैं NSDictionary। दो कुंजी के मूल्य विशेष रुचि के हैं: NSStoreTypeKeyऔर NSStoreUUIDKey। कुंजी के लिए मूल्य NSStoreTypeKeyएक विशिष्ट स्ट्रिंग होना चाहिए जो स्टोरेज के प्रकार की पहचान करता है, और NSStoreUUIDKeyसीधे स्टोरेज।
विशिष्ट पहचानकर्ता बनाने के लिए, निम्न वर्ग विधि जोड़ें:

 + (NSString *)makeUUID { CFUUIDRef uuidRef = CFUUIDCreate(NULL); CFStringRef uuidStringRef = CFUUIDCreateString(NULL, uuidRef); CFRelease(uuidRef); NSString *uuid = [NSString stringWithString:(__bridge NSString *)uuidStringRef]; CFRelease(uuidStriingRef); return uuid; } 

इस अध्याय में उदाहरण में, कस्टम डेटा वेयरहाउस के काम करने के लिए दो फाइलों की आवश्यकता होती है। पहली फ़ाइल, जिसमें txt एक्सटेंशन है, जिसमें डेटा स्वयं है; दूसरी फ़ाइल, जिसमें प्लिस्ट एक्सटेंशन है, में मेटाडेटा है। मेटाडेटा को लोड करने और सहेजने के मुद्दे को हल करने के लिए, हम एक और विधि जोड़ेंगे और विधि के कार्यान्वयन को पूरा करेंगे metadataForPersistentStoreWithURL:error:।

निम्न विधि मेटाडेटा फ़ाइल सहेजती है:

 + (void)writeMetadata:(NSDictionary *)metadata toURL:(NSURL *)url { NSString *path = [[url relativePath] stringByAppendingString:@".plist"]; [metadata writeToFile:path atomically:YES]; } 

मेटाडेटा डाउनलोड करना थोड़ा अधिक जटिल है, क्योंकि रिपॉजिटरी में पहली डाउनलोड (एक्सेस) के मामले में, आपको एक खाली डेटा फ़ाइल (हमारे मामले में txt) के साथ मेटाडेटा के साथ एक फ़ाइल बनाने की आवश्यकता है। कोर डाटा मेटाडाटा भंडार से प्राप्त करते हैं और UUID है, जो निर्धारित करने के लिए अनुमति देते हैं, कैसे भंडारण के इस प्रकार के साथ काम करने के लिए है, तो आप मान चाबी के लिए सेट करना होगा टाइप करने की उम्मीद है NSStoreTypeKey, NSStoreUUIDKey। विधि ढूंढें metadataForPersistentStoreWithURL:error:और इसके शरीर को बदलें ताकि यह मेटाडेटा फ़ाइल की उपस्थिति के लिए जांच करे और, अगर ऐसी कोई फ़ाइल नहीं है, तो यह एक खाली भंडारण फ़ाइल (पाठ फ़ाइल) के साथ बनाई गई है (निर्दिष्ट कुंजी के साथ)।

 + (NSDictionary *)metadataForPersistentStoreWithURL:(NSURL *)url error:(NSError **)error { // determine the filename for metadata file NSString *path = [[url relativePath] stringByAppendingString:@".plist"]; if(![[NSFileManager defaultManager] fileExistsAtPath:path]) { // create a dictionary and store the store type key (CustomStore) // and the UUID key NSMutableDictionary *metadata = [NSMutableDictionary dictionary]; [metadata setValue:@"CustomStore" forKey:NSStoreTypeKey]; [metadata setValue:[CustomStore makeUUID] forKey:NSStoreUUIDKey]; // write the metadata to the .plist file [CustomStore writeMetadata:metadata toURl:url]; // write an empty data file [@"" writeToURL:url atomically:YES encoding:[NSString defaultCStringEncoding] error:nil]; NSLog(@"Created new store at %@", path); } return [NSDictionary dictionaryWithContentsOfFile:path]; } 

मेटाडेटा को लोड / सेव करने के तरीके, हम एक कस्टम डेटा वेयरहाउस की आरंभीकरण विधि को निम्नानुसार पूरा कर सकते हैं:

 - (id)initWithPersistentStoreCoordinator:(NSPersistentStoreCoordinator *)coordinator configurationName:(NSString *)configurationName URL:(NSURL *)url options:(NSDictionary *)options { self = [super initWithPersistentStoreCoordinator:coordinator configurationName:configurationName URL:url options:options]; NSDictionary *metadata = [CustomStore metadataForPersistentStoreWithURL:[self URL] error:nil]; [self setMetadata:metadata]; return self; } 

NSManagedObject और NSAtomicStoreCacheNode के बीच संबंध

हमारे कस्टम डेटा वेयरहाउस को आवश्यकतानुसार काम करने के लिए, तीन अतिरिक्त तरीकों को लागू करना होगा। विधियों में से पहला पास किए गए के लिए एक नई संदर्भ वस्तु बनाता है NSManagedObject'। ऑब्जेक्ट्स का उल्लेख करना प्रत्येक के लिए विशिष्ट पहचानकर्ता है NSAtomicStoreCacheNode'(प्राथमिक कुंजी के समान, संबंध समान NSObjectIDहै NSManagedObject)। चूंकि कस्टम रिपॉजिटरी के बीच अनुवाद करने के लिए जिम्मेदार NSManagedObject'है NSAtomicStoreCacheNode, इसलिए इसे नए बनाए गए लोगों के लिए एक संदर्भ वस्तु बनाने में सक्षम होना चाहिए NSManagedObject'। ऐसा करने के लिए, हम फिर से UUID का उपयोग करते हैं:

 - (id)newReferenceObjectForManagedObject:(NSManagedObject *)managedObject { NSString *uuid = [CustomStore makeUUID]; return uuid; } 

दूसरी विधि, जो हमारे लिए उपयोगी है, NSAtomicStoreCacheNodeसंबंधित NSManagedObjectवस्तु के लिए कक्षा का एक उदाहरण बनाती है । जब एक नया NSManagedObjectबनाया जाता है और ढांचे को इसे बचाने की आवश्यकता होती है, तो विधि को कहा जाता है newReferenceObjectForManagedObject:। वस्तुओं के NSAtomicCacheबीच संबंधों को NSObjectIDसंदर्भित करता है। जब Core Data NSManagedObject को स्थानीय संग्रहण में सहेजता है, तो विधि को कहा जाता है newCacheNodeForManagedObject:, जो, जैसा कि आप इसके नाम से देख सकते हैं, एक नया उदाहरण बनाता है NSAtomicStoreCacheNodeजो NSManagedObject के एनालॉग के रूप में कार्य करता है।

 - (NSAtomicStoreCacheNode *)newCacheNodeForManagedObject:(NSManagedObject *)managedObject { NSManagedObjectID *oid = [managedObject objectID]; id referenceID = [self referenceObjectForObjectID:oid]; NSAtomicStoreCacheNode* node = [self nodeForReferenceObject:referenceID andObjectID:oid]; [self updateCacheNode:node fromManagedObject:managedObject]; return node; } 

कार्यान्वयन newCacheNodeForManagedObject:संबंधित NSManagedObject ऑब्जेक्ट के लिए बनाई गई संदर्भित ऑब्जेक्ट के लिए खोज करता है, और NSManagedObject उदाहरण से सभी फ़ील्ड की प्रतिलिपि बनाते हुए एक नया NSAtomicStoreCacheNode बनाता है।