Я знаю, как работают делегаты, и я знаю, как я могу их использовать.

Но как мне их создать?

Делегат Objective-C - это объект, который был назначен delegateсвойству другого объекта. Чтобы создать его, вы определяете класс, который реализует интересующие вас методы делегата, и помечаете этот класс как реализующий протокол делегата.

Например, предположим, у вас есть UIWebView. Если вы хотите реализовать webViewDidStartLoad:метод его делегата , вы можете создать такой класс:

@interface MyClass<UIWebViewDelegate>
// ...
@end

@implementation MyClass
- (void)webViewDidStartLoad:(UIWebView *)webView { 
    // ... 
}
@end

Затем вы можете создать экземпляр MyClass и назначить его делегатом веб-представления:

MyClass *instanceOfMyClass = [[MyClass alloc] init];
myWebView.delegate = instanceOfMyClass;

На UIWebViewстороне, вероятно, есть код, подобный этому, чтобы видеть, отвечает ли делегат на webViewDidStartLoad:сообщение, используя respondsToSelector:и отправляет его при необходимости.

if([self.delegate respondsToSelector:@selector(webViewDidStartLoad:)]) {
    [self.delegate webViewDidStartLoad:self];
}

Само свойство делегата обычно объявляется weak(в ARC) или assign(до ARC), чтобы избежать циклов сохранения, поскольку делегат объекта часто содержит сильную ссылку на этот объект. (Например, контроллер представления часто является делегатом представления, которое он содержит.)

Создание делегатов для ваших классов

Чтобы определить своих собственных делегатов, вам нужно где-то объявить их методы, как описано в Документах Apple по протоколам . Вы обычно объявляете официальный протокол. Объявление, перефразированное из UIWebView.h, будет выглядеть так:

@protocol UIWebViewDelegate <NSObject>
@optional
- (void)webViewDidStartLoad:(UIWebView *)webView;
// ... other methods here
@end

Это аналог интерфейса или абстрактного базового класса, так как UIWebViewDelegateв этом случае он создает специальный тип для вашего делегата . Разработчики делегата должны будут принять этот протокол:

@interface MyClass <UIWebViewDelegate>
// ...
@end

А затем реализовать методы в протоколе. Для методов, объявленных в протоколе как @optional(как и большинство методов делегатов), вы должны проверить -respondsToSelector:перед вызовом определенного метода для него.

Именование

Методы делегатов обычно именуются, начиная с имени делегирующего класса, и принимают делегирующий объект в качестве первого параметра. Они также часто используют волю, следует или сделали. Итак, webViewDidStartLoad:(первый параметр - это веб-представление), а не loadStarted(не принимая параметров), например.

Оптимизация скорости

Вместо того, чтобы проверять, отвечает ли делегат на селектор каждый раз, когда мы хотим отправить его, вы можете кэшировать эту информацию, когда установлены делегаты. Один очень чистый способ сделать это - использовать битовое поле, как показано ниже:

@protocol SomethingDelegate <NSObject>
@optional
- (void)something:(id)something didFinishLoadingItem:(id)item;
- (void)something:(id)something didFailWithError:(NSError *)error;
@end

@interface Something : NSObject
@property (nonatomic, weak) id <SomethingDelegate> delegate;
@end

@implementation Something {
  struct {
    unsigned int didFinishLoadingItem:1;
    unsigned int didFailWithError:1;
  } delegateRespondsTo;
}
@synthesize delegate;

- (void)setDelegate:(id <SomethingDelegate>)aDelegate {
  if (delegate != aDelegate) {
    delegate = aDelegate;

    delegateRespondsTo.didFinishLoadingItem = [delegate respondsToSelector:@selector(something:didFinishLoadingItem:)];
    delegateRespondsTo.didFailWithError = [delegate respondsToSelector:@selector(something:didFailWithError:)];
  }
}
@end

Затем в теле мы можем проверить, что наш делегат обрабатывает сообщения, обращаясь к нашей delegateRespondsToструктуре, а не отправляя -respondsToSelector:снова и снова.

Неофициальные делегаты

До появления протоколов, было принято использовать категорию на NSObjectдекларировать методы делегат мог бы осуществить. Например, CALayerвсе еще делает это:

@interface NSObject(CALayerDelegate)
- (void)displayLayer:(CALayer *)layer;
// ... other methods here
@end

Это говорит компилятору, что любой объект может быть реализован displayLayer:.

Затем вы бы использовали тот же -respondsToSelector:подход, как описано выше, чтобы вызвать этот метод. Делегаты реализуют этот метод и присваивают delegateсвойство, и все (нет декларации о соответствии протоколу). Этот метод распространен в библиотеках Apple, но новый код должен использовать более современный протоколный подход, описанный выше, так как этот подход загрязняет NSObject(что делает автозаполнение менее полезным) и затрудняет компилятору предупреждение о опечатках и подобных ошибках.

