如何在Objective-C中创建委托？

我知道代表是如何工作的，我知道如何使用它们。

但我如何创造它们？

379595 次浏览
小开
最佳答案

Objective-C委托是已分配给delegate属性另一个对象的对象。要创建一个，您需要定义一个实现您感兴趣的委托方法的类，并将该类标记为实现委托协议。

例如，假设您有一个UIWebView。如果您想实现其委托的webViewDidStartLoad:方法，您可以创建一个如下所示的类：

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


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

然后您可以创建MyClass的实例并将其分配为Web视图的委托：

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

在UIWebView端，它可能有类似的代码，以查看委托是否使用respondsToSelector:响应webViewDidStartLoad:消息并在适当的情况下发送它。

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

委托属性本身通常声明为weak（在ARC中）或assign（在ARC之前）以避免保留循环，因为对象的委托通常包含对该对象的强引用。（例如，视图控制器通常是它包含的视图的委托。）

为您的班级制作代表

要定义自己的委托，您必须在某处声明它们的方法，如Apple Docs on协议中所述。您通常声明一个正式的协议。声明从UIWebView. h转述，如下所示：

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

这类似于接口或抽象基类，因为它为您的委托创建了一个特殊类型，在本例中为UIWebViewDelegate。委托实现者必须采用此协议：

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

然后实现协议中的方法。对于在协议中声明为@optional的方法（与大多数委托方法一样），您需要在调用特定方法之前使用-respondsToSelector:进行检查。

命名

委托方法通常以委托类名开头命名，并将委托对象作为第一个参数。它们也经常使用意愿、应该或did-形式。例如，webViewDidStartLoad:（第一个参数是Web视图）而不是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（这使得自动完成变得不那么有用）并使编译器很难警告你拼写错误和类似错误。

小开

也许这更符合你所错过的：

如果你来自一个C++的观点，代表们需要一点习惯-但基本上他们只是工作。

它的工作方式是你设置一些你编写的对象作为NSWindow的委托，但你的对象只有许多可能的委托方法中的一个或几个的实现（方法）。所以发生了一些事情，NSWindow想要调用你的对象——它只是使用Objective-c的respondsToSelector方法来确定你的对象是否希望调用该方法，然后调用它。这就是Objective-c的工作方式——方法是按需查找的。

用你自己的对象执行此操作是完全微不足道的，没有什么特别的，例如，你可以有一个由27个对象组成的NSArray，所有不同类型的对象，只有18个其中一些具有方法-(void)setToBue;，其他9个没有。所以要在所有18个需要它的对象上调用setToBlue，如下所示：

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

关于委托的另一件事是它们不会被保留，因此您必须始终在MyClass dealloc方法中将委托设置为nil。

小开

在使用正式协议方法创建委托支持时，我发现您可以通过添加以下内容来确保正确的类型检查（尽管是运行时，而不是编译时）：

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

在您的委托访问器代码中。这有助于最大限度地减少错误。

小开

批准的答案很棒，但如果您正在寻找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

要在另一个类中使用您的委托（在本例中称为MyVC的UIViewController）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!");
}
小开

请检查下面的简单的一步一步的教程，以了解如何代表在iOS工作。

代理iOS

我创建了两个ViewController（用于将数据从一个发送到另一个）

  1. FirstViewController实现委托（提供数据）。
  2. 秒视图控制器声明委托（将接收数据）。
小开

我认为一旦你理解了委托，所有这些答案都很有意义。就我个人而言，我来自C/C++的土地，在此之前，程序语言如Fortran等，所以这是我在C++范式中寻找类似类似物的2分钟。

如果我要向C++/Java程序员解释委托，我会说

什么是代表？ 这些是指向另一个类中类的静态指针。一旦您分配了指针，您就可以调用该类中的函数/方法。因此，您类的某些函数被“委托”（在C++世界中-类对象指针指向的指针）到另一个类。

什么是协议？ 从概念上讲，它与您分配为委托类的类的头文件具有相似的目的。协议是定义需要在类中实现哪些方法的显式方法，该类的指针被设置为类中的委托。

我如何在C++做类似的事情？ 如果你试图在C++中这样做，你需要在类定义中定义指向类（对象）的指针，然后将它们连接到其他类，这些类将作为委托给你的基类提供额外的功能。但是这种连接需要在代码中进行，并且会笨拙且容易出错。ObjectiveC只是假设程序员不擅长维护这种决策，并提供编译器限制来强制执行干净的实现。

