දර්ශන පාලකයන් අතර දත්ත පසු කිරීම


1379

මම iOS සහ පරමාර්ථ-සී සහ සමස්ත එම්වීසී ආදර්ශයට අලුත් වන අතර මම පහත සඳහන් දෑ සමඟ හිර වී සිටිමි.

දත්ත ඇතුළත් කිරීමේ පෝරමයක් ලෙස ක්‍රියා කරන දර්ශනයක් මා සතුව ඇති අතර පරිශීලකයාට විවිධ නිෂ්පාදන තෝරා ගැනීමේ අවස්ථාව ලබා දීමට මට අවශ්‍යය. නිෂ්පාදන වෙනත් දර්ශනයක් මත ලැයිස්තුගත කර ඇති UITableViewControllerඅතර මම තෝරා ගැනීම් කිහිපයක් සක්‍රීය කර ඇත.

මගේ ප්‍රශ්නය නම්, දත්ත එක් දෘෂ්ටියකින් තවත් දෘෂ්ටියකට මාරු කරන්නේ කෙසේද යන්නයි. මම තෝරාගැනීම් UITableViewඅරාවෙහි තබා ගන්නෙමි, නමුත් මම එය පෙර දත්ත ඇතුළත් කිරීමේ පෝරම දර්ශනයට ආපසු යවන්නේ කෙසේද, එමඟින් පෝරමය ඉදිරිපත් කිරීමේදී අනෙක් දත්ත සමඟ මූලික දත්ත වෙත සුරැකිය හැක.

මම අවට සැරිසැරූ අතර සමහර අය යෙදුම් නියෝජිතයා තුළ අරාව ප්‍රකාශ කරන අයුරු මම දුටුවෙමි. මම සිංගල්ටන් ගැන යමක් කියවූ නමුත් මේවා මොනවාදැයි නොතේරෙන අතර දත්ත ආකෘතියක් නිර්මාණය කිරීම ගැන මම යමක් කියවමි.

මෙය සිදු කිරීමේ නිවැරදි ක්‍රමය කුමක්ද සහ මම ඒ පිළිබඳව කටයුතු කරන්නේ කෙසේද?

Answers:


1689

මෙම ප්‍රශ්නය ස්ටැක් ඕවර් ප්‍රවාහයේ ඉතා ජනප්‍රිය බව පෙනේ, එබැවින් මා වැනි iOS ලෝකයේ ආරම්භ වන පුද්ගලයින්ට උපකාර කිරීම සඳහා වඩා හොඳ පිළිතුරක් ලබා දීමට මම උත්සාහ කළෙමි.

මෙම පිළිතුර මිනිසුන්ට තේරුම් ගත හැකි තරම් පැහැදිලි බවත් මම කිසිවක් අතපසු කර නැති බවත් මම විශ්වාස කරමි.

දත්ත ඉදිරියට යැවීම

වෙනත් දර්ශන පාලකයකින් දර්ශන පාලකය වෙත දත්ත ඉදිරියට යැවීම. ඔබට සංචාලන තොගයක් වෙතට තල්ලු විය හැකි වස්තුවක් / අගයක් එක් දර්ශන පාලකයක සිට තවත් දර්ශන පාලකය වෙත යැවීමට අවශ්‍ය නම් ඔබ මෙම ක්‍රමය භාවිතා කරනු ඇත.

මෙම උදාහරණය සඳහා, අපට ViewControllerAසහViewControllerB

එය සම්මත කිරීමට BOOLවටිනාකමක් ViewControllerAකිරීමට ViewControllerBඅපි පහත සඳහන් කරනවා.

  1. දී ViewControllerB.hසඳහා නව දේපළක් නිර්මාණයBOOL

    @property (nonatomic, assign) BOOL isSomethingEnabled;
  2. දී ViewControllerAඔබ ගැන එය කියන්න අවශ්ය ViewControllerBනිසා භාවිතයට

    #import "ViewControllerB.h"

    එවිට ඔබට දර්ශනය පූරණය කිරීමට අවශ්‍ය තැන උදා. didSelectRowAtIndexහෝ සමහරක් IBActionඔබ දේපල ViewControllerBnav තොගයට තල්ලු කිරීමට පෙර එය සැකසිය යුතුය .

    ViewControllerB *viewControllerB = [[ViewControllerB alloc] initWithNib:@"ViewControllerB" bundle:nil];
    viewControllerB.isSomethingEnabled = YES;
    [self pushViewController:viewControllerB animated:YES];

    මෙය සකසා ඇත isSomethingEnabledතුල ViewControllerBකිරීමට BOOLවටිනාකම YES.

Segues භාවිතා කරමින් දත්ත ඉදිරියට යැවීම

ඔබ ස්ටෝරිබෝඩ් භාවිතා කරන්නේ නම් ඔබ බොහෝ විට භාවිතා කරන්නේ කොටස් වන අතර දත්ත ඉදිරියට යැවීමට මෙම ක්‍රියා පටිපාටිය අවශ්‍ය වේ. මෙය ඉහත දෙයට සමාන නමුත් ඔබ දර්ශන පාලකය තල්ලු කිරීමට පෙර දත්ත සම්මත කරනවා වෙනුවට ඔබ භාවිතා කරන ක්‍රමයක් භාවිතා කරයි

-(void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender

ඒ නිසා ගමන් කිරීමට BOOLසිට ViewControllerAකිරීමට ViewControllerBඅපි පහත සඳහන් කරන්නේ:

  1. දී ViewControllerB.hසඳහා නව දේපළක් නිර්මාණයBOOL

    @property (nonatomic, assign) BOOL isSomethingEnabled;
  2. දී ViewControllerAඔබ ගැන එය කියන්න අවශ්ය ViewControllerBනිසා භාවිතයට

    #import "ViewControllerB.h"
  3. සිට මෙම segue නිර්මාණය ViewControllerAකිරීමට ViewControllerBද පසුරු දක්වනය හා එය හඳුනා ගැනීම දෙන්න, මෙම උදාහරණය තුල අපි එය කතා කරන්නම්"showDetailSegue"

  4. මීලඟට, ViewControllerAඕනෑම සෙග් එකක් සිදු වූ විට අප ඒ සඳහා ක්‍රමවේදය එක් කළ යුතුය, මේ නිසා කුමන සෙග් කැඳවනු ලැබුවේද යන්න හඳුනාගෙන පසුව යමක් කළ යුතුය. අපගේ උදාහරණයේ දී අපි පරීක්ෂා කර බලමු. එය සිදු කළ "showDetailSegue"හොත් අපි අපගේ BOOLඅගය වෙත යමුViewControllerB

    -(void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender{
        if([segue.identifier isEqualToString:@"showDetailSegue"]){
            ViewControllerB *controller = (ViewControllerB *)segue.destinationViewController;
            controller.isSomethingEnabled = YES;
        }
    }

    ඔබේ අදහස් සංචාලන පාලකයක කාවැදී ඇත්නම් ඔබට ඉහත ක්‍රමය තරමක් පහත සඳහන් පරිදි වෙනස් කළ යුතුය

    -(void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender{
        if([segue.identifier isEqualToString:@"showDetailSegue"]){
            UINavigationController *navController = (UINavigationController *)segue.destinationViewController;
            ViewControllerB *controller = (ViewControllerB *)navController.topViewController;
            controller.isSomethingEnabled = YES;
        }
    }

    මෙය සකසා ඇත isSomethingEnabledතුල ViewControllerBකිරීමට BOOLවටිනාකම YES.

දත්ත ආපසු ලබා දීම

දත්ත ඔබ ViewControllerBවෙත ආපසු ViewControllerAයැවීම සඳහා ප්‍රොටෝකෝල සහ නියෝජිතයන් හෝ බ්ලොක් භාවිතා කළ යුතුය, දෙවැන්න ඇමතුම් ලබා ගැනීම සඳහා ලිහිල්ව සම්බන්ධ වූ යාන්ත්‍රණයක් ලෙස භාවිතා කළ හැකිය.

මෙය සිදු කිරීම ViewControllerAසඳහා අපි නියෝජිතයෙකු පත් කරන්නෙමු ViewControllerB. දත්ත ආපසු යැවීමට අපට හැකි වන පරිදි ViewControllerBපණිවිඩයක් ආපසු යැවීමට මෙය ඉඩ දෙයි ViewControllerA.

සඳහා ViewControllerAවූ නියෝජිත ලෙස ViewControllerBඊට අනුකූල විය යුතුය ViewControllerBඅප නියම කිරීමට ඇති ගේ ප්රොටෝකෝලය. මෙය ViewControllerAක්‍රියාත්මක කළ යුතු ක්‍රම මොනවාදැයි මෙයින් කියැවේ .

  1. තුළ ViewControllerB.h, පහළින් #import, නමුත් ඉහළින් @interfaceඔබ ප්‍රොටෝකෝලය නියම කරයි.

    @class ViewControllerB;
    
    @protocol ViewControllerBDelegate <NSObject>
    - (void)addItemViewController:(ViewControllerB *)controller didFinishEnteringItem:(NSString *)item;
    @end
  2. ඊළඟට ViewControllerB.hඔබට delegateදේපලක් සැකසීමට සහ සංස්ලේෂණය කිරීමට අවශ්‍යයViewControllerB.m

    @property (nonatomic, weak) id <ViewControllerBDelegate> delegate;
  3. දී ViewControllerBඅපි පණිවිඩයක් කතා delegateඅපි දැක්ම පාලකය ඇස්ටරොයිඩයක් විට.

    NSString *itemToPassBack = @"Pass this value back to ViewControllerA";
    [self.delegate addItemViewController:self didFinishEnteringItem:itemToPassBack];
  4. ඒ සඳහා ය ViewControllerB. දැන් ViewControllerA.h, එහි ප්‍රොටෝකෝලය ViewControllerAආනයනය කිරීමට ViewControllerBහා අනුකූල වීමට කියන්න .

    #import "ViewControllerB.h"
    
    @interface ViewControllerA : UIViewController <ViewControllerBDelegate>
  5. දී ViewControllerA.mඅපේ ප්රොටෝකෝලය සිට පහත සඳහන් ක්රමය ක්රියාත්මක

    - (void)addItemViewController:(ViewControllerB *)controller didFinishEnteringItem:(NSString *)item
    {
        NSLog(@"This was returned from ViewControllerB %@",item);
    }
  6. viewControllerBසංචාලන තොගයට තල්ලු කිරීමට පෙර එහි නියෝජිතයා ViewControllerBබව අපට පැවසිය යුතුය ViewControllerA, එසේ නොමැතිනම් අපට දෝෂයක් ලැබෙනු ඇත.

    ViewControllerB *viewControllerB = [[ViewControllerB alloc] initWithNib:@"ViewControllerB" bundle:nil];
    viewControllerB.delegate = self
    [[self navigationController] pushViewController:viewControllerB animated:YES];

යොමුව

  1. වෙනත් දැක්ම පාලකයන් සමඟ අදහස් හුවමාරු කිරීමට පැවරීම භාවිතා තුළ මාර්ගෝපදේශය වැඩසටහන් නරඹන්න පාලක
  2. නියෝජිත රටාව

NSNotification center එය දත්ත සම්මත කිරීමට තවත් ක්‍රමයකි.

// add observer in controller(s) where you want to receive data
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handleDeepLinking:) name:@"handleDeepLinking" object:nil];

-(void) handleDeepLinking:(NSNotification *) notification {
    id someObject = notification.object // some custom object that was passed with notification fire.
}

// post notification
id someObject;
[NSNotificationCenter.defaultCenter postNotificationName:@"handleDeepLinking" object:someObject];

එක් පන්තියක සිට තවත් පන්තියකට දත්ත ආපසු යැවීම (පන්තියක් ඕනෑම පාලකයෙකු, ජාල / සැසි කළමනාකරුවෙකු, UIView උප පංතියක් හෝ වෙනත් පන්තියක් විය හැකිය)

බ්ලොක් යනු නිර්නාමික කාර්යයන් ය.

මෙම උදාහරණය මඟින් පාලක බී සිට පාලක ඒ වෙත දත්ත යවනු ලැබේ

බ්ලොක් එකක් අර්ථ දක්වන්න

@property void(^selectedVoucherBlock)(NSString *); // in ContollerA.h

ඔබට වටිනාකමක් අවශ්‍ය තැන බ්ලොක් හෑන්ඩ්ලර් (සවන්දෙන්නන්) එක් කරන්න (නිදසුනක් ලෙස ඔබට පාලක ඒඒ හි API ප්‍රතිචාරය අවශ්‍ය වේ, නැතහොත් ඔබට A හි ContorllerB දත්ත අවශ්‍ය වේ)

// in ContollerA.m

- (void)viewDidLoad {
    [super viewDidLoad];
    __unsafe_unretained typeof(self) weakSelf = self;
    self.selectedVoucherBlock = ^(NSString *voucher) {
        weakSelf->someLabel.text = voucher;
    };
}

පාලක බී වෙත යන්න

UIStoryboard *storyboard = [UIStoryboard storyboardWithName:@"Main" bundle:nil];
ControllerB *vc = [storyboard instantiateViewControllerWithIdentifier:@"ControllerB"];
vc.sourceVC = self;
    [self.navigationController pushViewController:vc animated:NO];

ගිනි වාරණය

-(void)tableView:(UITableView *)tableView didSelectRowAtIndexPath: 
(NSIndexPath *)indexPath {
    NSString *voucher = vouchersArray[indexPath.row];
    if (sourceVC.selectVoucherBlock) {
        sourceVC.selectVoucherBlock(voucher);
    }
    [self.navigationController popToViewController:sourceVC animated:YES];
}

බ්ලොක් සඳහා තවත් ක්‍රියාකාරී උදාහරණයක්


24
අප ද @class ViewControllerB;@ ප්‍රොටොකෝල් අර්ථ දැක්වීමට ඉහළින් තැබිය යුතුද? : එය තොරව මම අනුකූලව ViewControllerB මත "බලාපොරොත්තුවූ වර්ගය" දෝෂයක් ලබා - (void)addItemViewController:(ViewControllerB *)controller didFinishEnteringItem:(NSString *)item; තුළ @protocolප්රකාශ
ඇලන් පි

4
මෙය විශිෂ්ටයි. ඇලන්-පී පවසන පරිදි, @class ViewControllerB ලිවීමට අමතක නොකරන්න; ප්‍රොටෝකෝලය ඉහළින් ඔබට වෙනත් ආකාරයකින් "අපේක්ෂිත වර්ගයක්" දෝෂයක් ලැබෙනු ඇත.
ඇන්ඩ rew ඩේවිස්

6
ආපසු යාම සඳහා ඔබට නියෝජිතයින් අවශ්‍ය නොවේ.
malhal

4
මම "viewControllerB.delegate = ස්වයං;" ViewControllerB හි මට දෝෂයක් ඇතිවිය. නොගැලපෙන 'ViewControllerB * const __strong' වර්ගයේ සිට 'id <ViewControllerBDelegate>' වෙත පැවරීම, මා වැරදි කරන්නේ කුමක් දැයි මට විශ්වාස නැත. කාටහරි උදව් කරන්න පුළුවන්ද? ප්ලස් මට වෙනස් කිරීමට සිදු විය: initWithNib -> initWithNibName.
uplearnedu.com

4
ඔබ භාවිතා කරන්නේ නම් ඒ වෙනුවට NavigationControllerභාවිතා කළ යුතුය [self.navigationController pushViewController:viewController animated:YES];[self pushViewController:viewControllerB animated:YES];
නසීර්

194

ස්විෆ්ට්

මෙහි සහ ස්ටැක් ඕවර්ෆ්ලෝ වටා පැහැදිලි කිරීම් ටොන් ගණනක් ඇත, නමුත් ඔබ ආරම්භකයකු නම් වැඩ කිරීමට මූලික යමක් ලබා ගැනීමට උත්සාහ කරන්නේ නම්, මෙම යූ ටියුබ් නිබන්ධනය නැරඹීමට උත්සාහ කරන්න (එය කරන්නේ කෙසේද යන්න අවසාන වශයෙන් තේරුම් ගැනීමට එය මට උපකාරී විය).

ඊළඟ දර්ශන පාලකය වෙත දත්ත ඉදිරියට යැවීම

පහත දැක්වෙන්නේ වීඩියෝව මත පදනම් වූ උදාහරණයකි. පළමු දර්ශන පාලකයේ පෙළ ක්ෂේත්‍රයේ සිට දෙවන දර්ශන පාලකයේ ලේබලය වෙත නූලක් යැවීම මෙහි අදහසයි.

රූප විස්තරය මෙහි ඇතුළත් කරන්න

අතුරුමුහුණත තුළ කතන්දර පුවරු පිරිසැලසුම සාදන්න. සෙග් සෑදීම සඳහා, ඔබ Controlබොත්තම මත ක්ලික් කර දෙවන දර්ශන පාලකය වෙත අදින්න.

පළමු දර්ශන පාලකය

පළමු දර්ශන පාලකය සඳහා කේතය වේ

import UIKit

class FirstViewController: UIViewController {

    @IBOutlet weak var textField: UITextField!
    
    // This function is called before the segue
    override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
        
        // get a reference to the second view controller
        let secondViewController = segue.destination as! SecondViewController
        
        // set a variable in the second view controller with the String to pass
        secondViewController.receivedString = textField.text!
    }

}

