关于 iOS delegate 的遐想

Delegate  作为iOS 系统中一种非常常用的设计模式，在很多地方使用的地方非常的多。

之前刚开始接触OC 的时候，对于这个delegate模式非常的不理解，不知道这个所谓的delegate 是用来干嘛的。

不过做了几年的iOS开发后，对于这一块也算是有自己的理解了。

首先 delegate 的定义是一个继承特定接口的对象。

比如定义了如下接口:

#ifndef Protocol_h
#define Protocol_h

@protocol TestProtocol <NSObject>

-(void)firstInterface;
-(void)secondInterface;

@end

然后在另外一个对象里面，有这么一个属性继承自这个接口：

#import <Foundation/Foundation.h>
#import "Protocol.h"

@interface TestClass : NSObject

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

@end

这样的好处就像一个一把起子，对于只要符合这个起子的螺丝钉，不管是长的短的，都可以操作，因为这些螺丝钉都的接口（对应我们的 protocol）都一样，在适当的时候可以进行替换。 所以 delegate 有一种面向抽象编程的意思，对象是不具体的但是接口是定义好的。

除此之外。 delegate 还可以做两件事情

大家常说的delegate模式，其实也就是这个意思。不过delegate模式不是一种模式，它是两种分别不同的功能。

第一点个就是回调。

A 有一件事情自己办不了，要找B 帮忙办理，办理完之后B得把结果告诉A ，然后通过delegate 找到A。

这里的delegate 就是A, 要得到结果，就得实现B提供的接口，这个接口是B调用A 用来告诉A结果的。

首先是类B 它是一个工具一样的东西，能够帮忙干活，然后干完活通知 让他干活的那个 对象，就是A

它的实现如下：

#import <Foundation/Foundation.h>

@protocol ResultProtocal <NSObject>
@optional
-(void)addResult:(NSInteger)value;
-(void)mutiplayResult:(NSInteger)value;
@end


@interface ObjectB : NSObject

///计算两个数之和
-(void)caculateAdd:(NSInteger)a value:(NSInteger)b;
///计算两个数的乘积
-(void)caculateMultiply:(NSInteger)a value:(NSInteger)b;

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

@end

#import "ObjectB.h"


@implementation ObjectB



///计算两个数之和
-(void)caculateAdd:(NSInteger)a value:(NSInteger)b
{
    if (self.delegate && [self.delegate respondsToSelector:@selector(addResult:)]) {
        [self.delegate addResult:(a+b)];
    }
}
///计算两个数的乘积
-(void)caculateMultiply:(NSInteger)a value:(NSInteger)b
{
    if (self.delegate && [self.delegate respondsToSelector:@selector(mutiplayResult:)]) {
        [self.delegate addResult:(a*b)];
    }
}

@end

A 呢，A 只管让B 干事情就行了，但是干完事B 得告诉A 啊，所以A得 实现函数，让B 告诉自己结果：

A的实现如下：

#import "ObjectA.h"
#import "ObjectB.h"

@interface ObjectA()<ResultProtocal>

@end

@implementation ObjectA




-(void)mainFunction
{

    ObjectB *b = [ObjectB new];//创建一个执行任务的对象
    b.delegate = self;//告诉B 你任务完成了之后找我就行了
    [b caculateAdd:100 value:200];//b 开始执行任务
}



/// 对象A 实现 工具B 完成任务的结果调用函数
-(void)addResult:(NSInteger)value
{
    
}


-(void)mutiplayResult:(NSInteger)value
{
    
}

@end

好了这是第一种 delegate 的应用场景，看起来有一点 异步工作的概念，事情交给你干，结果告诉我就得了。

这也是一种面向接口的编程。 比如同一种计算方法： 不仅可以有ObjectB 也许还有ObjectD 或者 ObjectE呢，也是可以的

他们虽然都提供了计算方法，但是对于不同的场景，也许计算的实现不一样，有的可以用二进制，有的可以用递归，有的可以使用

更高级的算法等等不一而论，具有可变性。

另外一种delegate 的使用方法，有点强盗的意味。还是A 和 B 但是呢，但是呢这里的角色得调换一下位置。

当然  A 仍然是 delegate 但是 这个时候 A 变成了干活的那一方。

这很神奇么？这不神奇。 这个时候，A 集成了方法，并且实现了方法，B中仍然有一个delegate对象，这个对象就是A。

下面看A代码：

#import "ObjectA.h"
#import "ObjectB.h"

@interface ObjectA()

@end

@implementation ObjectA

-(NSString*)todayIs
{
 
    return @"Friday";
}
-(NSString*)tomorroyIs
{
    return @"Saturday";
}

@end

再来看看B的代码：

#import <Foundation/Foundation.h>

@protocol ResultProtocal <NSObject>
@optional
-(NSString*)todayIs;
-(NSString*)tomorroyIs;
@end


@interface ObjectB : NSObject

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

@end

#import "ObjectB.h"


@implementation ObjectB



-(void)mainFunction
{
    /// 一开始很闲，突然想知道 今天周几了，那好吧，让A 告诉我
    if (self.delegate && [self.delegate respondsToSelector:@selector(todayIs)]) {
        NSString *today = [self.delegate todayIs];
        NSLog(@"%@",today);
    }
}

@end

B 摇身一遍称为了让A 干活的人。。。

从代码中可以看到 第二种情况， 定义的协议的函数实现，都有返回值。 这是和第一种情况不一样的地方。

而且 B 的这种调用方式，很像 同步操作。

一个delegate 两种玩法，也挺有意思。