[ios] मैं उद्देश्य-सी में प्रतिनिधियों को कैसे बना सकता हूं?



8 Answers

अनुमोदित उत्तर बहुत अच्छा है, लेकिन यदि आप 1 मिनट के उत्तर की तलाश में हैं तो इसे आजमाएं:

MyClass.h फ़ाइल इस तरह दिखनी चाहिए (टिप्पणी के साथ प्रतिनिधि लाइन जोड़ें!)

#import <BlaClass/BlaClass.h>

@class MyClass;             //define class, so protocol can see MyClass
@protocol MyClassDelegate <NSObject>   //define delegate protocol
    - (void) myClassDelegateMethod: (MyClass *) sender;  //define delegate method to be implemented within another class
@end //end protocol

@interface MyClass : NSObject {
}
@property (nonatomic, weak) id <MyClassDelegate> delegate; //define MyClassDelegate as delegate

@end

MyClass.m फ़ाइल इस तरह दिखनी चाहिए

#import "MyClass.h"
@implementation MyClass 
@synthesize delegate; //synthesise  MyClassDelegate delegate

- (void) myMethodToDoStuff {
    [self.delegate myClassDelegateMethod:self]; //this will call the method implemented in your other class    
}

@end

किसी अन्य वर्ग में अपने प्रतिनिधि का उपयोग करने के लिए (UIViewController इस मामले में MyVC कहा जाता है) MyVC.h:

#import "MyClass.h"
@interface MyVC:UIViewController <MyClassDelegate> { //make it a delegate for MyClassDelegate
}

MyVC.m:

myClass.delegate = self;          //set its delegate to self somewhere

प्रतिनिधि विधि लागू करें

- (void) myClassDelegateMethod: (MyClass *) sender {
    NSLog(@"Delegates are great!");
}
Question

मुझे पता है कि प्रतिनिधि कैसे काम करते हैं, और मुझे पता है कि मैं उनका उपयोग कैसे कर सकता हूं।

लेकिन मैं उन्हें कैसे बना सकता हूं?




Let's start with an example , if we buy a product online ,it goes through process like shipping/delivery handled by different teams.So if shipping gets completed ,shipping team should notify delivery team & it should be one to one communication as broadcasting this information would be overhead for other people / vendor might want to pass this information only to required people.

So if we think in terms of our app, an event can be an online order & different teams can be like multiple views.

यहां कोड शिपिंग शिपिंग को डिलीवरी टीम के रूप में शिपिंग टीम और डिलिवरी व्यू के रूप में माना जाता है:

//Declare the protocol with functions having info which needs to be communicated
protocol ShippingDelegate : class {
    func productShipped(productID : String)
}
//shippingView which shows shipping status of products
class ShippingView : UIView
{

    weak var delegate:ShippingDelegate?
    var productID : String

    @IBAction func checkShippingStatus(sender: UIButton)
    {
        // if product is shipped
        delegate?.productShipped(productID: productID)
    }
}
//Delivery view which shows delivery status & tracking info
class DeliveryView: UIView,ShippingDelegate
{
    func productShipped(productID : String)
    {
        // update status on view & perform delivery
    }
}

//Main page on app which has both views & shows updated info on product whole status
class ProductViewController : UIViewController
{
    var shippingView : ShippingView
    var deliveryView : DeliveryView

    override func viewDidLoad() {
        super.viewDidLoad()
        // as we want to update shipping info on delivery view, so assign delegate to delivery object
        // whenever shipping status gets updated it will call productShipped method in DeliveryView & update UI.
        shippingView.delegate = deliveryView
        //
    }
}



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

एक प्रोटोकॉल नीचे घोषित किया जाना चाहिए:

@protocol ServiceResponceDelegate <NSObject>

- (void) serviceDidFailWithRequestType:(NSString*)error;
- (void) serviceDidFinishedSucessfully:(NSString*)success;

@end

यह सेवा वर्ग है जहां कुछ कार्य किया जाना चाहिए। यह दिखाता है कि प्रतिनिधि को कैसे परिभाषित किया जाए और प्रतिनिधि को कैसे सेट किया जाए। कार्य पूरा होने के बाद कार्यान्वयन वर्ग में प्रतिनिधि के तरीकों को बुलाया जाता है।

@interface ServiceClass : NSObject
{
id <ServiceResponceDelegate> _delegate;
}

- (void) setDelegate:(id)delegate;
- (void) someTask;

@end

@implementation ServiceClass

- (void) setDelegate:(id)delegate
{
_delegate = delegate;
}

