Zatwierdzona odpowiedź jest świetna, ale jeśli szukasz 1-minutowej odpowiedzi, spróbuj tego:

#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

#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

Aby użyć delegata w innej klasie (UIViewController o nazwie MyVC w tym przypadku) 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

Zaimplementuj metodę delegata

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

Podczas korzystania z formalnej metody protokołu do tworzenia obsługi delegatów, odkryłem, że można zapewnić prawidłowe sprawdzanie typu (chociaż, runtime, a nie czas kompilacji), dodając coś w stylu:

if (![delegate conformsToProtocol:@protocol(MyDelegate)]) {
    [NSException raise:@"MyDelegate Exception"
                format:@"Parameter does not conform to MyDelegate protocol at line %d", (int)__LINE__];
}

W kodzie delegata (setDelegate). Pomaga to zminimalizować błędy.

Może to jest bardziej podobne do tego, co brakuje:

Jeśli przychodzisz z punktu widzenia C++, delegaci trochę się przyzwyczajają - ale w zasadzie "po prostu działają".

Sposób w jaki to działa polega na tym, że ustawiasz jakiś obiekt, który napisałeś jako delegat do NSWindow, ale twój obiekt ma tylko implementacje (metody) dla jednej lub kilku z wielu możliwych metod delegatów. Więc coś się dzieje i NSWindow chce wywołać Twój obiekt - po prostu używa Objective-c respondsToSelector metoda aby określić, czy obiekt chce wywołać tę metodę, a następnie ją wywołać. Tak działa objective-c - metody są sprawdzane na żądanie.

Jest to całkowicie trywialne, aby to zrobić z własnymi obiektami, nie ma nic specjalnego się dzieje, możesz na przykład mieć NSArray z 27 obiektów, wszystkich różnych rodzajów obiektów, tylko 18 niektóre z nich mają metodę -(void)setToBue; Inne 9 nie. więc aby wywołać setToBlue na wszystkich 18, które potrzebują tego zrobić, coś takiego: {9]}

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

The other rzecz w tym, że delegaci nie są zachowywani, więc zawsze musisz ustawić delegata na nil w swojej metodzie MyClass dealloc.

Proszę! Sprawdź poniżej prosty samouczek krok po kroku, aby zrozumieć, jak delegaci działają w systemie iOS.

Deleguj w iOS

Utworzyłem dwa Viewcontrollery (do przesyłania danych z jednego do drugiego)

1. FirstViewController implementuje delegata (który dostarcza dane).
2. SecondViewController deklaruje delegata (który otrzyma dane).

Jako dobra praktyka zalecana przez Apple, dobrze jest, aby delegat (który z definicji jest protokołem), był zgodny z protokołem NSObject.

@protocol MyDelegate <NSObject>
    ...
@end

& aby utworzyć Opcjonalne metody wewnątrz twojego delegata (tj. metody, które niekoniecznie muszą być zaimplementowane), możesz użyć adnotacji @optional w następujący sposób:

@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

Więc używając metod, które określiłeś jako opcjonalne, musisz (w swojej klasie) sprawdzić za pomocą respondsToSelector Czy widok (który jest zgodny z Twoim delegatem) rzeczywiście zaimplementowano Opcjonalne metody lub nie.

Myślę, że wszystkie te odpowiedzi mają sens, gdy zrozumiesz delegatów. Osobiście pochodzę z krainy C/C++, a wcześniej języków proceduralnych, takich jak Fortran itp., Więc oto moje 2 min podejście do znajdowania podobnych analogów w paradygmacie C++.

Gdybym miał wytłumaczyć programiście C++ / Java to powiedziałbym

Czym są delegaci ? Są to statyczne wskaźniki do klas w ramach innej klasy. Po przypisaniu wskaźnika możesz wywołać funkcje / metody w tej klasie. Stąd niektóre funkcje klasy są "delegowane" (w C++ world - pointer to by a class object pointer) do innej klasy.