小开

好吧，这不是一个真正的问题的答案，但如果你正在寻找如何让你自己的代表，也许更简单的东西可能是一个更好的答案。

我几乎不实现我的委托，因为我很少需要。一个委托对象只能有一个委托。所以如果你希望你的委托进行单向通信/传递数据，而不是通知。

NSNotify可以将对象传递给多个收件人，并且非常易于使用。 它是这样工作的：

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];
}
小开

作为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检查视图（符合您的委托）是否实际实现了您的可选方法。

小开

假设你有一个你开发的类，并且想要声明一个委托属性，以便能够在发生某些事件时通知它：

@class myClass;


@protocol myClassDelegate <NSObject>


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


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


@end




@interface MyClass : NSObject


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


@end

因此，您在MyClass头文件（或单独的头文件）中声明了一个协议，并声明了委托必须/应该实现的必需/可选事件处理程序，然后在MyClass中声明了一个类型（id< MyClassDelegate>）的属性，这意味着任何符合协议MyClassDelegate的目标c类，您会注意到委托属性被声明为弱，这对于防止保留循环非常重要（通常委托保留MyClass实例，因此如果您将委托声明为保留，它们都将相互保留，并且它们都不会被释放）。

您还会注意到，协议方法将MyClass实例作为参数传递给委托，这是最佳实践，以防委托想要在MyClass实例上调用某些方法，并且当委托将自己声明为MyClassDelegate时也会有所帮助多个MyClass实例，就像当您在ViewController中有多个UITableView's实例并将自己声明为UITableViewDelegate时一样。

在您的MyClass中，您使用声明的事件通知委托，如下所示：

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

您首先检查您的委托是否响应您即将调用的协议方法，以防委托未实现它并且应用程序将崩溃（即使需要协议方法）。

小开

要创建自己的委托，首先您需要创建一个协议并声明必要的方法，而不需要实现。然后将此协议实现到您想要实现委托或委托方法的头类中。

协议必须声明如下：

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

就是这样，通过在这个类中实现委托方法，一旦操作/任务完成，控制就会回来。

小开

这是一个创建委托的简单方法

在. 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

在协议行为中定义的方法可以通过作为协议定义的一部分的@可选和@必需来控制。

步骤：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];
}
}
小开

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. 当一个类想要允许另一个类自定义它时

除了委托类符合所需的协议之外，这些类不需要事先知道彼此的任何信息。

我强烈建议阅读以下两篇文章。它们帮助我比留档更好地理解代表。

小开

代表：-创建

@protocol addToCartDelegate <NSObject>


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


@end

发送并请指定代表以查看您正在发送数据

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

视图控制器h

@protocol NameDelegate <NSObject>


-(void)delegateMEthod: (ArgType) arg;


@end


@property id <NameDelegate> delegate;

视图控制器

[self.delegate delegateMEthod: argument];

主视图控制器

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

方法：

-(void)delegateMEthod: (ArgType) arg{
}
小开 
//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中实现方法 -（无效）删除带有标签的单元格：（NS整数）标签 { NSLog@（"Tag%d"， tag）；

}

小开

在我看来，为该委托方法创建单独的类，您可以在想要的地方使用。

在我的自定义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;

在那个in. 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];
}
}
}];
}

这里都设置为自定义委托class.after您可以使用此委托方法，您want.for示例…

在我的另一个视图控制器导入之后

创建调用委托方法的操作，如下所示

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

免责声明：这是如何创建delegate的Swift版本。

在软件开发中，有一些通用的可重用解决方案体系结构，有助于解决给定上下文中常见的问题，这些“模板”可以说是最著名的设计模式。 委托是一种设计模式，允许一个对象在特定事件发生时向另一个对象发送消息。 想象一下，一个对象A调用一个对象B来执行一个动作。一旦动作完成，对象A应该知道B已经完成了任务并采取必要的动作，这可以在委托的帮助下实现！

为了更好的解释，我将向您展示如何创建一个在类之间传递数据的自定义委托，在一个简单的应用程序首先下载或克隆这个启动项目并运行它！中使用Swift

你可以看到一个有两个类的应用程序，ViewController A和ViewController B. B有两个视图，可以随时更改ViewController的背景颜色，没有什么太复杂的了吧？现在让我们以一种简单的方式思考，当点击B类的视图时，也可以更改A类的背景颜色。