දෙවන දර්ශන පාලකය

දෙවන දර්ශන පාලකය සඳහා කේතය වේ

import UIKit

class SecondViewController: UIViewController {

    @IBOutlet weak var label: UILabel!
    
    // This variable will hold the data being passed from the First View Controller
    var receivedString = ""
    
    override func viewDidLoad() {
        super.viewDidLoad()

        // Used the text from the First View Controller to set the label
        label.text = receivedString
    }

}

අමතක කරන්න එපා

  • UITextFieldසහ සඳහා අලෙවිසැල් සම්බන්ධ කරන්න UILabel.
  • පළමු හා දෙවන දර්ශන පාලකයන් IB හි සුදුසු ස්විෆ්ට් ලිපිගොනු වලට සකසන්න.

පෙර දර්ශන පාලකය වෙත දත්ත ආපසු යැවීම

දෙවන දර්ශන පාලකයේ සිට පළමු දර්ශන පාලකය වෙත දත්ත ආපසු යැවීමට, ඔබ ප්‍රොටෝකෝලයක් සහ නියෝජිතයෙකු භාවිතා කරයි . මෙම වීඩියෝව එම ක්‍රියාවලිය වුවද ඉතා පැහැදිලි ඇවිදීමකි:

පහත දැක්වෙන්නේ වීඩියෝව මත පදනම් වූ උදාහරණයකි (වෙනස් කිරීම් කිහිපයක් සමඟ).

රූප විස්තරය මෙහි ඇතුළත් කරන්න

අතුරුමුහුණත තුළ කතන්දර පුවරු පිරිසැලසුම සාදන්න. නැවතත්, සෙග් සෑදීම සඳහා, ඔබ Controlබොත්තමෙන් දෙවන දර්ශන පාලකය වෙත ඇදගෙන යන්න. සෙග් හඳුනාගැනුම සකසන්න showSecondViewController. තවද, පහත දැක්වෙන කේතයේ නම් භාවිතා කරමින් අලෙවිසැල් සහ ක්‍රියාවන් සම්බන්ධ කිරීමට අමතක නොකරන්න.

පළමු දර්ශන පාලකය

පළමු දර්ශන පාලකය සඳහා කේතය වේ

import UIKit

class FirstViewController: UIViewController, DataEnteredDelegate {

    @IBOutlet weak var label: UILabel!
    
    override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
        if segue.identifier == "showSecondViewController" {
            let secondViewController = segue.destination as! SecondViewController
            secondViewController.delegate = self
        }
    }
    
    func userDidEnterInformation(info: String) {
        label.text = info
    }
}

අපගේ අභිරුචි DataEnteredDelegateප්‍රොටෝකෝලය භාවිතා කිරීම සැලකිල්ලට ගන්න .

දෙවන දර්ශන පාලකය සහ ප්‍රොටෝකෝලය

දෙවන දර්ශන පාලකය සඳහා කේතය වේ

import UIKit

// protocol used for sending data back
protocol DataEnteredDelegate: AnyObject {
    func userDidEnterInformation(info: String)
}

class SecondViewController: UIViewController {

    // making this a weak variable so that it won't create a strong reference cycle
    weak var delegate: DataEnteredDelegate? = nil
    
    @IBOutlet weak var textField: UITextField!

    @IBAction func sendTextBackButton(sender: AnyObject) {
        
        // call this method on whichever class implements our delegate protocol
        delegate?.userDidEnterInformation(info: textField.text!)
    
        // go back to the previous view controller
        _ = self.navigationController?.popViewController(animated: true)
    }
}

protocolදර්ශන පාලක පන්තියට පිටතින් ඇති බව සලකන්න .

ඒක තමයි. දැන් යෙදුම ක්‍රියාත්මක කිරීමෙන් ඔබට දෙවන දර්ශන පාලකයේ සිට පළමු දෙසට දත්ත යැවීමට හැකි විය යුතුය.


නවතම ස්විෆ්ට් යාවත්කාලීනයන් කිහිපයක් සලකා බැලීමේදී, මෙය තවමත් ක්‍රියාත්මක කිරීමට පොදු රටාවක්ද?
piofusco

4
මා දුටු බොහෝ ස්විෆ්ට් යාවත්කාලීනයන් සාපේක්ෂව සුළු සින්ටැක්ටිකල් වෙනස්කම් මිස දර්ශන පාලකයන් අතර දත්ත සම්ප්‍රේෂණය වන ආකාරයෙහි වෙනස්කම් නොවේ. මම එවැනි විශාල වෙනස්කම් ගැන ඉගෙන ගන්නේ නම්, මම මගේ පිළිතුර යාවත්කාලීන කරමි.
සුරග්

2
ඕෆ්ටොපික් - නව දර්ශන පාලකයන්ට පරාමිතීන් යැවීමට iOS ට එවැනි අවලස්සන ක්‍රමයක් ඇත, විශ්වාස කළ නොහැකි - ඔබ ඇමතුම් ලබා ගන්නා විට පරාමිතීන් ස්ථානයක නොව වෙනත් ආකාරයකින් සැකසිය යුතුය. මේ සම්බන්ධයෙන් ඇන්ඩ්‍රොයිඩ්ට වඩා හොඳ ප්‍රවේශයක් ඇත - ඔබ ක්‍රියාකාරකමක් ආරම්භ කරන විට ඔබට එහි ආරම්භක අභිප්‍රාය හරහා ඕනෑම දත්තයක් (හොඳින්, පාහේ) ලබා දිය හැකිය. පහසු. වාත්තු කිරීමට හෝ යමක් කිරීමට අවශ්‍ය නැත. ආපසු අගයන් නැවත අමතන්නා වෙත යැවීම අත්‍යවශ්‍ය දෙයක් වන අතර එය පැවරීම අවශ්‍ය නොවේ. ඇත්ත වශයෙන්ම එය කැත ප්‍රවේශයන් ද භාවිතා කළ හැකිය, එහි කිසිදු ගැටළුවක් නොමැත))
මික්සාස්

1
Im හිමාන්ෂු, පළමුව දෙවන දර්ශන පාලකය වෙත යොමු වන්න. ඉන්පසු එහි අඩංගු පොදු විචල්‍යය යාවත්කාලීන කරන්න.
සුරග්

8
-හනී. මම හිතන්නේ "නියෝජිතයා" යන වචනය අවුල් සහගත ය. "සේවකයා" යන වචනය භාවිතා කිරීමට මට ඉඩ දෙන්න. "සේවකයා" (පළමු දර්ශන පාලකය) "ලොක්කා" (දෙවන දර්ශන පාලකය) එය කිරීමට පවසන ඕනෑම දෙයක් කරයි. "ලොක්කා" එහි "සේවකයා" කවුදැයි නොදනී; එය ඕනෑම කෙනෙකුට විය හැකිය. එබැවින් පළමු දර්ශන පාලකයේ ("සේවක" පන්තියේ), එය පවසන්නේ, මම ඔබේ "සේවකයා" වනු ඇති බවයි. ලේබලයේ ලිවිය යුතු දේ ඔබ මට කියන්න, මම ඔබ වෙනුවෙන් එය කරන්නෙමි. මේ අනුව, secondViewController.delegate = self"ලොක්කාගේ සේවකයා වීමට මම එකඟ වෙමි" යන්නයි. තවත් පිළිතුරක් සහ වැඩි පැහැදිලි කිරීමක් සඳහා මෙම පිළිතුර බලන්න .
සුරග්

136

MVC හි M යනු "ආදර්ශ" සඳහා වන අතර MVC පරාමිතිය තුළ ආදර්ශ පන්තිවල කාර්යභාරය වන්නේ වැඩසටහනේ දත්ත කළමනාකරණය කිරීමයි. ආකෘතියක් යනු දර්ශනයකට ප්‍රතිවිරුද්ධ දෙයකි - දර්ශනයක් දත්ත ප්‍රදර්ශනය කරන්නේ කෙසේදැයි දනී, නමුත් එය දත්ත සමඟ කළ යුතු දේ ගැන කිසිවක් නොදන්නා අතර නිරූපිකාවක් දත්ත සමඟ වැඩ කරන්නේ කෙසේද යන්න ගැන සියල්ල දන්නා නමුත් එය ප්‍රදර්ශනය කරන්නේ කෙසේද යන්න ගැන කිසිවක් දන්නේ නැත. ආකෘති සංකීර්ණ විය හැකි නමුත් ඒවා එසේ විය යුතු නැත - ඔබගේ යෙදුමේ ආකෘතිය නූල් හෝ ශබ්ද කෝෂ රාශියක් තරම් සරල විය හැකිය.

පාලකයකුගේ කාර්යභාරය වන්නේ දැක්ම සහ ආකෘතිය අතර මැදිහත් වීමයි. එමනිසා, ඔවුන්ට දර්ශන වස්තු එකක් හෝ කිහිපයක් සහ ආදර්ශ වස්තු එකක් හෝ කිහිපයක් යොමු කිරීම අවශ්‍ය වේ. ඔබගේ ආකෘතිය ශබ්ද කෝෂ සමූහයක් යැයි කියමු, සෑම ශබ්ද කෝෂයක්ම ඔබේ වගුවේ එක් පේළියක් නියෝජනය කරයි. ඔබගේ යෙදුම සඳහා වන මූල දර්ශනය එම වගුව පෙන්වන අතර ගොනුවකින් අරාව පූරණය කිරීම සඳහා එය වගකිව යුතුය. පරිශීලකයා මේසයට නව පේළියක් එක් කිරීමට තීරණය කළ විට, ඔවුන් යම් බොත්තමක් තට්ටු කරන අතර ඔබේ පාලකය නව (විකෘති) ශබ්දකෝෂයක් සාදා එය අරාවට එක් කරයි. පේළිය පිරවීම සඳහා, පාලකය සවිස්තරාත්මක දර්ශන පාලකයක් නිර්මාණය කර එයට නව ශබ්ද කෝෂය ලබා දෙයි. සවිස්තරාත්මක දර්ශන පාලකය ශබ්ද කෝෂයේ පුරවා නැවත පැමිණේ. ශබ්දකෝෂය දැනටමත් ආකෘතියේ කොටසක් බැවින් වෙනත් කිසිවක් සිදුවිය යුතු නැත.