Co to są protokoły ? Koncepcyjnie służy ona do podobnego celu jak plik nagłówkowy klasy, którą przypisujesz jako klasę delegata. Protokół jest jawnym sposobem definiowania, jakie metody muszą być zaimplementowane w klasie, który wskaźnik został ustawiony jako delegat w klasie.

Jak mogę zrobić coś podobnego w C++? Jeśli próbowałeś to zrobić w C++, można by zdefiniować wskaźniki do klas (obiektów) w definicji klasy, a następnie połączyć je z innymi klasami, które zapewnią dodatkowe funkcje jako delegatów do klasy bazowej. Ale to okablowanie musi być utrzymane w kodzie i będzie niezdarne i podatne na błędy. Objective C zakłada tylko, że programiści nie są najlepsi w utrzymywaniu tej linii i zapewnia ograniczenia kompilatora, aby wymusić czystą implementację.

Wersja Swift

Delegat to tylko klasa, która wykonuje jakąś pracę dla innej klasy. Przeczytaj poniższy kod, aby uzyskać nieco głupi (ale miejmy nadzieję pouczający) przykład placu zabaw, który pokazuje, jak to się robi w Swift.

// 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!"
}

W praktyce delegaci są często używane w następujących sytuacjach

1. gdy klasa musi przekazać pewne informacje innej klasie
2. gdy Klasa chce zezwolić innej klasie na jej dostosowanie

The klasy nie muszą wiedzieć nic o sobie wcześniej, z wyjątkiem tego, że Klasa delegata jest zgodna z wymaganym protokołem.

Gorąco polecam przeczytanie następujących dwóch artykułów. Pomogły mi zrozumieć delegatów jeszcze lepiej niż dokumentacja .

• Co To jest Delegacja? – Szybki poradnik programisty
• Jak działa Delegacja-Swift Developer ' s Guide

Ok, to nie jest tak naprawdę odpowiedź na pytanie, ale jeśli szukasz, Jak zrobić własnego delegata, może coś znacznie prostszego mogłoby być lepszą odpowiedzią dla Ciebie.

NSNotification może przekazywać obiekty do więcej niż jednego odbiorcy i jest bardzo łatwy w użyciu. Działa tak:

#import "MyClass.h"
@implementation MyClass 

- (void) myMethodToDoStuff {
//this will post a notification with myClassData (NSArray in this case)  in its userInfo dict and self as an object
[[NSNotificationCenter defaultCenter] postNotificationName:@"myClassUpdatedData"
                                                    object:self
                                                  userInfo:[NSDictionary dictionaryWithObject:selectedLocation[@"myClassData"] forKey:@"myClassData"]];
}
@end

Aby użyć Twojego powiadomienia w innych klasach: Dodaj klasę jako obserwatora:

[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(otherClassUpdatedItsData:) name:@"myClassUpdatedData" object:nil];

Zaimplementuj selektor:

- (void) otherClassUpdatedItsData:(NSNotification *)note {
    NSLog(@"*** Other class updated its data ***");
    MyClass *otherClass = [note object];  //the object itself, you can call back any selector if you want
    NSArray *otherClassData = [note userInfo][@"myClassData"]; //get myClass data object and do whatever you want with it
}

Nie zapomnij usunąć swojej klasy jako obserwatora, Jeśli

- (void)dealloc
{
    [[NSNotificationCenter defaultCenter] removeObserver:self];
}

Powiedzmy, że masz klasę, którą stworzyłeś i chcesz zadeklarować właściwość delegata, aby móc powiadomić ją, gdy wydarzy się jakieś zdarzenie:

@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

Więc deklarujesz protokół w pliku nagłówkowym MyClass (lub oddzielnym pliku nagłówkowym) i deklarujesz wymagane / opcjonalne procedury obsługi zdarzeń, które twój delegat musi/powinien zaimplementować , a następnie deklarujesz właściwość w MyClass typu (id< MyClassDelegate>), co oznacza dowolną klasę objective c, która jest zgodna z protokołem MyClassDelegate, zauważysz, że właściwość delegate jest zadeklarowana jako słaba, jest to bardzo ważne, aby zapobiec cyklowi zachowywania (najczęściej delegat zachowuje instancję MyClass, więc jeśli zadeklarowałeś delegata jako zachowaj, obie zachowają się nawzajem i żadna z nich nigdy nie zostanie zwolniona).