Одобренный ответ хорош, но если вы ищете 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!");
}

При использовании метода формального протокола для создания поддержки делегатов я обнаружил, что вы можете обеспечить правильную проверку типов (хотя и во время выполнения, а не во время компиляции), добавив что-то вроде:

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

в вашем коде доступа делегата (setDelegate). Это помогает минимизировать ошибки.

Пожалуйста! посмотрите ниже простое пошаговое руководство, чтобы понять, как делегаты работают в iOS.

Делегат в iOS

Я создал два ViewController (для отправки данных от одного к другому)

1. FirstViewController реализует делегат (который предоставляет данные).
2. SecondViewController объявляет делегата (который будет получать данные).

Может быть, это больше похоже на то, что вам не хватает:

Если вы исходите из точки зрения, подобной C ++, делегатам нужно немного привыкнуть, но в основном «они просто работают».

Это работает так, что вы устанавливаете некоторый объект, который вы записали в качестве делегата в NSWindow, но у вашего объекта есть реализации (методы) только для одного или нескольких из множества возможных методов делегата. Итак, что-то происходит, и он NSWindowхочет вызвать ваш объект - он просто использует respondsToSelectorметод Objective-C, чтобы определить , хочет ли ваш объект вызвать этот метод, а затем вызывает его. Вот как работает target-c - методы ищутся по требованию.

Совершенно тривиально сделать это с вашими собственными объектами, ничего особенного в этом не происходит, например, вы можете иметь NSArray27 объектов, все виды объектов, только 18 из них имеют метод, -(void)setToBue;а другие 9 - нет. Итак, чтобы позвонить setToBlueвсем 18, которые нуждаются в этом, что-то вроде этого:

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

Еще одна вещь, связанная с делегатами, заключается в том, что они не сохраняются, поэтому вы всегда должны устанавливать делегата nilв своем MyClass deallocметоде.

В соответствии с рекомендациями Apple, рекомендуется, чтобы делегат (который по определению является протоколом) соответствовал 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действительно ли представление (соответствующее вашему делегату) действительно реализовало ваш необязательный метод (ы) или нет.

Я думаю, что все эти ответы имеют большой смысл, когда вы понимаете делегатов. Лично я приехал из страны Си / Си ++ и до этого процедурных языков, таких как Фортран и т. Д., Так что вот моя 2-минутная попытка найти похожие аналоги в парадигме Си ++.

Если бы я должен был объяснить делегатов программисту на C ++ / Java, я бы сказал

Что такое делегаты? Это статические указатели на классы внутри другого класса. Как только вы назначите указатель, вы можете вызывать функции / методы в этом классе. Следовательно, некоторые функции вашего класса «делегируются» (в мире C ++ - указатель на указатель объекта класса) другому классу.

Какие протоколы? Концептуально это служит аналогичным назначением для файла заголовка класса, который вы назначаете в качестве класса делегата. Протокол - это явный способ определения того, какие методы должны быть реализованы в классе, указатель которого был задан как делегат внутри класса.

Как я могу сделать что-то подобное в C ++? Если бы вы попытались сделать это в C ++, вы должны определить указатели на классы (объекты) в определении класса, а затем связать их с другими классами, которые предоставят дополнительные функции в качестве делегатов вашему базовому классу. Но эта проводка должна поддерживаться в коде и будет неуклюжей и подверженной ошибкам. Цель C просто предполагает, что программисты не лучше всего поддерживают эту дешифровку, и предоставляет ограничения компилятора для обеспечения чистой реализации.

Swift версия

Делегат - это просто класс, который выполняет работу для другого класса. Прочитайте следующий код для несколько глупого (но, надеюсь, поучительного) примера Playground, который показывает, как это делается в 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!"
}

На практике делегаты часто используются в следующих ситуациях

1. Когда класс должен передать некоторую информацию другому классу
2. Когда класс хочет разрешить другому классу настроить его

Классы не должны знать ничего друг о друге заранее, за исключением того, что класс делегата соответствует требуемому протоколу.

Я настоятельно рекомендую прочитать следующие две статьи. Они помогли мне понять делегатов даже лучше, чем документация .

• Что такое делегирование? - Руководство разработчика Swift
• Как работает делегирование - Руководство разработчика Swift

Хорошо, это не совсем ответ на вопрос, но если вы ищете, как сделать свой собственный делегат, возможно, что-то гораздо более простое может быть лучшим ответом для вас.

Я с трудом реализую своих делегатов, потому что мне это редко нужно. Я могу иметь ТОЛЬКО ОДИН делегат для объекта делегата. Так что если вы хотите, чтобы ваш делегат для односторонней связи / передачи данных, вам гораздо лучше с уведомлениями.