95

IOS හි වෙනත් පන්තියකට දත්ත ලබා ගත හැකි විවිධ ක්‍රම තිබේ. උදාහරණයක් වශයෙන් -

  1. වෙනත් පන්තියක් වෙන් කිරීමෙන් පසු සෘජු ආරම්භ කිරීම.
  2. පැවරීම - දත්ත ආපසු යැවීම සඳහා
  3. දැනුම්දීම - එකවර පන්ති කිහිපයකට දත්ත විකාශනය කිරීම සඳහා
  4. සුරැකීම NSUserDefaults- පසුව ප්‍රවේශ වීම සඳහා
  5. තනි පන්ති
  6. දත්ත සමුදායන් සහ ප්ලයිස්ට් වැනි වෙනත් ගබඩා යාන්ත්‍රණ.

නමුත් වර්තමාන පංතියේ ප්‍රතිපාදන වෙන් කර ඇති වෙනත් පන්තියකට වටිනාකමක් ලබා දීමේ සරල අවස්ථාව සඳහා, වඩාත් පොදු හා කැමති ක්‍රමය වනුයේ වෙන් කිරීමෙන් පසු සෘජුවම අගයන් සැකසීමයි. මෙය පහත පරිදි සිදු කෙරේ: -

පාලක 1 සහ පාලක 2 භාවිතා කරමින් අපට එය තේරුම් ගත හැකිය

Controller1 පන්තියේදී ඔබට Controller2 වස්තුව නිර්මාණය කිරීමට අවශ්‍ය යැයි සිතමු. මෙය මෙසේ කළ හැකිය: -

- (void)pushToController2 {

    Controller2 *obj = [[Controller2 alloc] initWithNib:@"Controller2" bundle:nil];
    [obj passValue:@"String"];
    [self pushViewController:obj animated:YES];
}

පාලක 2 පන්තිය ක්‍රියාත්මක කිරීමේදී මෙම ශ්‍රිතය පහත පරිදි වේ.

@interface Controller2  : NSObject

@property (nonatomic , strong) NSString* stringPassed;

@end

@implementation Controller2

@synthesize stringPassed = _stringPassed;

- (void) passValue:(NSString *)value {

    _stringPassed = value; //or self.stringPassed = value
}

@end

ඔබට පාලක 2 පන්තියේ ගුණාංග මේ ආකාරයටම සෘජුවම සැකසිය හැකිය:

- (void)pushToController2 {

    Controller2 *obj = [[Controller2 alloc] initWithNib:@"Controller2" bundle:nil];
    [obj setStringPassed:@"String"];  
    [self pushViewController:obj animated:YES];
}

බහුවිධ අගයන් පසු කිරීමට ඔබට වැනි පරාමිතීන් භාවිතා කළ හැකිය: -

Controller2 *obj = [[Controller2 alloc] initWithNib:@"Controller2" bundle:nil];
[obj passValue:@“String1 andValues:objArray withDate:date]; 

නැතහොත් ඔබට පොදු අංගයකට සම්බන්ධ පරාමිති 3 කට වඩා සම්මත කිරීමට අවශ්‍ය නම්, ඔබට ආදර්ශ පන්තියකට අගයන් ගබඩා කර එම ආකෘතිය ඊළඟ පන්තියට ලබා දිය හැකිය.

ModelClass *modelObject = [[ModelClass alloc] init]; 
modelObject.property1 = _property1;
modelObject.property2 = _property2;
modelObject.property3 = _property3;

Controller2 *obj = [[Controller2 alloc] initWithNib:@"Controller2" bundle:nil];
[obj passmodel: modelObject];

ඔබට අවශ්‍ය නම් කෙටියෙන් -

1) set the private variables of the second class initialise the values by calling a custom function and passing the values.
2) setProperties do it by directlyInitialising it using the setter method.
3) pass more that 3-4 values related to each other in some manner , then create a model class and set values to its object and pass the object using any of the above process.

මෙය උපකාරී වේ යැයි සිතමි


84

වැඩි පර්යේෂණ වලින් පසුව පෙනී ගියේ මෙය කිරීමට නිවැරදි / ඇපල් කැමති ක්‍රමය ප්‍රොටෝකෝල සහ නියෝජිතයන් බවයි.

මම මෙම උදාහරණය භාවිතා කිරීම අවසන් කළෙමි

දර්ශන පාලකයන් සහ වෙනත් වස්තු අතර දත්ත බෙදාගැනීම @ iPhone Dev SDK

හොඳින් වැඩ කළ අතර මගේ අදහස් අතර ඉදිරියට හා පසුපසට නූලක් සහ අරා එකක් පසු කිරීමට මට ඉඩ ලැබුණි.

ඔබගේ සියලු උදව්වට ස්තූතියි


3
ප්‍රොටෝකෝල සහ නියෝජිතයන් භාවිතා නොකරන්න.
malhal

1
@malhal ඔබ කතන්දර පුවරු භාවිතා නොකරන්නේ නම් කුමක් කළ යුතුද?
ඊවාන් ආර්

නිෂ් less ල ප්‍රොටෝකෝල සහ නියෝජිතයින්ට මම වෛර කරමි. @malhal
DawnSong

AnEvanR ඔබට කේතයෙන් කොටස් සෑදිය හැකිය. ඒ සියල්ලම එක හා සමානයි.
ඩෝන්සොං

1
අත්යවශ්යයෙන්ම මෙම පිටුවේ ඇති සමස්ත QA "බහාලුම් දර්ශන වලට පෙර පැරණි දිනවල සිට" වේ. ඔබ වසර මිලියනයක් තුළ කිසි විටෙකත් ප්‍රොටෝකෝල හෝ නියෝජිතයන් සමඟ කරදර වන්නේ නැත. ඔබ ඕනෑම තිරයක කරන සෑම කුඩා දෙයක්ම කෙසේ හෝ බහාලුම් දර්ශනයක් වේ, එබැවින් ප්‍රශ්නය ඇත්ත වශයෙන්ම තවදුරටත් නොපවතී - ඔබට දැනටමත් සියලුම බහාලුම් දර්ශන වලින් "ඉහළට සහ පහළට" සියලු යොමු කිරීම් තිබේ.
ෆැට්ටි

66

සම්මත කුට්ටි සහිත සරලම හා අලංකාර අනුවාදය මට හමු විය. ආපසු ලබා දෙන දත්ත "A" ලෙසත්, ආපසු බැලීමේ පාලකය "B" ලෙසත් බලා සිටින පාලක නම් කරමු. මෙම උදාහරණයේ දී අපට අගයන් 2 ක් ලබා ගැනීමට අවශ්‍යය: පළමුව ටයිප් 1 සහ දෙවන ටයිප් 2.

අපි ස්ටෝරිබෝඩ් භාවිතා කරමු යැයි උපකල්පනය කරමින්, පළමු පාලකය ඇමතුම් ලබා ගැනීමේ වාරණය සකසයි, උදාහරණයක් ලෙස සෙග් සකස් කිරීමේදී:

- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender
{
    if ([segue.destinationViewController isKindOfClass:[BViewController class]])
    {
        BViewController *viewController = segue.destinationViewController;

        viewController.callback = ^(Type1 *value1, Type2 *value2) {
            // optionally, close B
            //[self.navigationController popViewControllerAnimated:YES];

            // let's do some action after with returned values
            action1(value1);
            action2(value2);
        };

    }
}

සහ "බී" දර්ශන පාලකය විසින් ඇමතුම් ආපසු ගැනීමේ දේපල ප්‍රකාශ කළ යුතුය, BViewController.h:

// it is important to use "copy"
@property (copy) void(^callback)(Type1 *value1, Type2 *value2);

ක්‍රියාත්මක කිරීමේ ගොනුවට වඩා BViewController.m අපගේ ඇමතුම් ආපසු ලබා දීමට අවශ්‍ය අගයන් ලැබීමෙන් පසුව අමතන්න:

if (self.callback)
    self.callback(value1, value2);

මතක තබා ගත යුතු එක් දෙයක් නම්, බ්ලොක් භාවිතා කිරීම බොහෝ විට මෙහි විස්තර කර ඇති ආකාරයට ශක්තිමත් සහ __ සති යොමු කිරීම් කළමනාකරණය කළ යුතු බවයි


වෙනම දේපලක් වීම වෙනුවට කෝල්බැක් බ්ලොක් සඳහා පරාමිතියක් නොවන්නේ ඇයි?
තිමුසින්

56

ලබා දී ඇති බොහෝ පිළිතුරු වල හොඳ තොරතුරු තිබේ, නමුත් කිසිවෙකු ප්‍රශ්නය සම්පූර්ණයෙන් ආමන්ත්‍රණය නොකරයි.

දර්ශන පාලකයන් අතර තොරතුරු යැවීම පිළිබඳව ප්‍රශ්නය අසයි. ලබා දී ඇති නිශ්චිත උදාහරණය මඟින් අදහස් අතර තොරතුරු සම්ප්‍රේෂණය කිරීම ගැන විමසනු ඇත, නමුත් iOS වෙත ස්වයං ප්‍රකාශිත නවතාවයක් ලබා දී ඇති විට, මුල් පෝස්ටරය අදහස් කර ඇත්තේ දර්ශන පාලකයන් අතර මිස දර්ශන අතර නොවේ (ViewControllers වෙතින් කිසිදු මැදිහත්වීමකින් තොරව). සියලුම පිළිතුරු දර්ශන පාලකයන් දෙදෙනෙකු වෙත යොමු වී ඇති බව පෙනේ, නමුත් තොරතුරු හුවමාරුවේදී දර්ශන පාලකයන් දෙදෙනෙකුට වඩා සම්බන්ධ කර ගැනීමට යෙදුම පරිණාමය වුවහොත් කුමක් කළ යුතුද?

මුල් පෝස්ටරයේ සිංගල්ටන් සහ ඇප් ඩෙලිගේට් භාවිතය ගැන ද විමසීය . මෙම ප්‍රශ්නවලට පිළිතුරු සැපයිය යුතුය.

මෙම ප්‍රශ්නය දෙස බලන වෙනත් කෙනෙකුට උපකාර කිරීම සඳහා, සම්පූර්ණ පිළිතුරක් අවශ්‍ය, මම එය ලබා දීමට උත්සාහ කරමි.

යෙදුම් අවස්ථා

අතිශය උපකල්පිත, වියුක්ත සාකච්ඡාවක් කරනවා වෙනුවට, එය ස්ථිර යෙදුම් මනසෙහි තබා ගැනීමට උපකාරී වේ. දර්ශන දෙකක පාලක තත්වයක් සහ දර්ශන දෙකකට වඩා වැඩි පාලක තත්වයක් නිර්වචනය කිරීමට උපකාර කිරීම සඳහා, මම ස්ථිර යෙදුම් අවස්ථා දෙකක් අර්ථ දැක්වීමට යන්නෙමි.

සිදුවීම එකක්: තොරතුරු හුවමාරු කර ගැනීමට උපරිම දර්ශන පාලකයන් දෙදෙනෙකුට අවශ්‍ය වේ. රූප සටහන එකක් බලන්න.

මුල් ගැටලුවේ රූප සටහන

යෙදුමේ දර්ශන පාලක දෙකක් තිබේ. ViewControllerA (දත්ත ඇතුළත් කිරීමේ පෝරමය) සහ View Controller B (නිෂ්පාදන ලැයිස්තුව) ඇත. නිෂ්පාදන ලැයිස්තුවේ තෝරාගත් අයිතම දත්ත ඇතුළත් කිරීමේ පෝරමයේ පෙළ කොටුවේ ප්‍රදර්ශනය කර ඇති අයිතම සමඟ සැසඳිය යුතුය. මෙම තත්වය තුළ, ViewControllerA සහ ViewControllerB එකිනෙකා සමඟ කෙලින්ම සන්නිවේදනය කළ යුතු අතර වෙනත් දර්ශන පාලකයන් නොමැත.

සිදුවීම දෙක : දර්ශන පාලකයන් දෙදෙනෙකුට වඩා වැඩි ගණනක් එකම තොරතුරු බෙදා ගත යුතුය. රූප සටහන දෙක බලන්න.

ගෘහ ඉන්වෙන්ටරි යෙදුම් රූප සටහන

යෙදුමේ දර්ශන පාලක හතරක් ඇත. එය නිවාස ඉන්වෙන්ටරි කළමනාකරණය සඳහා ටැබ් මත පදනම් වූ යෙදුමකි. දර්ශන පාලකයන් තිදෙනෙකු එකම දත්තවල පෙරහන් කළ අදහස් ඉදිරිපත් කරයි:

  • ViewControllerA - සුඛෝපභෝගී භාණ්ඩ
  • ViewControllerB - රක්ෂණය නොකළ අයිතම
  • ViewControllerC - මුළු නිවාස ඉන්වෙන්ටරි
  • ViewControllerD - නව අයිතම පෝරමය එක් කරන්න

