it-swarm.com.ru

Как мне создать делегатов в Objective-C?

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

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

723
Andy Jacobs

Делегат 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 (pre-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: снова и снова.

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

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

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

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

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

872
Jesse Rusak

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

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

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

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

18
umop

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

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

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

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

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

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

17
Tom Andersen

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

Делегат в iOS

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

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

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

15
Jean

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

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

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

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

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

10
DrBug

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. Когда класс хочет разрешить другому классу настроить его

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

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

9
Suragch

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

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

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];
}
8
Tibidabo

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

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

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

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

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

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

8
m.eldehairy

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

Создать протокол в .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]; 
     }
  }
7
Sujania

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

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

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

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

5
Mahesh

Отказ от ответственности: это 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 в качестве аргумента. Рекомендуется называть ваши протоколы добавлением Word 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 и присваиваем его делегату self, но что здесь есть self? что ж, self - это 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, и всегда иметь в виду, что они имеют отношение один к одному между объектами.

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

3
James Rochabrun

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

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
3
Miras Maratuly

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{
}
2
Lal Krishna

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

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

}

0
Rohit Kashyap

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

@protocol addToCartDelegate <NSObject>

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

@end

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

[self.delegate addToCartAction:itemsModel isAdded:YES];
0
Vaibhav Gaikwad

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

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

Вот код, который рассматривает 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
        //
    }
}
0
Ellen