NSNotification может передавать объекты нескольким получателям, и им очень легко пользоваться. Это работает так:

Файл MyClass.m должен выглядеть так

#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

Чтобы использовать ваше уведомление в других классах: Добавьте класс в качестве наблюдателя:

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

Реализуйте селектор:

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

Не забудьте удалить свой класс в качестве наблюдателя, если

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

Допустим, у вас есть класс, который вы разработали, и вы хотите объявить свойство делегата, чтобы иметь возможность уведомлять его, когда происходит какое-то событие:

@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>), что означает любой целевой класс c, соответствующий По протоколу MyClassDelegateвы заметите, что свойство делегата объявлено как слабое, это очень важно для предотвращения сохранения цикла (чаще всего делегат сохраняет MyClassэкземпляр, поэтому, если вы объявили делегат как сохранение, оба они сохранят друг друга, и ни из них когда-нибудь выйдет).

Вы также заметите, что методы протокола MyClassпередают экземпляр делегату в качестве параметра, это наилучшая практика, если делегат хочет вызвать некоторые методы в MyClassэкземпляре, а также помогает, когда делегат объявляет себя MyClassDelegateдля нескольких MyClassэкземпляров, например, когда у вас несколько UITableView'sэкземпляры в вашем ViewControllerи объявляет себя UITableViewDelegateвсем им.

и внутри вашего MyClassвы уведомите делегата с объявленными событиями следующим образом:

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

сначала вы проверяете, отвечает ли ваш делегат на метод протокола, который вы собираетесь вызвать, в случае, если делегат не реализует его, а затем произойдет сбой приложения (даже если метод протокола требуется).

Вот простой способ создания делегатов

Создать протокол в .h файле. Убедитесь, что он определен перед протоколом с использованием @class, за которым следует имя UIViewController< As the protocol I am going to use is UIViewController class>.

Шаг: 1: Создайте новый протокол класса с именем «YourViewController», который будет подклассом класса UIViewController, и назначьте этот класс второму ViewController.

Шаг 2: перейдите к файлу «YourViewController» и измените его, как показано ниже:

#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

Методы, определенные в поведении протокола, могут управляться с помощью @optional и @required как часть определения протокола.

Шаг: 3: Реализация делегата

    #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

// проверяем, был ли метод определен перед его вызовом

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

Чтобы создать свой собственный делегат, сначала нужно создать протокол и объявить необходимые методы, не реализуя. А затем внедрите этот протокол в свой класс заголовка, где вы хотите реализовать методы делегата или делегата.

Протокол должен быть объявлен как ниже:

@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];
}

Вот и все, и, реализовав методы делегата в этом классе, управление вернется после выполнения операции / задачи.

Отказ от ответственности: это Swiftверсия о том, как создать delegate.

Итак, что такое делегаты? … В разработке программного обеспечения существуют общие многократно используемые архитектуры решений, которые помогают решать часто возникающие проблемы в данном контексте, эти «шаблоны», так сказать, наиболее известны как шаблоны проектирования. Делегаты - это шаблон проектирования, который позволяет одному объекту отправлять сообщения другому объекту, когда происходит определенное событие. Представьте, что объект A вызывает объект B для выполнения действия. Как только действие завершено, объект A должен знать, что B выполнил задачу, и предпринять необходимые действия, это может быть достигнуто с помощью делегатов!

Для лучшего объяснения я собираюсь показать вам, как создать пользовательский делегат, который передает данные между классами, с помощью Swift в простом приложении, начните с загрузки или клонирования этого начального проекта и запустите его!

Вы можете увидеть приложение с двумя классами, ViewController Aи ViewController B. У Б есть два представления, что при нажатии меняет цвет фона ViewController, ничего слишком сложного, верно? Что ж, теперь давайте по-простому подумаем также изменить цвет фона класса A при касании представлений класса B.

Проблема заключается в том, что эти представления являются частью класса B и не имеют представления о классе A, поэтому нам нужно найти способ связи между этими двумя классами, и именно здесь сияет делегирование. Я разделил реализацию на 6 шагов, чтобы вы могли использовать ее как шпаргалку, когда вам это нужно.

Шаг 1: Найдите прагму в шаге 1 в файле ClassBVC и добавьте

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

Первым шагом является создание protocol, в этом случае мы создадим протокол в классе B, внутри протокола вы можете создать столько функций, сколько вам нужно, исходя из требований вашей реализации. В этом случае у нас просто есть одна простая функция, которая принимает необязательный UIColorаргумент. Это хорошая практика , чтобы назвать свои протоколы , добавив слово delegateв конце имени класса, в данном случае ClassBVCDelegate.

Шаг 2: Найдите прагматический шаг 2 ClassVBCи добавьте это

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