තනි අයිතමයක් නිර්මාණය කරන විට හෝ සංස්කරණය කරන ඕනෑම වේලාවක එය අනෙක් දර්ශන පාලකයන් සමඟ සමමුහුර්ත කළ යුතුය. උදාහරණයක් ලෙස, අපි ViewControllerD හි බෝට්ටුවක් එක් කළත් එය තවමත් රක්ෂණය කර නොමැති නම්, පරිශීලකයා ViewControllerA (සුඛෝපභෝගී අයිතම) වෙත යන විට බෝට්ටුව දිස්විය යුතුය, එසේම ViewControllerC (මුළු නිවාස ඉන්වෙන්ටරි) වෙත ගියද පරිශීලකයා වෙත යන විට නොවේ. ViewControllerB (රක්ෂණය නොකළ අයිතම). නව අයිතම එකතු කිරීම පමණක් නොව, අයිතම මකා දැමීම (ඕනෑම දර්ශන පාලකයන් හතර දෙනාගෙන් ඕනෑම කෙනෙකුට අවසර දිය හැකිය), හෝ පවතින අයිතම සංස්කරණය කිරීම ("නව අයිතම එකතු කරන්න" වෙතින් අවසර දිය හැකි, නැවත ප්‍රතිනිර්මාණය කිරීම ගැන අපි සැලකිලිමත් විය යුතුය. සංස්කරණය සඳහා).

සියලුම දර්ශන පාලකයන්ට එකම දත්ත බෙදා ගැනීමට අවශ්‍ය බැවින්, දර්ශන පාලකයන් හතරම සමමුහුර්තකරණයෙහි රැඳී සිටිය යුතු අතර, එම නිසා ඕනෑම තනි දර්ශන පාලකයක් යටින් පවතින දත්ත වෙනස් කරන සෑම අවස්ථාවකම අනෙක් සියලුම දර්ශන පාලකයන්ට යම් ආකාරයක සන්නිවේදනයක් තිබිය යුතුය. මෙම තත්වය තුළ එක් එක් දර්ශන පාලකය එකිනෙකා සමඟ සෘජුවම සන්නිවේදනය කිරීම අපට අවශ්‍ය නොවන බව තරමක් පැහැදිලිය. එය පැහැදිලිව පෙනෙන්නට නොමැති නම්, අපට විවිධ දර්ශන පාලක 20 ක් තිබුනේ නම් (4 ට වඩා) සලකා බලන්න. එක් දර්ශන පාලකයක් වෙනසක් සිදු කළ ඕනෑම වේලාවක අනෙක් දර්ශන පාලකයන් 19 දෙනාට දැනුම් දීම කෙතරම් දුෂ්කර හා දෝෂ සහිතද?

විසඳුම්: නියෝජිතයින් සහ ඔබ්සර්වර් රටාව සහ තනි තනි

පළමු අවස්ථාවෙහිදී, වෙනත් පිළිතුරු ලබා දී ඇති පරිදි අපට ශක්‍ය විසඳුම් කිහිපයක් තිබේ

  • segues
  • නියෝජිතයන්
  • දර්ශන පාලකයන්ගේ ගුණාංග කෙලින්ම සැකසීම
  • NSUserDefaults (ඇත්ත වශයෙන්ම දුර්වල තේරීමක්)

අවස්ථා දෙකක දී, අපට වෙනත් ශක්‍ය විසඳුම් තිබේ:

  • නිරීක්ෂක රටාව
  • තනි

කටය උදාහරණයක් එහි ජීවිත කාලය තුළ පැවැත්ම තුළ එකම සිද්ධිය වීම බව, පන්තියේ උදාහරණයක් වේ. තනි පුද්ගලයෙකුට එහි නම ලැබෙන්නේ එය තනි අවස්ථාව වන බැවිනි. සාමාන්‍යයෙන් සිංගල්ටන් භාවිතා කරන සංවර්ධකයින්ට ඒවාට ප්‍රවේශ වීම සඳහා විශේෂ පන්ති ක්‍රම තිබේ.

+ (HouseholdInventoryManager*) sharedManager; {
    static dispatch_once_t onceQueue;
    static HouseholdInventoryManager* _sharedInstance;

    // dispatch_once is guaranteed to only be executed once in the
    // lifetime of the application
    dispatch_once(&onceQueue, ^{
        _sharedInstance = [[self alloc] init];
    });
    return _sharedInstance;
}

සිංගල්ටන් යනු කුමක්දැයි දැන් අපට වැටහී ඇති හෙයින්, සිංගල්ටන් එකක් නිරීක්ෂක රටාවට ගැලපෙන්නේ කෙසේදැයි සාකච්ඡා කරමු. නිරීක්‍ෂක රටාව එක් වස්තුවකට තවත් වස්තුවක වෙනස්කම් වලට ප්‍රතිචාර දැක්වීමට යොදා ගනී. දෙවන අවස්ථාවෙහිදී, අපට වෙනස් දර්ශන පාලක හතරක් ඇත, ඔවුන් සියල්ලන්ටම යටින් පවතින දත්තවල වෙනස්කම් ගැන දැන ගැනීමට අවශ්‍යය. “යටින් පවතින දත්ත” තනි අවස්ථාවකට අයත් විය යුතුය. "වෙනස්කම් ගැන දැන ගැනීම" සිදු කරනු ලබන්නේ සිංගල්ටන් හි සිදු කරන ලද වෙනස්කම් නිරීක්ෂණය කිරීමෙනි.

ගෘහ ඉන්වෙන්ටරි යෙදුමට ඉන්වෙන්ටරි අයිතම ලැයිස්තුවක් කළමනාකරණය කිරීම සඳහා නිර්මාණය කර ඇති පන්තියක එක් අවස්ථාවක් තිබේ. කළමනාකරු විසින් ගෘහ භාණ්ඩ එකතුවක් කළමනාකරණය කරනු ඇත. පහත දැක්වෙන්නේ දත්ත කළමනාකරු සඳහා පන්ති අර්ථ දැක්වීමකි:

#import <Foundation/Foundation.h>

@class JGCHouseholdInventoryItem;

@interface HouseholdInventoryManager : NSObject
/*!
 The global singleton for accessing application data
 */
+ (HouseholdInventoryManager*) sharedManager;


- (NSArray *) entireHouseholdInventory;
- (NSArray *) luxuryItems;
- (NSArray *) nonInsuredItems;

- (void) addHouseholdItemToHomeInventory:(JGCHouseholdInventoryItem*)item;
- (void) editHouseholdItemInHomeInventory:(JGCHouseholdInventoryItem*)item;
- (void) deleteHoueholdItemFromHomeInventory:(JGCHouseholdInventoryItem*)item;
@end

ගෘහ ඉන්වෙන්ටරි අයිතම එකතු කිරීම වෙනස් වන විට, මෙම වෙනස පිළිබඳව දර්ශන පාලකයන් දැනුවත් කළ යුතුය. ඉහත පන්ති අර්ථ දැක්වීම මෙය සිදු වන්නේ කෙසේද යන්න පැහැදිලි නොකරයි. අපි නිරීක්ෂක රටාව අනුගමනය කළ යුතුයි. දර්ශන පාලකය හවුල් කළමණාකරු විධිමත් ලෙස නිරීක්ෂණය කළ යුතුය. තවත් වස්තුවක් නිරීක්ෂණය කිරීමට ක්‍රම දෙකක් තිබේ:

  • යතුරු අගය-නිරීක්ෂණ (KVO)
  • NSNotificationCenter.

අවස්ථා දෙකක දී, KVO භාවිතයෙන් නිරීක්ෂණය කළ හැකි ගෘහස්ථ ඉන්වෙන්ටරි මැනේජර් හි එක් දේපලක් අප සතුව නොමැත. අපට පහසුවෙන් නිරීක්ෂණය කළ හැකි තනි දේපලක් නොමැති නිසා, නිරීක්ෂක රටාව, මේ අවස්ථාවේ දී, NSNotificationCenter භාවිතයෙන් ක්‍රියාත්මක කළ යුතුය. සෑම දර්ශන පාලක හතරකින්ම දැනුම්දීම් සඳහා දායක වන අතර, හවුල් කළමණාකරු සුදුසු අවස්ථාවලදී දැනුම්දීම් මධ්‍යස්ථානයට දැනුම් දෙනු ඇත. ඉන්වෙන්ටරි කළමණාකරුට ඉන්වෙන්ටරි අයිතම එකතු කිරීම වෙනස් වන විට දැන ගැනීමට උනන්දුවක් දක්වන වෙනත් පංතිවල දර්ශන පාලකයන් හෝ සිද්ධීන් ගැන කිසිවක් දැන ගැනීමට අවශ්‍ය නැත; NSNotificationCenter විසින් මෙම ක්‍රියාත්මක කිරීමේ තොරතුරු බලා ගනී. දර්ශන පාලකයන් හුදෙක් දැනුම්දීම් වලට දායක වන අතර දත්ත කළමනාකරු විසින් දැනුම්දීම් පළ කරයි.

බොහෝ ආරම්භක ක්‍රමලේඛකයින් ගෝලීය වශයෙන් ප්‍රවේශ විය හැකි යෙදුමේ ජීවිත කාලය තුළ සෑම විටම හරියටම එක් යෙදුම් නියෝජිතයෙකු සිටින බව වාසි ලබා ගනී . ආරම්භක ක්‍රමලේඛකයින් යෙදුමේ වෙනත් ඕනෑම තැනකින් ප්‍රවේශ වීමේ පහසුව සඳහා ඇප් ඩෙලිගේට් තුළට වස්තු සහ ක්‍රියාකාරිත්වය පුරවා ගැනීමට මෙම කරුණ භාවිතා කරයි. AppDelegate සිංගල්ටන් එකක් බැවින් එය අනෙක් සියලුම තනි බොත්තම් ආදේශ කළ යුතු යැයි අදහස් නොකෙරේ. මෙය එක් පංතියකට අධික බරක් පැටවීම, හොඳ වස්තු-නැඹුරු පුරුදු බිඳ දැමීම නිසා මෙය දුර්වල පුරුද්දකි. සෑම පන්තියකටම පැහැදිලි භූමිකාවක් තිබිය යුතුය, එය පහසුවෙන් පැහැදිලි කළ හැකිය, බොහෝ විට පන්තියේ නමෙන්.

ඔබගේ යෙදුම් නියෝජිතයා පුපුරා යාමට පටන් ගන්නා ඕනෑම වේලාවක, ක්‍රියාකාරීත්වය තනි බොත්තම් වලට ඉවත් කිරීමට පටන් ගන්න. නිදසුනක් ලෙස, මූලික දත්ත ගබඩාව AppDelegate හි තබා නොගත යුතුය, ඒ වෙනුවට coreDataManager පන්තියක් වන තමන්ගේම පන්තියට දැමිය යුතුය.

යොමුව


41

OP දර්ශන පාලකයන් ගැන සඳහන් නොකළ නමුත් බොහෝ පිළිතුරු වලට අනුව, එක් දර්ශන පාලකයකින් තවත් දර්ශනයකට දත්ත යැවීමට අවශ්‍ය වූ විට LLVM හි සමහර නව විශේෂාංග මඟින් මෙය පහසු කර ගැනීමට ඉඩ සලසයි. ප්‍රති results ල නැවත ලබා ගැනීම.

කතන්දර පුවරු, ARC සහ LLVM කුට්ටි මට වෙන කවරදාටත් වඩා පහසු කරයි. ඉහත සඳහන් සමහර පිළිතුරු පුවරු සහ කොටස් දැනටමත් සඳහන් කර ඇති නමුත් තවමත් නියෝජිතයින් මත රඳා පවතී. නියෝජිතයින් නිර්වචනය කිරීම නිසැකවම ක්‍රියාත්මක වන නමුත් සමහර අයට දර්ශක හෝ කේත වාරණ සම්මත කිරීම පහසු වනු ඇත.

UINavigators සහ segues සමඟ, යටත් පාලක වෙත තොරතුරු යැවීමට සහ තොරතුරු නැවත ලබා ගැනීමට පහසු ක්‍රම තිබේ. ARC විසින් NSObjects වෙතින් ලබාගත් දේ වෙත යොමු කිරීමේ ලක්ෂ්‍යයන් සරල කරයි, එබැවින් ඔබට යම් දත්ත එකතු කිරීමට / වෙනස් කිරීමට / වෙනස් කිරීමට යටත් පාලකයට අවශ්‍ය නම්, එය විකෘති අවස්ථාවකට යොමු කරන්න. බ්ලොක් මඟින් සම්මත කිරීමේ ක්‍රියාවන් පහසු කරයි, එවිට ඔබට ඔබගේ ඉහළ මට්ටමේ පාලකය වෙත ක්‍රියා කිරීමට ආරාධිත පාලකය අවශ්‍ය නම්, එය වාරණයක් පසු කරන්න. ඔබට අර්ථවත් වන තර්ක ගණනාවක් පිළිගැනීමට ඔබ වාරණය අර්ථ දක්වයි. දේවල් වඩා හොඳින් ගැලපෙන්නේ නම් ඔබට බහු වාරණ භාවිතා කිරීමට API නිර්මාණය කළ හැකිය.

සෙග් මැලියම් සඳහා සුළු උදාහරණ දෙකක් මෙන්න. පළමුවැන්න ආදානය සඳහා සම්මත කර ඇති එක් පරාමිතියක් පෙන්වන අතර දෙවනුව ප්‍රතිදානය සඳහා ය.

// Prepare the destination view controller by passing it the input we want it to work on
// and the results we will look at when the user has navigated back to this controller's view.

- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender
{
    [[segue destinationViewController]

     // This parameter gives the next controller the data it works on.
     segueHandoffWithInput:self.dataForNextController

     // This parameter allows the next controller to pass back results
     // by virtue of both controllers having a pointer to the same object.
     andResults:self.resultsFromNextController];
}

මෙම දෙවන උදාහරණයෙන් දැක්වෙන්නේ දෙවන තර්කය සඳහා ඇමතුම් ලබා ගැනීමේ වාරණයක් පසු කිරීම ය. මම කුට්ටි භාවිතා කිරීමට කැමතියි, මන්ද එය අදාළ තොරතුරු ප්‍රභවයේ සමීපව තබා ගන්නා බැවිනි - ඉහළ මට්ටමේ ප්‍රභවය.