Zauważysz również, że metody protokołu przekazują instancję MyClass do delegata jako parametru , jest to najlepsza praktyka w przypadku, gdy delegat chce wywołać niektóre metody na instancji MyClass, a także pomaga, gdy delegat deklaruje się jako MyClassDelegate do wielu instancji MyClass, Jak wtedy, gdy masz wiele instancji UITableView's w swoim ViewController i deklaruje się jako UITableViewDelegate do wszystkich z nich.

I wewnątrz MyClass powiadamiasz delegata o zadeklarowanych zdarzeniach w następujący sposób:

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

Najpierw sprawdzasz, czy twój delegat reaguje na metodę protokołu, którą chcesz wywołać, na wypadek, gdyby delegat jej nie zaimplementował, a aplikacja ulegnie awarii (nawet jeśli wymagana jest metoda protokołu).

Oto prosta metoda tworzenia delegatów

Utwórz protokół w .plik H. Upewnij się, że jest zdefiniowany przed protokołem używając @ class, po którym następuje nazwa UIViewController < As the protocol I am going to use is UIViewController class>.

Krok: 1: Utwórz nowy protokół klasy o nazwie "YourViewController", który będzie podklasą klasy UIViewController i przypisz tę klasę do drugiego Viewcontrollera.

Krok: 2: przejdź do pliku "YourViewController" i zmodyfikuj go jako poniżej:

#import <UIKit/UIkit.h>
@class YourViewController;

@protocol YourViewController Delegate <NSObject>

 @optional
-(void)defineDelegateMethodName: (YourViewController *) controller;

@required
-(BOOL)delegateMethodReturningBool: (YourViewController *) controller;

  @end
  @interface YourViewController : UIViewController

  //Since the property for the protocol could be of any class, then it will be marked as a type of id.

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

@end

Metody zdefiniowane w zachowaniu protokołu mogą być kontrolowane za pomocą @optional i @required jako część definicji protokołu.

Krok: 3: implementacja delegata

    #import "delegate.h"

   @interface YourDelegateUser ()
     <YourViewControllerDelegate>
   @end

   @implementation YourDelegateUser

   - (void) variousFoo {
      YourViewController *controller = [[YourViewController alloc] init];
      controller.delegate = self;
   }

   -(void)defineDelegateMethodName: (YourViewController *) controller {
      // handle the delegate being called here
   }

   -(BOOL)delegateMethodReturningBool: (YourViewController *) controller {
      // handle the delegate being called here
      return YES;
   }

   @end

//sprawdź, czy metoda została zdefiniowana, zanim ją wywołasz

 - (void) someMethodToCallDelegate {
     if ([[self delegate] respondsToSelector:@selector(defineDelegateMethodName:)]) {
           [self.delegate delegateMethodName:self]; 
     }
  }

Aby utworzyć własnego delegata, najpierw musisz utworzyć protokół i zadeklarować niezbędne metody, bez implementacji. A następnie zaimplementuj ten protokół do swojej klasy nagłówka, w której chcesz zaimplementować metody delegate lub delegate.

Protokół musi być zadeklarowany jak poniżej:

@protocol ServiceResponceDelegate <NSObject>

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

@end

Jest to klasa usług, w której należy wykonać jakieś zadanie. Pokazuje, jak zdefiniować delegata i jak ustawić delegata. W klasie implementacji po wykonaniu zadania metody delegata są wywoływane.

@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

Jest to główna klasa widoku, z której Klasa service jest wywoływana przez ustawienie delegata do siebie. A także protokół jest zaimplementowany w klasie nagłówka.

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