问题是这个视图是类B的一部分，不知道类A，所以我们需要找到一种方法来在这两个类之间进行通信，这就是委托的亮点。 我将实现分为6个步骤，因此您可以在需要时将其用作备忘单。

步骤1：在ClassBVC文件中查找Pragma标记步骤1并添加此

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

第一步是创建一个protocol，在这种情况下，我们将在类B中创建协议，在协议内部，您可以根据实现的要求创建任意数量的函数。在这种情况下，我们只有一个简单的函数接受可选的UIColor作为参数。 为您的协议命名是一个很好的做法，在类名的末尾添加单词delegate，在本例中为ClassBVCDelegate。

第2步：在ClassVBC中查找Pragma标记步骤2并添加以下内容

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

这里我们只是为类创建一个委托属性，该属性必须采用protocol类型，并且它应该是可选的。此外，您应该在属性之前添加弱关键字以避免保留周期和潜在的内存泄漏，如果您不知道这意味着什么，请不要担心，请记住添加此关键字。

第3步：在句柄内查找Pragma标记步骤3点击ClassBVC中的method并添加以下内容

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

你应该知道的一件事，运行应用程序并点击任何视图，你不会看到任何新行为，这是正确的，但我想指出的是，调用委托时应用程序不会崩溃，这是因为我们将其创建为可选值，这就是为什么即使委托还不存在它也不会崩溃。现在让我们转到ClassAVC文件并使其成为委托。

步骤4：在ClassAVC中的handleTap方法中查找Pragma标记步骤4，并像这样将其添加到您的类类型旁边。

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

现在ClassAVC采用了ClassBVCDelegate协议，你可以看到你的编译器给你一个错误，上面写着“类型'ClassAVC不符合协议'ClassBVC代表'，这只意味着你还没有使用协议的方法，想象一下，当A类采用协议时，就像与B类签订合同一样，这个合同说“任何采用我的类都必须使用我的函数！”

快速说明：如果你来自Objective-C背景，你可能会认为你也可以关闭那个错误，使该方法可选，但令我惊讶的是，也许是你的，Swift语言不支持可选的protocols，如果你想这样做，你可以为你的protocol创建一个扩展，或者在你的protocol实现中使用@Object c关键字。

就我个人而言，如果我必须创建一个具有不同可选方法的协议，我宁愿将其分解为不同的protocols，这样我将遵循为我的对象赋予单一责任的概念，但它可以根据具体实现而有所不同。

这里是关于可选方法的好文章。

第5步：在准备segue方法中查找语用标记步骤5，并添加以下内容

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

在这里，我们只是创建一个ClassBVC的实例并将其委托分配给自己，但是这里的自我是什么？好吧，自我是已委托的ClassAVC！

第6步：最后，在ClassAVC中寻找实践步骤6，让我们使用protocol的函数，开始输入func更改背景颜色，你将看到它正在为你自动完成它。你可以在其中添加任何实现，在这个例子中，我们将只更改背景颜色，添加这个。

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

现在运行应用程序！

Delegates无处不在，你可能在没有通知的情况下使用它们，如果你创建一个tableview，过去你使用委托，许多UIKIT类围绕它们工作，许多其他frameworks也一样，它们解决了这些主要问题。

  • 避免物体的紧密耦合。
  • 修改行为和外观，而无需子类化对象。
  • 允许将任务处理到任何任意对象。

恭喜你，你刚刚实现了一个自定义委托，我知道你可能在想，这么多麻烦只是为了这个？好吧，委托是一个非常重要的设计模式，如果你想成为一个iOS开发人员，要理解，并始终记住，他们之间有一对一的关系对象。

您可以查看原始教程这里

小开

让我们从一个例子开始，如果我们在网上购买一个产品，它会经历不同团队处理的运输/交付等过程。因此，如果运输完成，运输团队应该通知交付团队，这应该是一对一的沟通，因为广播此信息对其他人/供应商可能希望仅将此信息传递给所需的人来说是开销。

因此，如果我们从我们的应用程序的角度思考，一个事件可以是一个在线订单，不同的团队可以像多个视图。

以下代码将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
//
}
}
小开

答案实际上已经回答了，但我想给你一个创建代表的“备忘单”：

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

提交答案