// Prepare the destination view controller by passing it the input we want it to work on
// and the callback when it has done its work.

- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender
{
    [[segue destinationViewController]

     // This parameter gives the next controller the data it works on.
     segueHandoffWithInput:self.dataForNextController

     // This parameter allows the next controller to pass back results.
     resultsBlock:^(id results) {
         // This callback could be as involved as you like.
         // It can use Grand Central Dispatch to have work done on another thread for example.
        [self setResultsFromNextController:results];
    }];
}

41

ViewController 2 (ගමනාන්තය) සිට viewController 1 (Source) වෙත දත්ත ආපසු යැවීම වඩාත් සිත්ගන්නා කරුණකි. ඔබ කතන්දර පුවරුව භාවිතා කරන බව උපකල්පනය කිරීම මම සොයාගත් සියලු ක්‍රම වේ:

  • නියෝජිත
  • දැනුම්දීම
  • පරිශීලක පෙරනිමි
  • සිංගල්ටන්

ඒවා දැනටමත් මෙහි සාකච්ඡා කර ඇත.

තවත් ක්‍රම ඇති බව මට පෙනී ගියේය:

බ්ලොක් කෝල්බැක් භාවිතා කිරීම:

prepareForSegueVC1 හි ඇති ක්‍රමයේදී එය භාවිතා කරන්න

NextViewController *destinationVC = (NextViewController *) segue.destinationViewController;
[destinationVC setDidFinishUsingBlockCallback:^(NextViewController *destinationVC)
{
    self.blockLabel.text = destination.blockTextField.text;
}];

කතන්දර පුවරු භාවිතා කිරීම ඉවත් කරන්න (පිටවීම)

VC 1 හි UIStoryboardSegue තර්කය සමඟ ක්‍රමයක් ක්‍රියාත්මක කරන්න, මේ ආකාරයට:

-(IBAction)UnWindDone:(UIStoryboardSegue *)segue { }

කතන්දර පුවරුවේ vc හි හරිත පිටවීමේ බොත්තමට (ආපසු හැරවීම) බොත්තම "ආපසු" බොත්තම සම්බන්ධ කරන්න. දැන් ඔබට "ආපසු යන" සීගු එකක් තිබේ, එබැවින් ඔබට VC2 හි සූදානම් කිරීම සඳහා ගමනාන්තය දර්ශන පාලක දේපල භාවිතා කළ හැකි අතර VC1 හි ඕනෑම දේපලක් ආපසු යාමට පෙර වෙනස් කළ හැකිය.

  • කතන්දර පුවරු භාවිතා කිරීමේ තවත් විකල්පයක් Undwind (Exit) - ඔබට VC1 හි ලියා ඇති ක්‍රමය භාවිතා කළ හැකිය

    -(IBAction)UnWindDone:(UIStoryboardSegue *)segue {
        NextViewController *nextViewController = segue.sourceViewController;
        self.unwindLabel.text = nextViewController.unwindPropertyPass;
    } 

    VC1 හි සූදානම් කිරීම සඳහා ඔබට බෙදා ගැනීමට අවශ්‍ය ඕනෑම දේපලක් වෙනස් කළ හැකිය.

නොවරදින විකල්ප දෙකෙහිම ඔබට බොත්තමෙහි ටැග් ගුණාංග සැකසිය හැකි අතර එය සූදානම් කිරීමේ ෆෝසෙගු හි පරීක්ෂා කරන්න.

මම සාකච්ඡාවට යමක් එකතු කළා යැයි සිතමි.

:) චියර්ස්.


40

දත්ත හුවමාරු කර ගැනීම සඳහා විවිධ ක්‍රම තිබේ.

  1. ඔබට සැමවිටම දත්ත බෙදා ගත හැකිය NSUserDefaults. ඔබ කැමති යතුරකට සාපේක්ෂව ඔබට බෙදා ගැනීමට අවශ්‍ය අගය සකසා NSUserDefaultඊළඟ දර්ශන පාලකයේ එම යතුර හා සම්බන්ධිත අගය ලබා ගන්න .

    [[NSUserDefaults standardUserDefaults] setValue:value forKey:key]
    [[NSUserDefaults standardUserDefaults] objectForKey:key]
  2. ඔබට දේපලක් නිර්මාණය කළ හැකිය viewcontrollerA. වස්තුවක් නිර්මාණය viewcontrollerAතුළ viewcontrollerBහා දේපළ අපේක්ෂිත අගය නියම.

  3. මේ සඳහා ඔබට අභිරුචි නියෝජිතයින් ද නිර්මාණය කළ හැකිය.


30
NSUserDefaults හි සාමාන්‍ය අරමුණ වන්නේ යෙදුම් ක්‍රියාත්මක කිරීම් අතර පවතින පරිශීලක මනාපයන් ගබඩා කිරීමයි, එබැවින් පැහැදිලිව ඉවත් නොකළහොත් මෙහි ගබඩා කර ඇති ඕනෑම දෙයක් මෙහි රැඳෙනු ඇත. යෙදුමක දර්ශන පාලකයන් (හෝ වෙනත් වස්තූන්) අතර තොරතුරු යැවීමට මෙය භාවිතා කිරීම ඇත්තෙන්ම නරක අදහසකි.
හෝසේ ගොන්සාලෙස්

30

ඔබට එක් පාලකයකුගේ සිට තවත් දත්තයකට දත්ත යැවීමට අවශ්‍ය නම් මෙම කේතය උත්සාහ කරන්න

FirstViewController.h

@property (nonatomic, retain) NSString *str;

SecondViewController.h

@property (nonatomic, retain) NSString *str1;

FirstViewController.m

- (void)viewDidLoad
   {
     // message for the second SecondViewController
     self.str = @"text message";

     [super viewDidLoad];
   }

-(IBAction)ButtonClicked
 {
   SecondViewController *secondViewController = [[SecondViewController alloc] initWithNibName:@"SecondViewController" bundle:nil];
   secondViewController.str1 = str;
  [self.navigationController pushViewController:secondViewController animated:YES];
 }

29

මෙය ඉතා පැරණි පිළිතුරක් වන අතර මෙය විරෝධී රටාවකි, කරුණාකර නියෝජිතයින් භාවිතා කරන්න. මෙම ප්‍රවේශය භාවිතා නොකරන්න !!

1. දෙවන දර්ශන පාලකයේ පළමු දර්ශන පාලකයේ උදාහරණය සාදා එහි දේපල සාදන්න @property (nonatomic,assign).

2.SecondviewController මෙම දර්ශන පාලකයේ උදාහරණය පවරන්න .

2. ඔබ තේරීමේ මෙහෙයුම අවසන් කළ විට අරාව පළමු දර්ශන පාලකයට පිටපත් කරන්න, ඔබ දෙවන දර්ශනය මුදා හරින විට, පළමු දර්ශනය අරාව දත්ත රඳවා ගනී.

මෙය උපකාරී වේ යැයි සිතමු.


2
දර්ශන පාලකයන් අතර ඉතා දුරස්ථ සම්බන්ධතාවයක් ඇති කරන බැවින් මෙය නිවැරදි මාර්ගය බව මම විශ්වාස නොකරමි. ඇත්ත වශයෙන්ම එම්වීසී වලට ඇලී නැත.
මැට් මිල

1
ඔබට MVC දැඩි ලෙස අනුගමනය කිරීමට අවශ්‍ය නම්, NSNotificationCenter භාවිතා කරන්න ViewControllerA සිට ViewControllerB වෙත ක්‍රමයක් කැඳවිය හැකිය, මෙය පරීක්ෂා කර බලන්න u
kaar3k

28

මම දීර් solution කාලයක් තිස්සේ මෙම විසඳුම සොයමින් සිටියෙමි, ඇට්ලාස්ට් මට එය හමු විය. පළමුවෙන්ම ඔබේ SecondViewController.h ගොනුවේ ඇති සියලුම වස්තු ප්‍රකාශ කරන්න

@interface SecondViewController: UIviewController 
{
    NSMutableArray *myAray;
    CustomObject *object;
}

දැන් ඔබේ ක්‍රියාත්මක කිරීමේ ගොනුවේ මේ වගේ වස්තූන් සඳහා මතකය වෙන් කරන්න

- (id)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil
{
     self = [super initWithNibName:nibNameOrNil bundle:nibBundleOrNil];
     if (self) 
     {
         // Custom initialization
         myAray=[[NSMutableArray alloc] init];
         object=[[CustomObject alloc] init];
     }
     return self;
}

දැන් ඔබ මතකය Arrayහා වස්තුව සඳහා වෙන් කර ඇත . මෙය තල්ලු කිරීමට පෙර ඔබට එම මතකය පුරවා ගත හැකියViewController

ඔබගේ SecondViewController.h වෙත ගොස් ක්‍රම දෙකක් ලියන්න

-(void)setMyArray:(NSArray *)_myArray;
-(void)setMyObject:(CustomObject *)_myObject;

ක්‍රියාත්මක කිරීමේ ගොනුවේදී ඔබට ශ්‍රිතය ක්‍රියාත්මක කළ හැකිය

-(void)setMyArray:(NSArray *)_myArray
{
     [myArra addObjectsFromArray:_myArray];
}
-(void)setMyObject:(CustomObject *)_myObject
{
     [object setCustomObject:_myObject];
}

ඔබ CustomObjectසමඟ එය සැකසුම් ශ්‍රිතයක් තිබිය යුතු යැයි අපේක්ෂා කරයි .

දැන් ඔබේ මූලික වැඩ කටයුතු අවසන්. ඔබට තල්ලු කිරීමට අවශ්‍ය ස්ථානයට ගොස් SecondViewControllerපහත සඳහන් දෑ කරන්න

SecondViewController *secondView= [[SecondViewController alloc] initWithNibName:@"SecondViewController " bundle:[NSBundle MainBundle]] ;
[secondView setMyArray:ArrayToPass];
[secondView setMyObject:objectToPass];
[self.navigationController pushViewController:secondView animated:YES ];

අක්ෂර වින්‍යාසය පිළිබඳ සැලකිලිමත් වන්න.


24

මෙය කළ හැකි ක්‍රමය නොවේ, ඔබ නියෝජිතයින් භාවිතා කළ යුතුය, මම හිතන්නේ අපට දර්ශන පාලකයන් දෙදෙනෙකු ඇති බව මම සිතමි. ViewController1 සහ ViewController2 මෙම චෙක්පත පළමු එකෙහි ඇති අතර එහි තත්වය වෙනස් වූ විට ඔබට ViewController2 හි යමක් කිරීමට අවශ්‍යය එය නිසි ආකාරයෙන් සාක්ෂාත් කර ගැනීම සඳහා, ඔබ පහත දේ කළ යුතුය:

ඔබේ ව්‍යාපෘතියට නව ගොනුවක් එක් කරන්න (Objective-C ප්‍රොටොකෝලය) ගොනුව -> නව, දැන් එයට ViewController1Delegate හෝ ඔබට අවශ්‍ය ඕනෑම දෙයක් නම් කර මේවා intinterface සහ endend විධානයන් අතර ලියන්න

@optional

- (void)checkStateDidChange:(BOOL)checked;

දැන් ViewController2.h වෙත ගොස් එක් කරන්න

#import "ViewController1Delegate.h"

ඉන්පසු එහි අර්ථ දැක්වීම වෙනස් කරන්න

@interface ViewController2: UIViewController<ViewController1Delegate>

දැන් ViewController2.m වෙත ගොස් ක්‍රියාත්මක කිරීමේදී ඇතුළත එකතු කරන්න:

- (void)checkStateDidChange:(BOOL)checked {
     if (checked) {
           // Do whatever you want here
           NSLog(@"Checked");
     }
     else {
           // Also do whatever you want here
           NSLog(@"Not checked");
     }
}

දැන් ViewController1.h වෙත ගොස් පහත දේපල එක් කරන්න:

@property (weak, nonatomic) id<ViewController1Delegate> delegate; 

දැන් ඔබ යම් සිදුවීමකින් පසු ViewController2 තුළ ViewController1 නිර්මාණය කරන්නේ නම්, ඔබ එය NIB ගොනු භාවිතයෙන් කළ යුතුය:

ViewController1* controller = [[NSBundle mainBundle] loadNibNamed:@"ViewController1" owner:self options:nil][0];
controller.delegate = self;
[self presentViewController:controller animated:YES completion:nil];

දැන් ඔබ සියල්ල සුදානම්ය, ViewController1 හි චෙක්පත වෙනස් වී ඇති බව ඔබ හඳුනාගත් විට, ඔබ කළ යුත්තේ පහත දැක්වේ

[delegate checkStateDidChange:checked]; // You pass here YES or NO based on the check state of your control

ඔබේ ප්‍රශ්නය මට නිසි ලෙස නොතේරුනේ නම් පැහැදිලි නැති දෙයක් තිබේදැයි කරුණාකර මට කියන්න.


23

ඔබට එකකින් තවත් දර්ශනයකට දත්ත යැවීමට අවශ්‍ය නම්, මෙන්න ඒ සඳහා ක්‍රමයක්:

අපට viewControllers ඇති බව පවසන්න: viewControllerA සහ viewControllerB

දැන් viewControllerB.h

@interface viewControllerB : UIViewController {

  NSString *string;
  NSArray *array;

}

- (id)initWithArray:(NSArray)a andString:(NSString)s;

ViewControllerB.m

#import "viewControllerB.h"

@implementation viewControllerB

- (id)initWithArray:(NSArray)a andString:(NSString)s {

   array = [[NSArray alloc] init];
   array = a;

   string = [[NSString alloc] init];
   string = s;

}