- (void) go;

@end

@implementation viewController

//
//some methods
//

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

To wszystko, a implementując metody delegatów w tej klasie, Kontrola powróci po wykonaniu operacji/zadania.

Disclaimer: to jest Swift Wersja jak utworzyć delegate.

Aby uzyskać lepsze wyjaśnienie, pokażę Ci, jak utworzyć niestandardowy delegat, który przekazuje dane między klasami, za pomocą Swift w prostej aplikacji, zacznij od pobrania lub klonowania tego projektu startowego i uruchom go!

Możesz zobaczyć aplikację z dwoma klasami, ViewController A i ViewController B. B ma dwa widoki, które NA tap zmienia kolor tła ViewController, nic zbyt skomplikowanego prawda? dobrze teraz pomyślmy w łatwy sposób, aby również zmienić kolor tła klasy A, gdy widoki na klasie B są tapped.

Problem polega na tym, że te poglądy są częścią klasy B i nie mają pojęcia o klasie A, więc musimy znaleźć sposób na komunikację między tymi dwiema klasami, i to jest miejsce, w którym delegacja świeci. Podzieliłem implementację na 6 kroków, dzięki czemu możesz użyć tego jako ściągawki, gdy potrzebujesz to.

Krok 1: poszukaj znaku pragma Krok 1 w pliku ClassBVC i dodaj to

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

Pierwszym krokiem jest utworzenie protocol, w tym przypadku utworzymy protokół w klasie B, wewnątrz protokołu możesz utworzyć tyle funkcji, ile chcesz w oparciu o wymagania Twojej implementacji. W tym przypadku mamy tylko jedną prostą funkcję, która przyjmuje opcjonalny UIColor jako argument. Jest dobrą praktyką, aby nazwać swoje protokoły dodając słowo delegate na końcu klasy nazwa, w tym przypadku ClassBVCDelegate.

Krok 2: Poszukaj znaku pragmy Krok 2 w ClassVBC i dodaj to

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

Tutaj po prostu tworzymy właściwość delegata dla klasy, ta właściwość musi przyjąć typ protocol i powinna być opcjonalna. Ponadto, należy dodać słabe słowo kluczowe przed właściwością, aby uniknąć zatrzymywania cykli i potencjalnych wycieków pamięci, jeśli nie wiesz, co to oznacza, nie martw się na razie, po prostu pamiętaj, aby dodać to słowo kluczowe.

Krok 3: poszukaj znaku pragmy krok 3 wewnątrz uchwytu method W ClassBVC i dodaj to

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

Jedna rzecz, którą powinieneś wiedzieć, uruchom aplikację i dotknij dowolnego widoku, nie zobaczysz żadnego nowego zachowania i to jest poprawne, ale rzeczą, którą chcę podkreślić, jest to, że aplikacja nie zawiesza się, gdy delegat jest wywoływany, i to dlatego, że tworzymy go jako wartość opcjonalną i dlatego nie zawiesi się nawet delegowany jeszcze nie istnieje. Przejdźmy teraz do pliku ClassAVC i zrób to, delegowany.

Krok 4: poszukaj pragma zaznacz Krok 4 wewnątrz metody handleTap w ClassAVC i dodaj to obok swojego typu klasy w ten sposób.

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

Teraz ClassAVC przyjęło protokół ClassBVCDelegate, widać, że Twój kompilator wyświetla błąd, który mówi: "Typ 'ClassAVC nie jest zgodny z protokołem 'ClassBVCDelegate' i to tylko oznacza, że nie używałeś jeszcze metod protokołu, wyobraź sobie, że kiedy Klasa A przyjmuje protokół jest jak podpisanie umowy z klasą B i ta umowa mówi: "każda klasa przyjmująca protokół muszę korzystać z moich funkcji!"