- (void) someTask
{
/*

   perform task

*/
if (!success)
{
[_delegate serviceDidFailWithRequestType:@”task failed”];
}
else
{
[_delegate serviceDidFinishedSucessfully:@”task success”];
}
}
@end

यह मुख्य दृश्य वर्ग है जहां से प्रतिनिधि वर्ग को प्रतिनिधि को स्वयं सेट करके बुलाया जाता है। और हेडर वर्ग में भी प्रोटोकॉल लागू किया गया है।

@interface viewController: UIViewController <ServiceResponceDelegate>
{
ServiceClass* _service;
}

- (void) go;

@end

@implementation viewController

//
//some methods
//

- (void) go
{
_service = [[ServiceClass alloc] init];
[_service setDelegate:self];
[_service someTask];
}

यही वह है, और इस वर्ग में प्रतिनिधि विधियों को लागू करके, ऑपरेशन / कार्य पूरा हो जाने पर नियंत्रण वापस आ जाएगा।




ऐप्पल द्वारा अनुशंसित एक अच्छी प्रैक्टिस के रूप में, यह NSObject प्रोटोकॉल के अनुरूप प्रतिनिधि के लिए अच्छा है (जो परिभाषा द्वारा प्रोटोकॉल है)।

@protocol MyDelegate <NSObject>
    ...
@end

और अपने प्रतिनिधि के भीतर वैकल्पिक तरीकों को बनाने के लिए (यानी विधियों को जरूरी नहीं है), आप इस तरह @optional एनोटेशन का उपयोग कर सकते हैं:

@protocol MyDelegate <NSObject>
    ...
    ...
      // Declaration for Methods that 'must' be implemented'
    ...
    ...
    @optional
    ...
      // Declaration for Methods that 'need not necessarily' be implemented by the class conforming to your delegate
    ...
@end

तो जब आप वैकल्पिक रूप से निर्दिष्ट विधियों का उपयोग करते हैं, तो आपको respondsToSelector (आपकी कक्षा में) की आवश्यकता होती है, respondsToSelector अगर चयन (जो आपके प्रतिनिधि के अनुरूप है) वास्तव में आपके वैकल्पिक तरीके को लागू किया गया है या नहीं।




मान लें कि आपके पास एक कक्षा है जिसे आपने विकसित किया है और कुछ प्रतिनिधि होने पर इसे सूचित करने में सक्षम होने के लिए एक प्रतिनिधि संपत्ति घोषित करना चाहते हैं:

@class myClass;

@protocol myClassDelegate <NSObject>

-(void)myClass:(MyClass*)myObject requiredEventHandlerWithParameter:(ParamType*)param;

@optional
-(void)myClass:(MyClass*)myObject optionalEventHandlerWithParameter:(ParamType*)param;

@end


@interface MyClass : NSObject

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

@end

इसलिए आप MyClass शीर्षलेख फ़ाइल (या एक अलग शीर्षलेख फ़ाइल) में एक प्रोटोकॉल घोषित करते हैं, और आवश्यक / वैकल्पिक ईवेंट हैंडलर घोषित करते हैं कि आपके प्रतिनिधि को लागू / लागू करना चाहिए, फिर MyClass प्रकार ( id< MyClassDelegate> ) में एक संपत्ति घोषित करें जिसका अर्थ है कि कोई भी उद्देश्य सी क्लास जो प्रोटोकॉल MyClassDelegate अनुरूप है, आप देखेंगे कि प्रतिनिधि संपत्ति को कमजोर घोषित किया जाता है, यह बनाए रखने के चक्र को रोकने के लिए बहुत महत्वपूर्ण है (अक्सर प्रतिनिधि प्रतिनिधि MyClass उदाहरण को बरकरार रखता है ताकि अगर आप प्रतिनिधि को बनाए रखने के रूप में घोषित कर दें, तो दोनों उनमें से एक दूसरे को बनाए रखेंगे और उनमें से कोई भी कभी जारी नहीं होगा)।

आप यह भी देखेंगे कि प्रोटोकॉल विधियां MyClassDelegate इंस्टेंस को प्रतिनिधि के रूप में पैरामीटर के रूप में पास करती हैं, अगर प्रतिनिधि MyClassDelegate इंस्टेंस पर कुछ तरीकों को कॉल करना चाहता है तो यह सबसे अच्छा अभ्यास है और यह भी मदद करता है जब प्रतिनिधि खुद को MyClassDelegate रूप में कई MyClass उदाहरणों में घोषित करता है, जैसे जब आपके ViewController में एकाधिक UITableView's उदाहरण ViewController और आप सभी को UITableViewDelegate रूप में घोषित करते हैं।