ViewControllerA.m

#import "viewControllerA.h"
#import "viewControllerB.h"

@implementation viewControllerA

- (void)someMethod {

  someArray = [NSArray arrayWithObjects:@"One", @"Two", @"Three", nil];
  someString = [NSString stringWithFormat:@"Hahahahaha"];

  viewControllerB *vc = [[viewControllerB alloc] initWithArray:someArray andString:someString];

  [self.navigationController pushViewController:vc animated:YES];
  [vc release];

}

එබැවින් කිසිදු නියෝජිතයෙකු සැකසීමකින් තොරව ඔබට viewControllerA වෙතින් viewControllerB වෙත දත්ත යැවිය හැකි ආකාරය මෙයයි. ;)


1
මම මගේ ව්‍යාපෘතියේ ur ර් කේතය භාවිතා කිරීමට උත්සාහ කළෙමි, නමුත් viewcontrollerB හි අගයන් ලබා ගැනීමට මට නොහැකි විය. ප්‍රශ්නය කුමක් විය හැකිදැයි මට කියන්න පුළුවන්ද?
එක්ස් කෝඩරය

1
J අජිත්තලා ඔබට ඔබේ කේතය නව ප්‍රශ්නයකට ඇලවිය හැකිද? මම ඔබේ ප්‍රශ්නය විසඳීමට උත්සාහ කරමි. :)
අනිරුද්

1
ආරම්භක ක්‍රම භාවිතා නොකිරීම වැරදියි, සහ දර්ශන පාලක A වෙතින් vcB.string = as "asdf" වැනි දෙයක් කරන්න?
khanh.tran.vinh

1
AR khanh.tran.vinh ඔබ ARC භාවිතා කරනවාද නැද්ද යන්න මත රඳා පවතී.
අනිරුද්

21

මෙය පරාජිත විෂයක් බව මම දනිමි, නමුත් මෙම ප්‍රශ්නයට ස්විෆ්ට් බෑවුමකින් පිළිතුරු දීමට සහ හිස් ඇටකටු නිදසුනක් අවශ්‍ය අයට, මෙන්න ඔබ යන්නට සෙග් එකක් භාවිතා කරන්නේ නම් දත්ත සම්ප්‍රේෂණය කිරීමේ මගේ ක්‍රමය.

එය ඉහත ඒවාට සමාන නමුත් බොත්තම්, ලේබල් සහ එවැනි දේ නොමැතිව. එක් දෘෂ්ටියකින් තවත් දෘෂ්ටියකට දත්ත යැවීම පමණි.

කතන්දර පුවරුව සැකසීම

කොටස් තුනක් ඇත.

  1. යවන්නා
  2. සීගු
  3. ලබන්නා

මෙය ඉතා සරල දර්ශන පිරිසැලසුමකි.


ඉතා සරල දර්ශන පිරිසැලසුම.  සටහන: සංචාලන පාලකයක් නොමැත


මෙන්න යවන්නා සඳහා සැකසුම


යවන්නා


මෙන්න ලබන්නා සඳහා සැකසුම.


ලබන්නා


අවසාන වශයෙන්, සෙග් සඳහා සැකසුම.


Segue Identifier


දර්ශන පාලකයන්

අපි මෙය සරල ලෙස තබා ඇති බැවින් බොත්තම් නැත, ක්‍රියා නොවේ, අපි යෙදුම යවන විට යවන්නාගේ සිට ග්‍රාහකයා වෙත දත්ත ගෙන යමින් සම්ප්‍රේෂණය කළ අගය කොන්සෝලය වෙත ප්‍රතිදානය කරයි.

මෙම පිටුව මුලින් පටවන ලද අගය ගෙන එය දිගේ ගමන් කරයි.

import UIKit


class ViewControllerSender: UIViewController {

    // THE STUFF - put some info into a variable
    let favoriteMovie = "Ghost Busters"

    override func viewDidAppear(animated: Bool) {
        // PASS IDENTIFIER - go to the recieving view controller.
        self.performSegueWithIdentifier("goToReciever", sender: self)
    }

    override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {

        //GET REFERENCE - ...to the receiver view.
        var viewControllerReceiver = segue.destinationViewController as? ViewControllerReceiver

        //PASS STUFF - pass the variable along to the target.
        viewControllerReceiver!.yourFavMovie = self.favoriteMovie

    }

}

මෙම පිටුව විචල්‍යයේ අගය පටවන විට එය කොන්සෝලය වෙත යවයි. මෙම අවස්ථාව වන විට, අපගේ ප්‍රියතම චිත්‍රපටය එම විචල්‍යයේ තිබිය යුතුය.

import UIKit

class ViewControllerReceiver: UIViewController {

    //Basic empty variable waiting for you to pass in your fantastic favorite movie.
    var yourFavMovie = ""

    override func viewDidLoad() {
        super.viewDidLoad()

        //And now we can view it in the console.
        println("The Movie is \(self.yourFavMovie)")

    }   
}

ඔබට සෙග් එකක් භාවිතා කිරීමට අවශ්‍ය නම් සහ ඔබේ පිටු සංචාලන පාලකයක් යටතේ නොමැති නම් ඔබට එය විසඳිය හැක්කේ එලෙසිනි.

එය ක්‍රියාත්මක වූ පසු එය ස්වයංක්‍රීයව ග්‍රාහක දර්ශනයට මාරුවිය යුතු අතර යවන්නාගේ සිට ලබන්නා වෙත අගය ලබා දිය යුතුය.

හොස්ට් බස්ටර්ස් යනු සම්භාව්‍ය ජනතාවකි.


19

මගේ නඩුවේදී මම යෙදුමේ සෑම තැනකම පාහේ දත්ත වලට ප්‍රවේශ වීමට ඉඩ දෙන ගෝලීය වස්තුවක් ලෙස ක්‍රියා කළ හැකි තනි පන්තියක් භාවිතා කළෙමි. පළමු දෙය නම් සිංගල්ටන් පන්තියක් තැනීමයි. කරුණාකර පිටුව වෙත යොමු වන්න, " මගේ පරමාර්ථය-සී සිංගල්ටන් පෙනුම කුමක් විය යුතුද? " තවද, වස්තුව ගෝලීයව ප්‍රවේශ විය හැකි පරිදි කිරීමට මම කළේ appName_Prefix.pchසෑම පන්තියකම ආනයන ප්‍රකාශය යෙදීම සඳහා ආනයනය කිරීමයි. මෙම වස්තුවට ප්‍රවේශ වීමට සහ භාවිතා කිරීමට, මම සරලවම පන්ති ක්‍රමය ක්‍රියාත්මක කළේ එහි විචල්‍යයන් අඩංගු හවුල් අවස්ථාව නැවත ලබා දීමට ය


මෙය නිවැරදි පිළිතුරයි. සිංගල්ටන් එකක් "ආකෘතිය" ලෙස භාවිතා කරන්න. කාලෙබ් පවසන පරිදි "ඔබේ යෙදුමේ ආකෘතිය නූල් පෙළක් තරම් සරල විය හැකිය" . ස්විෆ්ට් හි සිංගල්ටන් එකක් කිරීම සැබවින්ම සුළුපටු බව සැලකිල්ලට ගැනීම වැදගත්ය . (එතරම් සරල නම් මෙහි සඳහන් කිරීම පවා වටින්නේ නැත - ගූගල් පමණි.) නව ක්‍රමලේඛකයින් සඳහා, සිංගල්ටන් එකක් සෑදීම බූරුවාගේ සැබෑ වේදනාවක් බව තේරුම් ගැනීම වටී . කෙසේ වෙතත්, සිංගල්ටන් යනු iOS ක්‍රමලේඛනයේ කේන්ද්‍රීය වේ - ඇපල් කරන සෑම දෙයක්ම සිංගල්ටන් ය. ඒ නිසාම ඇපල් විසින් සිංගල්ටන් නිසියාකාරව සෑදීම සඳහා (ස්විෆ්ට් හි) සත්‍යයක් බවට පත් කළේය.
ෆැට්ටි

1
කෙසේ වෙතත්, මේ දිනවල (2016+) "සියල්ල iOS හි බහාලුම් දර්ශනයක්" බව සලකන්න. තිරය ​​මත ඔබ කරන සෑම දෙයක්ම ඔබ කුඩා බහාලුම් දර්ශනයක් සාදයි. බහාලුම් දර්ශන "ඉහළ සහ පහළ" දාම ලබා ගැනීම තරමක් සුළු කාරණයක් (අනාගතයේදී ඇපල් එය පහසු කරනු ඇත), ඔබ කෙසේ හෝ සෑම බහාලුම් දර්ශනයක් සඳහාම මෙය කරයි. එබැවින්, ඔබ එය කෙසේ හෝ කර ඇත්නම් - ඔබට පිළිතුර ඇත; සිංගල්ටන් අවශ්‍ය නොවේ. බහාලුම් දර්ශන හැඳින්වීම ... stackoverflow.com/a/23403979/294884
ෆැට්ටි

19

ස්විෆ්ට් 5

වෙල් මැට් ප්‍රයිස්ගේ පිළිතුර දත්ත සම්ප්‍රේෂණය කිරීම සඳහා ඉතා සුදුසු නමුත් නවතම ස්විෆ්ට් අනුවාදයෙන් මම එය නැවත ලිවීමට යන්නේ නව සින්ටැක්ස් සහ ක්‍රම / රාමු හේතුවෙන් නව ක්‍රමලේඛකයින් එය අභියෝගාත්මක නොවන බව මා විශ්වාස කරන හෙයිනි.

දර්ශන පාලකයන් අතර දත්ත සම්ප්‍රේෂණය කිරීම සඳහා විවිධ විකල්ප තිබේ.

  1. සංචාලන පාලක තල්ලු භාවිතා කිරීම
  2. Segue භාවිතා කිරීම
  3. නියෝජිතයා භාවිතා කිරීම
  4. දැනුම්දීම් නිරීක්ෂකය භාවිතා කිරීම
  5. බ්ලොක් භාවිතා කිරීම

මම ඔහුගේ තර්කනය ස්විෆ්ට් හි නවතම iOS රාමුව සමඟ නැවත ලිවීමට යන්නෙමි


සංචාලන පාලක තල්ලු හරහා දත්ත යැවීම : ViewControllerA සිට ViewControllerB දක්වා

පියවර 1. ViewControllerB හි විචල්‍යය ප්‍රකාශ කරන්න

var isSomethingEnabled = false

පියවර 2. ViewControllerB 'ViewDidLoad ක්‍රමයේදී විචල්යය මුද්‍රණය කරන්න

override func viewDidLoad() {
        super.viewDidLoad()
        //Print value received through segue, navigation push
        print("Value of 'isSomethingEnabled' from ViewControllerA : ", isSomethingEnabled)
    }

පියවර 3. සංචාලන පාලකය හරහා තල්ලු කරන අතරතුර ViewControllerA පාස් දත්ත

if let viewControllerB = UIStoryboard(name: "Main", bundle: nil).instantiateViewController(withIdentifier: "ViewControllerB") as? ViewControllerB {
        viewControllerB.isSomethingEnabled = true
        if let navigator = navigationController {
            navigator.pushViewController(viewControllerB, animated: true)
        }
    }

එබැවින් සම්පූර්ණ කේතය මෙන්න:

ViewControllerA

import UIKit

class ViewControllerA: UIViewController  {

    override func viewDidLoad() {
        super.viewDidLoad()
    }

    //MARK:Passing Data through Navigation PushViewController
    @IBAction func goToViewControllerB(_ sender: Any) {

        if let viewControllerB = UIStoryboard(name: "Main", bundle: nil).instantiateViewController(withIdentifier: "ViewControllerB") as? ViewControllerB {
            viewControllerB.isSomethingEnabled = true
            if let navigator = navigationController {
                navigator.pushViewController(viewControllerB, animated: true)
            }
        }
    }
}

ViewControllerB

import UIKit

class ViewControllerB: UIViewController {

    //MARK:  - Variable for Passing Data through Navigation push   
    var isSomethingEnabled = false

    override func viewDidLoad() {
        super.viewDidLoad()
        //Print value received through navigation push
        print("Value of 'isSomethingEnabled' from ViewControllerA : ", isSomethingEnabled)
    }
}

Segue හරහා දත්ත සම්ප්‍රේෂණය කිරීම : ViewControllerA සිට ViewControllerB දක්වා

පියවර 1. ViewControllerA සිට ViewControllerB වෙත Segue සාදන්න සහ පහත දැක්වෙන පරිදි කතන්දර පුවරුවේ Identifier = showDetailSegue ලබා දෙන්න

රූප විස්තරය මෙහි ඇතුළත් කරන්න

පියවර 2. ViewControllerB දී නම් ශක්ය ප්රකාශ isSomethingEnabled හා එහි අගය මුද්රණය කරන්න.

පියවර 3. ViewControllerA pass හි Segue පසු කරන විට SomethingEnabled හි අගය වේ

එබැවින් සම්පූර්ණ කේතය මෙන්න:

ViewControllerA

import UIKit

class ViewControllerA: UIViewController  {

    override func viewDidLoad() {
        super.viewDidLoad()
    }

    //MARK:  - - Passing Data through Segue  - - 
    @IBAction func goToViewControllerBUsingSegue(_ sender: Any) {
        performSegue(withIdentifier: "showDetailSegue", sender: nil)
    }

    //Segue Delegate Method
    override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
        if (segue.identifier == "showDetailSegue") {
            let controller = segue.destination as? ViewControllerB
            controller?.isSomethingEnabled = true//passing data
        }
    }
}

ViewControllerB

import UIKit

class ViewControllerB: UIViewController {
    var isSomethingEnabled = false