Здесь мы просто создаем свойство делегата для класса, это свойство должно принимать protocolтип, и оно должно быть необязательным. Кроме того, вы должны добавить ключевое слово слабое перед свойством, чтобы избежать циклов и потенциальных утечек памяти, если вы не знаете, что это значит, не беспокойтесь, просто не забудьте добавить это ключевое слово.

шаг 3: Посмотрите на шаг Прагма марки 3 внутри handleTap methodв ClassBVCи добавить

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

Одна вещь, которую вы должны знать, запустите приложение и нажмите на любое представление, вы не увидите никакого нового поведения, и это правильно, но я хочу отметить, что приложение не падает при вызове делегата, и это потому, что мы создаем его как необязательное значение, и поэтому оно не будет падать, даже если делегированный еще не существует. Теперь давайте перейдем к ClassAVCфайлу и сделаем его делегированным.

Шаг 4: Найдите шаг 4 прагмы внутри метода handleTap ClassAVCи добавьте его рядом с вашим типом класса следующим образом.

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

Теперь, когда ClassAVC принял ClassBVCDelegateпротокол, вы можете видеть, что ваш компилятор выдает ошибку, которая говорит: «Тип» ClassAVC не соответствует протоколу «ClassBVCDelegate», и это только означает, что вы еще не использовали методы протокола, представьте, что когда класс A принимает протокол, это все равно что подписывать контракт с классом B, и этот контракт говорит: «Любой класс, принимающий меня, ДОЛЖЕН использовать мои функции!»

Краткое примечание. Если вы работаете в Objective-Cфоновом режиме, вы, вероятно, думаете, что вы также можете закрыть эту ошибку, сделав этот метод необязательным, но, к моему удивлению и, вероятно, Swiftвашему , язык не поддерживает необязательный protocols, если вы хотите это сделать, вы можете создать расширение protocolили используйте ключевое слово @objc в своей protocolреализации.

Лично, если мне нужно создать протокол с разными дополнительными методами, я бы предпочел разбить его на разные 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: Наконец, найдите прагму на шаге 6, ClassAVCи давайте использовать функции protocol, начнем вводить func changeBackgroundColor, и вы увидите, что он автоматически заполняется для вас. Вы можете добавить любую реализацию внутри него, в этом примере мы просто изменим цвет фона, добавим это.

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

Теперь запустите приложение!

Delegatesнаходятся везде, и вы, вероятно, используете их даже без уведомления, если вы tableviewв прошлом использовали делегирование, многие классы UIKITработ вокруг них и многие другие frameworksтоже решают эти основные проблемы.

• Избегайте плотного сцепления предметов.
• Изменить поведение и внешний вид без необходимости подкласса объектов.
• Разрешить выполнение задач для любого произвольного объекта.

Поздравляю, вы просто внедрили собственный делегат, я знаю, что вы, вероятно, думаете, так много проблем только для этого? Ну, делегирование - это очень важный шаблон проектирования, который нужно понимать, если вы хотите стать iOSразработчиком, и всегда помнить о том, что они имеют отношение один к одному между объектами.

Вы можете увидеть оригинальный учебник здесь

Ответ действительно получен, но я хотел бы дать вам «шпаргалку» для создания делегата:

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

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;

Метод:

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

На мой взгляд, создайте отдельный класс для этого метода делегата, и вы сможете использовать его там, где хотите.

в моем пользовательском 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;

после этого в файле .m создайте массив с объектами,

 - (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];
        }
    }
}];
}

Здесь все установлено для Пользовательского делегата класса. После этого вы можете использовать этот метод делегата, где вы хотите. Например ...

в моем другом импорте viewcontroller после этого

создать действие для вызова метода делегата, как это

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

после этого вызова метода делегата, как это

- (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;
}
}

Делегат: - Создать

@protocol addToCartDelegate <NSObject>

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

@end

Отправьте и, пожалуйста, назначьте делегата для просмотра отправляемых вами данных.

[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. Реализуйте метод в классе .m - (void) didRemoveCellWithTag: (NSInteger) tag {NSLog @ ("Tag% d", tag);

}

Давайте начнем с примера: если мы покупаем продукт через Интернет, он проходит такой процесс, как доставка / доставка, осуществляемая различными командами. Так что, если доставка завершена, команда доставки должна уведомить команду доставки, и это должно быть сообщение один на один для передачи этой информации. Это может быть связано с накладными расходами для других людей / поставщик может захотеть передать эту информацию только нужным людям.

Поэтому, если мы думаем с точки зрения нашего приложения, мероприятие может быть онлайн-заказом, а разные команды могут быть похожи на несколько просмотров.

Вот код, который рассматривает ShippingView в качестве команды доставки и DeliveryView в качестве команды доставки:

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