और अपने MyClass अंदर आप प्रतिनिधि को घोषित घटनाओं के साथ सूचित करते हैं:

if([_delegate respondsToSelector:@selector(myClass: requiredEventHandlerWithParameter:)])
{
     [_delegate myClass:self requiredEventHandlerWithParameter:(ParamType*)param];
}

आप पहली बार जांचते हैं कि क्या आपका प्रतिनिधि प्रोटोकॉल विधि का जवाब देता है जिसे आप कॉल करने वाले हैं, यदि प्रतिनिधि इसे लागू नहीं करता है और ऐप तब क्रैश हो जाएगा (भले ही प्रोटोकॉल विधि आवश्यक हो)।




हो सकता है कि आप जो खो रहे हैं उसके साथ यह अधिक है:

यदि आप सी ++ से दृष्टिकोण के रूप में आ रहे हैं, तो प्रतिनिधियों को थोड़ा सा उपयोग करने में मदद मिलती है - लेकिन मूल रूप से 'वे बस काम करते हैं'।

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

यह अपनी खुद की वस्तुओं के साथ ऐसा करने के लिए पूरी तरह से तुच्छ है, कुछ खास नहीं चल रहा है, उदाहरण के लिए आप 27 ऑब्जेक्ट्स के -(void)setToBue; कर सकते हैं, सभी प्रकार के ऑब्जेक्ट्स, केवल 18 उनमें से कुछ में विधि है -(void)setToBue; अन्य 9 नहीं। तो 18 में से setToBlue पर setToBlue को कॉल करने के लिए, ऐसा कुछ करने की आवश्यकता है:

for (id anObject in myArray)
{
  if ([anObject respondsToSelector:@selector(@"setToBlue")])
     [anObject setToBlue]; 
}

प्रतिनिधियों के बारे में दूसरी बात यह है कि उन्हें बनाए रखा नहीं जाता है, इसलिए आपको हमेशा अपने MyClass dealloc विधि में प्रतिनिधि को सेट करना होगा।




अस्वीकरण: यह एक delegate बनाने के लिए Swift संस्करण है।

तो, प्रतिनिधियों क्या हैं? ... सॉफ्टवेयर विकास में, सामान्य पुन: प्रयोज्य समाधान आर्किटेक्चर हैं जो किसी दिए गए संदर्भ में सामान्य रूप से होने वाली समस्याओं को हल करने में मदद करते हैं, इसलिए इन "टेम्पलेट्स" को बोलने के लिए सबसे अच्छा डिजाइन पैटर्न के रूप में जाना जाता है। प्रतिनिधि एक डिज़ाइन पैटर्न होते हैं जो एक ऑब्जेक्ट को किसी अन्य ऑब्जेक्ट पर संदेश भेजने की अनुमति देता है जब कोई विशिष्ट घटना होती है। एक ऑब्जेक्ट की कल्पना करें ए ए ऑब्जेक्ट बी को एक्शन करने के लिए कॉल करता है। एक बार कार्रवाई पूरी होने के बाद, वस्तु ए को पता होना चाहिए कि बी ने कार्य पूरा कर लिया है और आवश्यक कार्रवाई कर ली है, इसे प्रतिनिधियों की मदद से हासिल किया जा सकता है!

एक बेहतर स्पष्टीकरण के लिए, मैं आपको एक कस्टम प्रतिनिधि बनाने का तरीका दिखाऊंगा जो कक्षाओं के बीच डेटा को पास करता है, स्विफ्ट के साथ एक साधारण एप्लिकेशन में, इस स्टार्टर प्रोजेक्ट को डाउनलोड या क्लोन करके शुरू करें और इसे चलाएं!

आप दो कक्षाओं, ViewController A और ViewController B साथ एक ऐप देख सकते हैं। बी में दो विचार हैं कि टैप पर ViewController का पृष्ठभूमि रंग बदलता है, कुछ भी जटिल नहीं है? अच्छी तरह से कक्षा ए के पृष्ठभूमि रंग को बदलने के एक आसान तरीके से सोचें जब कक्षा बी के विचार टैप किए जाते हैं।