    override func viewDidLoad() {
        super.viewDidLoad()
        //Print value received through segue
        print("Value of 'isSomethingEnabled' from ViewControllerA : ", isSomethingEnabled)
    }
}

නියෝජිතයා හරහා දත්ත යැවීම : ViewControllerB සිට ViewControllerA දක්වා

පියවර 1. ViewControllerB ගොනුවේ ප්‍රොටෝකෝලය ViewControllerBDelegate ප්‍රකාශ කරන්න නමුත් පන්තියෙන් පිටත

protocol ViewControllerBDelegate: NSObjectProtocol {

    // Classes that adopt this protocol MUST define
    // this method -- and hopefully do something in
    // that definition.
    func addItemViewController(_ controller: ViewControllerB?, didFinishEnteringItem item: String?)
}

පියවර 2. ViewControllerB හි නියෝජිත විචල්‍ය අවස්ථාව ප්‍රකාශයට පත් කරන්න

var delegate: ViewControllerBDelegate?

පියවර 3. ViewControllerB හි viewDidLoad ක්‍රමය තුළ නියෝජිතයින් සඳහා දත්ත යවන්න

delegate?.addItemViewController(self, didFinishEnteringItem: "Data for ViewControllerA")

පියවර 4. ViewControllerA හි ViewControllerBDelegate තහවුරු කරන්න

class ViewControllerA: UIViewController, ViewControllerBDelegate  {
// to do
}

පියවර 5. ඔබ ViewControllerA හි නියෝජිතයා ක්‍රියාත්මක කරන බව තහවුරු කරන්න

if let viewControllerB = UIStoryboard(name: "Main", bundle: nil).instantiateViewController(withIdentifier: "ViewControllerB") as? ViewControllerB {
            viewControllerB.delegate = self//confirming delegate
            if let navigator = navigationController {
                navigator.pushViewController(viewControllerB, animated: true)
            }
        }

පියවර 6. ViewControllerA හි දත්ත ලැබීම සඳහා නියෝජිත ක්‍රමයක් ක්‍රියාත්මක කරන්න

func addItemViewController(_ controller: ViewControllerB?, didFinishEnteringItem item: String?) {
        print("Value from ViewControllerB's Delegate", item!)
    }

එබැවින් සම්පූර්ණ කේතය මෙන්න:

ViewControllerA

import UIKit

class ViewControllerA: UIViewController, ViewControllerBDelegate  {

    override func viewDidLoad() {
        super.viewDidLoad()
    }

    //Delegate method
    func addItemViewController(_ controller: ViewControllerB?, didFinishEnteringItem item: String?) {
        print("Value from ViewControllerB's Delegate", item!)
    }

    @IBAction func goToViewControllerForDelegate(_ sender: Any) {

        if let viewControllerB = UIStoryboard(name: "Main", bundle: nil).instantiateViewController(withIdentifier: "ViewControllerB") as? ViewControllerB {
            viewControllerB.delegate = self
            if let navigator = navigationController {
                navigator.pushViewController(viewControllerB, animated: true)
            }
        }
    }
}

ViewControllerB

import UIKit

//Protocol decleare
protocol ViewControllerBDelegate: NSObjectProtocol {
    // Classes that adopt this protocol MUST define
    // this method -- and hopefully do something in
    // that definition.
    func addItemViewController(_ controller: ViewControllerB?, didFinishEnteringItem item: String?)
}

class ViewControllerB: UIViewController {
    var delegate: ViewControllerBDelegate?

    override func viewDidLoad() {
        super.viewDidLoad()
        //MARK:  - - - -  Set Data for Passing Data through Delegate  - - - - - -
        delegate?.addItemViewController(self, didFinishEnteringItem: "Data for ViewControllerA")
    }
}

දැනුම්දීම් නිරීක්ෂකය හරහා දත්ත යැවීම : ViewControllerB සිට ViewControllerA දක්වා

පියවර 1. ViewControllerB හි දැනුම්දීම් නිරීක්ෂකයා තුළ දත්ත සකසා පළ කරන්න

let objToBeSent = "Test Message from Notification"
        NotificationCenter.default.post(name: Notification.Name("NotificationIdentifier"), object: objToBeSent)

පියවර 2. ViewControllerA හි දැනුම්දීම් නිරීක්ෂකය එක් කරන්න

NotificationCenter.default.addObserver(self, selector: #selector(self.methodOfReceivedNotification(notification:)), name: Notification.Name("NotificationIdentifier"), object: nil)

පියවර 3. ViewControllerA හි දැනුම්දීම් දත්ත අගය ලබා ගන්න

@objc func methodOfReceivedNotification(notification: Notification) {
        print("Value of notification : ", notification.object ?? "")
    }

එබැවින් සම්පූර්ණ කේතය මෙන්න:

ViewControllerA

import UIKit

class ViewControllerA: UIViewController{

    override func viewDidLoad() {
        super.viewDidLoad()

        // add observer in controller(s) where you want to receive data
        NotificationCenter.default.addObserver(self, selector: #selector(self.methodOfReceivedNotification(notification:)), name: Notification.Name("NotificationIdentifier"), object: nil)
    }

    //MARK: Method for receiving Data through Post Notification 
    @objc func methodOfReceivedNotification(notification: Notification) {
        print("Value of notification : ", notification.object ?? "")
    }
}

ViewControllerB

import UIKit

class ViewControllerB: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        //MARK:Set data for Passing Data through Post Notification
        let objToBeSent = "Test Message from Notification"
        NotificationCenter.default.post(name: Notification.Name("NotificationIdentifier"), object: objToBeSent)
    }
}

බ්ලොක් හරහා දත්ත යැවීම : ViewControllerB සිට ViewControllerA දක්වා

පියවර 1. ViewControllerB හි වාරණය ප්‍රකාශ කරන්න

var AuthorizationCompletionBlock: ((බූල්) -> ())? = {_ in}

පියවර 2. ViewControllerB හි දත්ත වාරණය කරන්න

if authorizationCompletionBlock != nil
        {
            authorizationCompletionBlock!(true)
        }

පියවර 3. ViewControllerA හි වාරණ දත්ත ලබා ගන්න

//Receiver Block
                controller!.authorizationCompletionBlock = { isGranted in
                    print("Data received from Block is :", isGranted)
                }

එබැවින් සම්පූර්ණ කේතය මෙන්න:

ViewControllerA

import UIKit

class ViewControllerA: UIViewController  {

    override func viewDidLoad() {
        super.viewDidLoad()
    }

    //MARK:Method for receiving Data through Block
        override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
            if (segue.identifier == "showDetailSegue") {
                let controller = segue.destination as? ViewControllerB
                controller?.isSomethingEnabled = true

                //Receiver Block
                controller!.authorizationCompletionBlock = { isGranted in
                    print("Data received from Block is :", isGranted)
                }
            }
        }
}

ViewControllerB

import UIKit

class ViewControllerB: UIViewController {

    //MARK:Variable for Passing Data through Block
    var authorizationCompletionBlock:((Bool)->())? = {_ in}

    override func viewDidLoad() {
        super.viewDidLoad()

        //MARK:Set data for Passing Data through Block
        if authorizationCompletionBlock != nil
        {
            authorizationCompletionBlock!(true)
        }
    }
}

ඔබට සම්පූර්ණ නියැදි අයදුම්පත මගේ GitHub වෙතින් සොයාගත හැකිය කරුණාකර ඔබට මේ පිළිබඳව කිසියම් ප්‍රශ්නයක් (ප්‍රශ්න) ඇත්නම් මට දන්වන්න.


18

FirstViewController සිට SecondViewController අතර දත්ත පහත පරිදි වේ

උදාහරණයක් වශයෙන්:

FirstViewController සංගීත අගය ලෙස

StrFirstValue = @"first";

එබැවින් අපට මෙම අගය දෙවන පියවරේදී පහත පියවර භාවිතා කළ හැකිය

1> SecondViewController.h ගොනුවේ අපට නූල් වස්තුව කූඩයට දැමිය යුතුය

NSString *strValue;

2> .h ගොනුවේ පහත දැක්වෙන පරිදි දේපල ප්‍රකාශ කිරීමට අවශ්‍යය

@property (strong, nonatomic)  NSString *strSecondValue;

3> ශීර්ෂ ප්‍රකාශයට පහළින් ඇති FirstViewController.m ගොනුවේ එම අගය සංස්ලේෂණය කිරීම අවශ්‍ය වේ

@synthesize strValue;

සහ FirstViewController.h හි:

@property (strong, nonatomic)  NSString *strValue;

4> FirstViewController හි, අපි දෙවන දර්ශනය වෙත ගමන් කරන්නේ කුමන ක්‍රමයෙන්ද යන්න කරුණාකර එම ක්‍රමයේ පහත කේතය ලියන්න.

SecondViewController *secondView= [[SecondViewController alloc]     
initWithNibName:@"SecondViewController " bundle:[NSBundle MainBundle]];

[secondView setStrSecondValue:StrFirstValue];

[self.navigationController pushViewController:secondView animated:YES ];

SecondViewController හි සිටීමෙන් පසු, ඔබ නැවත FirstViewController වෙත දත්ත යවන්නේ කෙසේද?
bruno

18

MCViewFactory නම් ව්‍යාපෘතියක් හරහා මම දැනට මෙම ගැටලුවට විවෘත මූලාශ්‍ර විසඳුමකට දායක වෙමි, එය මෙහි සොයාගත හැකිය:

https://github.com/YetiHQ/manticore-iosviewfactory

අදහස වන්නේ ඇන්ඩ්‍රොයිඩ් හි අභිප්‍රාය පරමාදර්ශය අනුකරණය කිරීමයි, ගෝලීය කර්මාන්තශාලාවක් භාවිතා කරමින් ඔබ බලන්නේ කුමන දෘෂ්ටියද යන්න කළමනාකරණය කිරීම සහ දර්ශන අතර දත්ත මාරු කිරීම සහ සම්මත කිරීම සඳහා “අභිප්‍රායන්” භාවිතා කිරීම. සියලුම ලියකියවිලි ගිතුබ් පිටුවේ ඇත, නමුත් මෙහි විශේෂ අවස්ථා කිහිපයක් තිබේ:

ඔබ ඔබේ සියලු අදහස් .XIB ලිපිගොනු තුළ සකසා ඒවා කර්මාන්තශාලාව ආරම්භ කරන අතරතුර යෙදුම් නියෝජිතයා තුළ ලියාපදිංචි කරන්න.

// Register activities

MCViewFactory *factory = [MCViewFactory sharedFactory];

// the following two lines are optional. 
[factory registerView:@"YourSectionViewController"]; 

දැන්, ඔබේ උපකුලපතිවරයා තුළ, ඔබට නව උපකුලපතිවරයකු වෙත ගොස් දත්ත සම්මත කිරීමට අවශ්‍ය ඕනෑම වේලාවක, ඔබ නව අභිප්‍රායක් නිර්මාණය කර එහි ශබ්ද කෝෂයට දත්ත එක් කරයි (saveInstanceState). ඉන්පසු, කර්මාන්තශාලාවේ වර්තමාන අභිප්‍රාය සකසන්න:

MCIntent* intent = [MCIntent intentWithSectionName:@"YourSectionViewController"];
[intent setAnimationStyle:UIViewAnimationOptionTransitionFlipFromLeft];
[[intent savedInstanceState] setObject:@"someValue" forKey:@"yourKey"];
[[intent savedInstanceState] setObject:@"anotherValue" forKey:@"anotherKey"];
// ...
[[MCViewModel sharedModel] setCurrentSection:intent];

මෙයට අනුකූල වන ඔබගේ සියලු අදහස් MCViewController හි උප පංති විය යුතු අතර, එමඟින් නව onResume: ක්‍රමය අභිබවා යාමට ඔබට ඉඩ සලසයි, එමඟින් ඔබ සමත් වූ දත්ත වලට ප්‍රවේශ වීමට ඉඩ ලබා දේ.

-(void)onResume:(MCIntent *)intent {
    NSObject* someValue = [intent.savedInstanceState objectForKey:@"yourKey"];
    NSObject* anotherValue = [intent.savedInstanceState objectForKey:@"anotherKey"];

    // ...

    // ensure the following line is called, especially for MCSectionViewController
    [super onResume:intent];
}

ඔබගෙන් සමහරෙකුට මෙම විසඳුම ප්‍රයෝජනවත් / රසවත් යැයි සිතමි.


එවිට සියලු පාලක වස්තූන් හට ඕනෑම විෂය පථයක ලියාපදිංචි ශබ්ද කෝෂ ලබා ගැනීමට / සැකසීමට හැකිද? මෙය පහත් කරන්න.
ඉටාචි

15

ඊළඟට දේපල සාදන්න view controller .hසහ getter සහ setter යන්න අර්ථ දක්වන්න.

propertyNextVC හි NextVC.h හි මෙය එක් කරන්න

@property (strong, nonatomic) NSString *indexNumber;

එකතු කරන්න

@synthesize indexNumber; NextVC.m හි

අන්තිමට

NextVC *vc=[[NextVC alloc]init];

vc.indexNumber=@"123";

[self.navigationController vc animated:YES];

11

මෙය කිරීමට ක්‍රම ගණනාවක් ඇති අතර නිවැරදි දේ තෝරා ගැනීම වැදගත්ය. බොහෝ විට විශාලතම වාස්තු විද්‍යාත්මක තීරණ වලින් එකක් වන්නේ ආදර්ශ කේතය යෙදුම පුරා බෙදාගන්නේ හෝ ප්‍රවේශ වන්නේ කෙසේද යන්න මතය.