Szybka uwaga: jeśli pochodzisz z tła Objective-C, prawdopodobnie myślisz, że możesz również zamknąć ten błąd czyniąc tę metodę opcjonalną, ale ku mojemu zdziwieniu, a prawdopodobnie Twojej, język Swift nie obsługuje opcjonalnej protocols, Jeśli chcesz to zrobić, możesz utworzyć rozszerzenie dla swojej protocol lub użyć słowa kluczowego @objc w swojej implementacji protocol.

Osobiście, jeśli muszę stworzyć protokół z różnymi opcjonalnymi metodami, wolałbym aby podzielić ją na inną protocols, w ten sposób będę podążał za koncepcją powierzenia jednej odpowiedzialności moim przedmiotom, ale może się ona różnić w zależności od konkretnej implementacji.

Oto dobry artykuł o metodach opcjonalnych.

//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
}

Tutaj właśnie tworzymy instancję ClassBVC i przypisujemy jej delegata do jaźni, ale czym jest jaźń tutaj? cóż, self is the ClassAVC która została przekazana!

Krok 6: na koniec poszukaj kroku pragma 6 w ClassAVC i użyjmy funkcji protocol, zacznij wpisywać func changeBackgroundColor , a zobaczysz, że jest to automatyczne uzupełnianie go dla Ciebie. Możesz dodać dowolną implementację wewnątrz niego, w tym przykładzie po prostu zmienimy kolor tła, dodaj to.

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

Teraz uruchom aplikację!

Delegates są wszędzie i prawdopodobnie używasz ich bez zauważenia, jeśli stworzysz tableview w przeszłość, której używałeś, wiele klas UIKIT działa wokół nich i wiele innych frameworks również rozwiązują te główne problemy.

• unikaj ciasnego łączenia obiektów.
• Modyfikuj zachowanie i wygląd bez konieczności podklasowania obiektów.
• pozwala na przenoszenie zadań do dowolnego dowolnego obiektu.

Gratulacje, właśnie wdrażasz niestandardowego delegata, wiem, że pewnie myślisz, tyle kłopotów tylko z tego powodu? cóż, delegacja jest bardzo ważny wzorzec projektowy, aby zrozumieć, jeśli chcesz zostać programistą {36]} i zawsze pamiętaj, że mają one jeden do jednego związek między obiektami.

ViewController.h

@protocol NameDelegate <NSObject>

-(void)delegateMEthod: (ArgType) arg;

@end

@property id <NameDelegate> delegate;

ViewController.m

[self.delegate delegateMEthod: argument];

MainViewController.m

ViewController viewController = [ViewController new];
viewController.delegate = self;

Metoda:

-(void)delegateMEthod: (ArgType) arg{
}

Z mojego punktu widzenia Utwórz osobną klasę dla tej metody delegata i możesz jej używać tam, gdzie chcesz.

W moim Custom DropDownClass.h

typedef enum
{
 DDSTATE,
 DDCITY
}DropDownType;

@protocol DropDownListDelegate <NSObject>
@required
- (void)dropDownDidSelectItemWithString:(NSString*)itemString     DropDownType:(DropDownType)dropDownType;
@end
@interface DropDownViewController : UIViewController
{
 BOOL isFiltered;
}
@property (nonatomic, assign) DropDownType dropDownType;
@property (weak) id <DropDownListDelegate> delegate;
@property (strong, nonatomic) NSMutableArray *array1DropDown;
@property (strong, nonatomic) NSMutableArray *array2DropDown;

Potem w.m plik tworzy tablicę z obiektami,

 - (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath{
CGFloat rowHeight = 44.0f;
return rowHeight;
}

-(NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
return 1;
}
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section{
return isFiltered?[self.array1DropDown count]:[self.array2DropDown count];
}
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
static NSString *simpleTableIdentifier = @"TableCell";
UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:simpleTableIdentifier];
if (cell == nil) {
    cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:simpleTableIdentifier];
}