समस्या यह है कि यह विचार कक्षा बी का हिस्सा हैं और कक्षा ए के बारे में कोई जानकारी नहीं है, इसलिए हमें इन दो वर्गों के बीच संवाद करने का एक तरीका ढूंढना होगा, और यही वह जगह है जहां प्रतिनिधिमंडल चमकता है। मैंने कार्यान्वयन को 6 चरणों में विभाजित किया ताकि आप इसे धोखाधड़ी के रूप में उपयोग कर सकें जब आपको इसकी आवश्यकता हो।

चरण 1: क्लासबीवीसी फ़ाइल में प्रोगमा मार्क चरण 1 की तलाश करें और इसे जोड़ें

//MARK: step 1 Add Protocol here.
protocol ClassBVCDelegate: class {
func changeBackgroundColor(_ color: UIColor?)
}

पहला कदम एक protocol बनाना है, इस मामले में, हम प्रोटोकॉल के अंदर कक्षा बी में प्रोटोकॉल बनाएंगे, आप अपने कार्यान्वयन की आवश्यकताओं के आधार पर जितना चाहें उतने कार्यों को बना सकते हैं। इस मामले में, हमारे पास एक साधारण कार्य है जो एक वैकल्पिक UIColor को तर्क के रूप में स्वीकार करता है। कक्षा के नाम के अंत में delegate को जोड़ने वाले प्रोटोकॉल को नाम देने का एक अच्छा अभ्यास है, इस मामले में, ClassBVCDelegate

चरण 2: ClassVBC में ClassVBC चिह्न चरण 2 की ClassVBC और इसे जोड़ें

//MARK: step 2 Create a delegate property here.
weak var delegate: ClassBVCDelegate?

यहां हम कक्षा के लिए सिर्फ एक प्रतिनिधि संपत्ति बनाते हैं, इस संपत्ति को protocol प्रकार को अपनाना होगा, और यह वैकल्पिक होना चाहिए। साथ ही, आपको चक्र से पहले कमजोर कीवर्ड जोड़ना चाहिए ताकि चक्र और संभावित मेमोरी लीक बनाए रखने से बच सकें, अगर आपको नहीं पता कि इसका मतलब क्या है, तो अभी चिंता न करें, बस इस कीवर्ड को जोड़ना याद रखें।

चरण 3: क्लासबीवीसी में हैंडलटैप method अंदर प्रगमा चिह्न चरण 3 की ClassBVC और इसे जोड़ें

//MARK: step 3 Add the delegate method call here.
delegate?.changeBackgroundColor(tapGesture.view?.backgroundColor)

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

चरण 4: क्लासएवीसी में हैंडलटैप विधि के अंदर प्रोगमा मार्क चरण 4 की ClassAVC और इसे अपने क्लास प्रकार के आगे इस तरह जोड़ें।

//MARK: step 4 conform the protocol here.
class ClassAVC: UIViewController, ClassBVCDelegate {
}

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

त्वरित नोट: यदि आप किसी Objective-C पृष्ठभूमि से आते हैं तो आप शायद सोच रहे हैं कि आप उस विधि को वैकल्पिक बनाने के लिए उस त्रुटि को भी बंद कर सकते हैं, लेकिन मेरे आश्चर्य के लिए, और शायद आपकी, Swift भाषा वैकल्पिक protocols समर्थन नहीं करती protocols , अगर आप चाहें ऐसा करें कि आप अपने protocol लिए एक एक्सटेंशन बना सकते हैं या अपने protocol कार्यान्वयन में @objc कीवर्ड का उपयोग कर सकते हैं।

निजी तौर पर, यदि मुझे विभिन्न वैकल्पिक तरीकों से प्रोटोकॉल बनाना है, तो मैं इसे विभिन्न protocols में तोड़ना पसंद करूंगा, इस तरह मैं अपनी वस्तुओं को एक ही जिम्मेदारी देने की अवधारणा का पालन करूंगा, लेकिन यह विशिष्ट कार्यान्वयन के आधार पर भिन्न हो सकता है।

यहां वैकल्पिक तरीकों के बारे में एक अच्छा लेख है।

चरण 5: सेगू विधि के लिए तैयार के अंदर प्रगमा चिह्न चरण 5 की तलाश करें और इसे जोड़ें

//MARK: step 5 create a reference of Class B and bind them through the `prepareforsegue` method.
if let nav = segue.destination as? UINavigationController, let classBVC = nav.topViewController as? ClassBVC {
classBVC.delegate = self
}

यहां हम केवल ClassBVC का एक उदाहरण बना रहे हैं और अपने प्रतिनिधि को स्वयं को सौंप सकते हैं, लेकिन यहां स्वयं क्या है? अच्छा, स्वयं ClassAVC जिसे प्रतिनिधिमंडल दिया गया है!