මම මේ ගැන බ්ලොග් සටහනක් ලිව්වේ ටික කලකට පෙර: ආකෘති කේතය බෙදා ගැනීම . මෙන්න කෙටි සාරාංශයක්:

බෙදාගත් දත්ත

එක් ප්‍රවේශයක් නම් දර්ශන පාලකයන් අතර ආදර්ශ වස්තු වෙත දර්ශකයන් බෙදා ගැනීමයි.

  • දත්ත සැකසීම සඳහා දර්ශන පාලකයන්ගේ (සංචාලනයේ හෝ ටැබ් තීරු පාලකයේ) තිරිසන් බල ක්‍රියාකාරීත්වය
  • දත්ත සූදානම් කරන්න ෆෝසෙගු (කතන්දර පුවරු නම්) හෝ init (ක්‍රමලේඛනය නම්)

සෙග් සඳහා සූදානම් වීම මෙහි බහුලව දක්නට ලැබෙන උදාහරණයකි:

override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
    var next = segue.destinationViewController as NextViewController
    next.dataSource = dataSource
}

ස්වාධීන ප්‍රවේශය

තවත් ප්‍රවේශයක් වන්නේ වරකට දත්ත පිරී ඇති තිරයක් හැසිරවීම සහ දර්ශන පාලකයන් එකිනෙකාට සම්බන්ධ කිරීම වෙනුවට එක් එක් දර්ශන පාලකය ස්වාධීනව ලබා ගත හැකි තනි දත්ත ප්‍රභවයක් වෙත එක් එක් දර්ශන පාලකය සම්බන්ධ කිරීමයි.

මෙය සිදු කර ඇති බව මා දුටු වඩාත් පොදු ක්‍රමය වන්නේ තනි අවස්ථාවකි. එබැවින් ඔබේ සිංගල්ටන් වස්තුව නම් DataAccessඔබට UIViewController හි viewDidLoad ක්‍රමයෙන් පහත දේ කළ හැකිය:

func viewDidLoad() {
    super.viewDidLoad()
    var data = dataAccess.requestData()
}

දත්ත පසුකර යාමට උපකාරී වන අතිරේක මෙවලම් තිබේ:

  • යතුරු අගය නිරීක්ෂණය කිරීම
  • NSNotification
  • මූලික දත්ත
  • NSFetchedResultsController
  • දත්ත මූලාශ්රය

මූලික දත්ත

මූලික දත්තවල ඇති හොඳ දෙය නම් එයට ප්‍රතිලෝම සම්බන්ධතා තිබීමයි. එබැවින් ඔබට නෝට්ස්වීව් කන්ට්‍රොලර් වෙත සටහන් වස්තුව ලබා දීමට අවශ්‍ය නම් එය නෝට්බුක් වැනි වෙනත් දෙයකට ප්‍රතිලෝම සම්බන්ධතාවයක් ඇති හෙයිනි. ඔබට NotesViewController හි සටහන් පොතේ දත්ත අවශ්‍ය නම් පහත සඳහන් දෑ කිරීමෙන් ඔබට වස්තු ප්‍රස්ථාරය ඉහළට යා හැකිය:

let notebookName = note.notebook.name

මගේ බ්ලොග් සටහනේ මේ ගැන වැඩිදුර කියවන්න: ආකෘති කේතය බෙදා ගැනීම


10

NewsViewController

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath
{
  [tbl_View deselectRowAtIndexPath:indexPath animated:YES];
  News *newsObj = [newstitleArr objectAtIndex:indexPath.row];
  NewsDetailViewController *newsDetailView = [[NewsDetailViewController alloc] initWithNibName:@"NewsDetailViewController" bundle:nil];

  newsDetailView.newsHeadlineStr = newsObj.newsHeadline;

  [self.navigationController pushViewController:newsDetailView animated:YES];
}

NewsDetailViewController.h

@interface NewsDetailViewController : UIViewController
@property(nonatomic,retain) NSString *newsHeadlineStr;
@end

NewsDetailViewController.m

@synthesize newsHeadlineStr;

10

ඔබ .xib ලිපිගොනු භාවිතා කරන විට එවැනි මෙහෙයුම් සිදු කිරීමට ඇති එකම විසඳුම නියෝජිත කණ්ඩායමයි. කෙසේ වෙතත් ඉහත විස්තර කර ඇති සියලුම පිළිතුරු storyboardඔබට නියෝජිතයින් භාවිතා කිරීමට අවශ්‍ය .xibs ගොනු සඳහා වේ. එය ඔබට කළ හැකි විසඳුම පමණි.

තවත් විසඳුමක් වන්නේ සිංගල්ටන් පන්ති රටාව භාවිතා කිරීම එක් වරක් ආරම්භ කර එය ඔබේ මුළු යෙදුම තුළම භාවිතා කිරීමයි.


10

ඔබට ViewControlerOne වෙතින් ViewControllerTwo වෙත දත්ත යැවීමට අවශ්‍ය නම් මේවා උත්සාහ කරන්න ..

ViewControlerOne.h හි මේවා කරන්න

 @property (nonatomic, strong) NSString *str1;

ViewControllerTwo.h හි මේවා කරන්න

 @property (nonatomic, strong) NSString *str2;

ViewControllerTwo.m හි str2 සංස්ලේෂණය කරන්න

@interface ViewControllerTwo ()
@end
@implementation ViewControllerTwo
@synthesize str2;

ViewControlerOne.m හි මේවා කරන්න

 - (void)viewDidLoad
 {
   [super viewDidLoad];

  // Data or string you wants to pass in ViewControllerTwo..
  self.str1 = @"hello world";

 }

බොත්තම් මත ක්ලික් කරන්න සිදුවීම මෙය කරන්න ..

-(IBAction)ButtonClicked
{ //Navigation on buttons click event from ViewControlerOne to ViewControlerTwo with transferring data or string..
  ViewControllerTwo *objViewTwo=[self.storyboard instantiateViewControllerWithIdentifier:@"ViewControllerTwo"];
  obj.str2=str1;
  [self.navigationController pushViewController: objViewTwo animated:YES];
}

ViewControllerTwo.m හි මේවා කරන්න

- (void)viewDidLoad
{
 [super viewDidLoad];
  NSLog(@"%@",str2);
}

10

ඔබගේ යෙදුමේ දර්ශන පාලකයන් හරහා ප්‍රවේශ වීමට ඔබට යෙදුම් නියෝජිතයා තුළ දත්ත සුරැකිය හැක. ඔබ කළ යුත්තේ යෙදුම් නියෝජිතයාගේ හවුල් අවස්ථාවක් නිර්මාණය කිරීම පමණි

AppDelegate *appDelegate = (AppDelegate *)[UIApplication sharedApplication].delegate;

උදාහරණයක් වශයෙන්

ඔබ එය ප්‍රකාශ කරන්නේ NSArray object *arrayXYZනම් ඔබට ඕනෑම දර්ශන පාලකයකින් එය ප්‍රවේශ කළ හැකියappDelegate.arrayXYZ


එය හැක්ටන් සඳහා තෝරා ගැනීමේ ක්‍රමයයි
හායි ෆෙන් කාවෝ

9

ඔබට එකකින් තවත් දර්ශනයකට දත්ත යැවීමට අවශ්‍ය නම්, මෙන්න ඒ සඳහා ක්‍රමයක්:

අපට viewControllers ඇති බව පවසන්න: ViewController සහ NewViewController.

ViewController.h හි

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController
{
    IBOutlet UITextField *mytext1,*mytext2,*mytext3,*mytext4;
}

@property (nonatomic,retain) IBOutlet UITextField *mytext1,*mytext2,*mytext3,*mytext4;

-(IBAction)goToNextScreen:(id)sender;

@end

ViewController.m හි

#import "ViewController.h"

#import "NewViewController.h"

@implementation ViewController
@synthesize mytext1,mytext2,mytext3,mytext4;

-(IBAction)goToNextScreen:(id)sender
{
    NSArray *arr = [NSArray arrayWithObjects:mytext1.text,mytext2.text,mytext3.text,mytext4.text, nil];


    NewViewController *newVc = [[NewViewController alloc] initWithNibName:@"NewViewController" bundle:nil];

    newVc.arrayList = arr;

    [self.navigationController pushViewController:newVc animated:YES];

}

NewViewController.h හි

#import <UIKit/UIKit.h>

@interface NewViewController : UITableViewController
{
    NSArray *arrayList;

    NSString *name,*age,*dob,*mobile;

}

@property(nonatomic, retain)NSArray *arrayList;

@end

NewViewController.m හි

#import "NewViewController.h"

#import "ViewController.h"

@implementation NewViewController
@synthesize arrayList;

#pragma mark - Table view data source

- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView
{

    // Return the number of sections.
    return 1;
}

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{

    // Return the number of rows in the section.
    return [arrayList count];
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    static NSString *CellIdentifier = @"Cell";
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
    if (cell == nil)
    {
         cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier];      
    }
    // Configure the cell...
    cell.textLabel.text = [arrayList objectAtIndex:indexPath.row];
    return cell;


}

@end

ඉතින් මේ ආකාරයෙන් අපට එක් දර්ශන පාලකයකුගේ සිට තවත් දර්ශන පාලකය වෙත දත්ත යැවිය හැකිය ...


8

පරිශීලක තෝරාගත් දේ අවලංගු කළ හැකි නම් දත්ත කැප කිරීම හෝ ඉවත දැමීම සඳහා NSProxy මත පදනම් වූ ආදර්ශ වස්තු සහ ව්‍යාජ වස්තු පිළිබඳ අදහසට මා කැමතිය.

එය තනි වස්තුවක් හෝ වස්තු කිහිපයක් බැවින් දත්ත සම්ප්‍රේෂණය කිරීම පහසු වන අතර ඔබට UINavigationController පාලකය යැයි කියමු නම්, ඔබට ආකෘතිය පිළිබඳ සඳහනක් තබා ගත හැකි අතර තල්ලු කළ සියලුම දර්ශන පාලකයන්ට එය සෘජුවම සංචාලන පාලකයෙන් ප්‍රවේශ විය හැකිය.


8

didSelectRowAtPathක්රමය භාවිතා කරමින් මෙය සංකීර්ණ කිරීම පිළිබඳව බොහෝ දෙනෙක් මම දැක ඇත්තෙමි . මම මගේ උදාහරණයේ මූලික දත්ත භාවිතා කරමි.

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

    //this solution is for using Core Data
    YourCDEntityName * value = (YourCDEntityName *)[[self fetchedResultsController] objectAtIndexPath: indexPath];

    YourSecondViewController * details = [self.storyboard instantiateViewControllerWithIdentifier:@"nameOfYourSecondVC"];//make sure in storyboards you give your second VC an identifier

    //Make sure you declare your value in the second view controller
    details.selectedValue = value;

    //Now that you have said to pass value all you need to do is change views
    [self.navigationController pushViewController: details animated:YES];

}

ක්‍රමවේදය තුළ කේත පේළි 4 ක් ඔබ අවසන් කර ඇත.


6

ඇත්ත වශයෙන්ම ක්‍රියාත්මක වන දර්ශන පාලක සන්නිවේදනය සිදු කිරීම සඳහා විවිධ ක්‍රම ඉදිරිපත් කරන මෙම ප්‍රශ්නවලට බොහෝ පිළිතුරු ඇත, නමුත් ඇත්ත වශයෙන්ම භාවිතා කිරීමට වඩාත්ම සුදුසු ඒවා සහ ඒවායින් වැළකී සිටිය යුත්තේ කුමන ඒවාදැයි සඳහන් කර නැත.

ප්රායෝගිකව, මගේ මතය අනුව නිර්දේශ කරනුයේ විසඳුම් කිහිපයක් පමණි:

  • දත්ත ඉදිරියට යැවීමට:
    • prepare(for:sender:)ක්‍රමවේදය ඉක්මවා යන්නUIViewControllerකතන්දර පුවරුවක් සහ කොටස් භාවිතා කරන විට
    • දර්ශන පාලක සංක්‍රාන්ති thtough කේතය සිදුකරන විට ආරම්භක හරහා හෝ ගුණාංග හරහා දත්ත සම්ප්‍රේෂණය කරන්න
  • දත්ත පසුපසට යැවීමට
    • යෙදුම බෙදාගත් තත්වය යාවත්කාලීන කරන්න (ඉහත ක්‍රමවලින් එකක් සමඟ ඔබට දර්ශන පාලකයන් අතර ඉදිරියට යා හැකිය)
    • නියෝජිත කණ්ඩායම භාවිතා කරන්න
    • නොවරදින සේගු භාවිතා කරන්න

භාවිතා නොකිරීමට මම නිර්දේශ කරන විසඳුම්:

  • නියෝජිත කණ්ඩායම භාවිතා කිරීම වෙනුවට සෘජුවම පෙර පාලකය යොමු කිරීම
  • සිංගල්ටන් හරහා දත්ත බෙදා ගැනීම
  • යෙදුම් නියෝජිතයා හරහා දත්ත යැවීම
  • පරිශීලක පෙරනිමි හරහා දත්ත බෙදා ගැනීම
  • දැනුම්දීම් හරහා දත්ත සම්ප්‍රේෂණය කිරීම

මෙම විසඳුම් කෙටිකාලීනව ක්‍රියාත්මක වුවද, යෙදුමේ ගෘහ නිර්මාණ ශිල්පය අවුල් කරන බොහෝ පරායත්තතා හඳුන්වා දෙන අතර පසුව තවත් ගැටලු ඇති කරයි.

උනන්දුවක් දක්වන අය සඳහා, මම මෙම කරුණු වඩාත් ගැඹුරින් හා විවිධ අඩුපාඩු ඉස්මතු කරන ලිපි කිහිපයක් ලිව්වෙමි:

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.