if (self.delegate) {
    if (self.dropDownType == DDCITY) {
        cell.textLabel.text = [self.array1DropDown objectAtIndex:indexPath.row];
    }
    else if (self.dropDownType == DDSTATE) {
        cell.textLabel.text = [self.array2DropDown objectAtIndex:indexPath.row];
    }
}
return cell;
}

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath
{
 [self dismissViewControllerAnimated:YES completion:^{
    if(self.delegate){
        if(self.dropDownType == DDCITY){
            [self.delegate dropDownDidSelectItemWithString:[self.array1DropDown objectAtIndex:indexPath.row] DropDownType:self.dropDownType];
        }
        else if (self.dropDownType == DDSTATE) {
            [self.delegate dropDownDidSelectItemWithString:[self.array2DropDown objectAtIndex:indexPath.row] DropDownType:self.dropDownType];
        }
    }
}];
}

Tutaj wszystkie są ustawione dla niestandardowej klasy delegata.następnie możesz użyć tej metody delegowania tam, gdzie chcesz.na przykład...

In my another ViewController import after that

Utwórz akcję do wywołania metody delegata w ten sposób

- (IBAction)dropDownBtn1Action:(id)sender {
DropDownViewController *vehicleModelDropView = [[DropDownViewController alloc]init];
vehicleModelDropView.dropDownType = DDCITY;
vehicleModelDropView.delegate = self;
[self presentViewController:vehicleModelDropView animated:YES completion:nil];
}

Po tym wywołanie metody delegata w ten sposób

- (void)dropDownDidSelectItemWithString:(NSString *)itemString DropDownType:(DropDownType)dropDownType {
switch (dropDownType) {
    case DDCITY:{
        if(itemString.length > 0){
            //Here i am printing the selected row
            [self.dropDownBtn1 setTitle:itemString forState:UIControlStateNormal];
        }
    }
        break;
    case DDSTATE: {
        //Here i am printing the selected row
        [self.dropDownBtn2 setTitle:itemString forState:UIControlStateNormal];
    }

    default:
        break;
}
}

Delegate: - Create

@protocol addToCartDelegate <NSObject>

-(void)addToCartAction:(ItemsModel *)itemsModel isAdded:(BOOL)added;

@end

Wyślij i przypisz delegata, aby wyświetlić wysyłane DANE

[self.delegate addToCartAction:itemsModel isAdded:YES];

//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. Zaimplementuj metodę w klasie .na - (void)didRemoveCellWithTag: (NSInteger)tag { NSLog@("Tag % d", tag);

}

Zacznijmy od przykładu, jeśli kupujemy produkt online, przechodzi on proces podobny do wysyłki / dostawy obsługiwanej przez różne teams.So jeśli wysyłka zostanie zakończona, zespół wysyłkowy powinien powiadomić zespół dostaw i powinna to być komunikacja jeden do jednego, ponieważ nadawanie tych informacji byłoby narzutowe dla innych osób / sprzedawca może chcieć przekazać te informacje tylko wymaganym osobom.

Więc jeśli myślimy w kategoriach naszej aplikacji, wydarzenie może być zamówieniem online i różne zespoły mogą być jak wiele widoków.

Oto kod rozważ ShippingView jako zespół wysyłki i Deliview jako zespół dostawy:

//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
        //
    }
}

Odpowiedź jest rzeczywiście odpowiedział, ale chciałbym dać ci "Ściągawka" do tworzenia delegata:

DELEGATE SCRIPT

CLASS A - Where delegate is calling function

@protocol <#Protocol Name#> <NSObject>

-(void)delegateMethod;

@end

@interface <#Some ViewController#> : <#UIViewController#> 

@property (nonatomic, assign) id <<#Protocol Name#>> delegate;

@end


@implementation <#Some ViewController#> 

-(void)someMethod {
    [self.delegate methodName];
}

@end




CLASS B - Where delegate is called 

@interface <#Other ViewController#> (<#Delegate Name#>) {}
@end

@implementation <#Other ViewController#> 

-(void)otherMethod {
    CLASSA *classA = [[CLASSA alloc] init];

    [classA setDelegate:self];
}

-delegateMethod() {

}

@end