चरण 6: आखिरकार, ClassAVC में ClassAVC चरण 6 की ClassAVC और चलिए protocol के कार्यों का उपयोग करें, func change टाइप करना शुरू करें बैकग्राउंड रंग और आप देखेंगे कि यह आपके लिए स्वतः पूर्ण हो रहा है। आप इसके अंदर कोई कार्यान्वयन जोड़ सकते हैं, इस उदाहरण में, हम केवल पृष्ठभूमि रंग बदल देंगे, इसे जोड़ें।

//MARK: step 6 finally use the method of the contract
func changeBackgroundColor(_ color: UIColor?) {
view.backgroundColor = color
}

अब ऐप चलाएं!

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

  • वस्तुओं के तंग युग्मन से बचें।
  • ऑब्जेक्ट्स को उप-वर्ग की आवश्यकता के बिना व्यवहार और उपस्थिति को संशोधित करें।
  • किसी भी मनमानी वस्तु को कार्यों को संभालने की अनुमति दें।

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

आप here मूल ट्यूटोरियल देख सकते हैं




स्विफ्ट संस्करण

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

// A protocol is just a list of methods (and/or properties) that must
// be used by any class that adopts the protocol.
protocol OlderSiblingDelegate: class {
    // This protocol only defines one required method
    func getYourNiceOlderSiblingAGlassOfWater() -> String
}

class BossyBigBrother {

    // The delegate is the BossyBigBrother's slave. This position can 
    // be assigned later to whoever is available (and conforms to the 
    // protocol).
    weak var delegate: OlderSiblingDelegate?

    func tellSomebodyToGetMeSomeWater() -> String? {
        // The delegate is optional because there might not be anyone
        // nearby to boss around.
        return delegate?.getYourNiceOlderSiblingAGlassOfWater()
    }
}

// PoorLittleSister conforms to the OlderSiblingDelegate protocol
class PoorLittleSister: OlderSiblingDelegate {

    // This method is repquired by the protocol, but the protocol said
    // nothing about how it needs to be implemented.
    func getYourNiceOlderSiblingAGlassOfWater() -> String {
        return "Go get it yourself!"
    }

}

// initialize the classes
let bigBro = BossyBigBrother()
let lilSis = PoorLittleSister()

// Set the delegate 
// bigBro could boss around anyone who conforms to the 
// OlderSiblingDelegate protocol, but since lilSis is here, 
// she is the unlucky choice.
bigBro.delegate = lilSis

// Because the delegate is set, there is a class to do bigBro's work for him.
// bigBro tells lilSis to get him some water.
if let replyFromLilSis = bigBro.tellSomebodyToGetMeSomeWater() {
    print(replyFromLilSis) // "Go get it yourself!"
}

वास्तविक अभ्यास में, प्रतिनिधियों को अक्सर निम्नलिखित स्थितियों में उपयोग किया जाता है

  1. जब किसी वर्ग को किसी अन्य वर्ग को कुछ जानकारी संवाद करने की आवश्यकता होती है
  2. जब कोई वर्ग किसी अन्य वर्ग को इसे अनुकूलित करने की अनुमति देना चाहता है

कक्षाओं को पहले एक दूसरे के बारे में कुछ भी जानने की आवश्यकता नहीं है, सिवाय इसके कि प्रतिनिधि वर्ग आवश्यक प्रोटोकॉल के अनुरूप है।

मैं निम्नलिखित दो लेख पढ़ने की अत्यधिक अनुशंसा करता हूं। उन्होंने documentation तुलना में प्रतिनिधियों को भी बेहतर समझने में मेरी मदद की।




//1.
//Custom delegate 
@protocol TB_RemovedUserCellTag <NSObject>

-(void)didRemoveCellWithTag:(NSInteger)tag;

@end

//2.
//Create a weak reference in a class where you declared the delegate
@property(weak,nonatomic)id <TB_RemovedUserCellTag> removedCellTagDelegate;

//3. 
// use it in the class
  [self.removedCellTagDelegate didRemoveCellWithTag:self.tag];

//4. import the header file in the class where you want to conform to the protocol
@interface MyClassUsesDelegate ()<TB_RemovedUserCellTag>

@end

// 5। कक्षा में विधि को कार्यान्वित करें। एम - (शून्य) didRemoveCellWithTag: (एनएसआईएनटेगर) टैग {एनएसएलओजी @ ("टैग% डी", टैग);

}




Related