8

我已经习惯将发送@optional委托的方法包装成：

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

它运作良好，但如果有很多委托的方法，它看起来像重复respondToSelector:代码......

在某个时间点，我使用respondsToSelector:了单独的方法：

//ignore warning
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"

- (void)performDelegateSelector:(SEL)selector withObject:(id)obj {

    if ([self.delegate respondsToSelector:selector]) {
        [self.delegate performSelector:selector withObject:obj];
    }
}

结果我只有一个 respondToSelector: 检查，但它看起来仍然没有得到很好的改进。

[self performDelegateSelector:@selector(method:) withObject:self];

你怎么看？使用一些帮助程序或类别来包装发送所有委托的方法是否有意义@optional，或者它是不应该改进的东西？

4

3 回答 3

13

性能方面，这取决于您对委托的用途，它是否直接影响 UI（在这种情况下，您希望获得更快的响应时间）等。

一个很好的速度优化是在您第一次设置委托时将委托实现的所有方法注册到一个数据结构中。你可以这样做：

struct {
    unsigned int myFirstMethod:1;
    unsigned int mySecondMethod:1;
} delegateRespondsTo;

-(void)setDelegate:(id<MyProtocol>)delegate
{
    self.delegate = delegate;
    delegateRespondsTo.myFirstMethod = [delegate respondsToSelector:@selector(myFirstMethod)];
    delegateRespondsTo.mySecondMethod = [delegate respondsToSelector:@selector(mySecondMethod)];
}

然后你可以简单地做

if ( delegateRespondsTo.myFirstMethod )
    [self.delegate myFirstMethod];

检查这个很好的答案以获得更详尽的解释。

于 2013-09-23T13:20:44.233 回答
4

您可以为此使用蹦床。蹦床是将消息转发到另一个对象的对象。这是一个简单的 DelegateTrampoline。

#import <objc/runtime.h>

@interface DelegateTrampoline : NSObject
- (id)initWithProtocol:(Protocol *)protocol delegate:(id)delegate;
@end

#import "DelegateTrampoline.h"

@interface DelegateTrampoline ()
@property (nonatomic) Protocol *protocol;
@property (nonatomic, weak) id delegate;
@end

@implementation DelegateTrampoline

- (id)initWithProtocol:(Protocol *)protocol delegate:(id)delegate {
  self = [super init];
  if (self) {
    _protocol = protocol;
    _delegate = delegate;
  }
  return self;
}

- (NSMethodSignature *)methodSignatureForSelector:(SEL)selector {
  // Look for a required method
  struct objc_method_description desc = protocol_getMethodDescription(self.protocol, selector, YES, YES);
  if (desc.name == NULL) {
    // Maybe it's optional
    desc = protocol_getMethodDescription(self.protocol, selector, NO, YES);
  }
  if (desc.name == NULL) {
    [self doesNotRecognizeSelector:selector]; // Raises NSInvalidArgumentException
    return nil;
  }
  else {
    return [NSMethodSignature signatureWithObjCTypes:desc.types];
  }
}

- (void)forwardInvocation:(NSInvocation *)invocation {
  SEL selector = [invocation selector];
  if ([self.delegate respondsToSelector:selector]) {
    [invocation setTarget:self.delegate];
    [invocation invoke];
  }
}

@end

以下是您将如何使用它：

@interface MyObject ()
@property (nonatomic) id delegateTrampoline;
@end
...
self.delegateTrampoline = [[DelegateTrampoline alloc] initWithProtocol:@protocol(MyProtocol)
                                                              delegate:delegate];

[self.delegateTrampoline myobject:self didSomethingAtIndex:1];
@end

一些注意事项：

  • 与其他方法相比，这非常慢。它需要创建一个NSInvocation对象，这可能比简单的方法调用慢数百倍。也就是说，除非您在紧密循环中调用您的委托方法，否则这可能不是问题。
  • 您必须声明delegateTrampoline为 type id。这允许您将任意选择器传递给它。但这也意味着编译器无法检测到您是否将选择器传递给delegateTrampoline不在协议中的选择器。如果你这样做，你会在运行时崩溃。编译器可以检测您是否传递了一个完全未知的选择器，因此它会捕获简单的拼写错误。
于 2013-09-23T13:58:42.667 回答
1

除了@micantox提供的答案之外，我还要补充一点，struct您可以使用它NS_OPTIONS来定义一个bitmask.

typedef NS_OPTIONS (NSUInteger, MyDelegateOptions) 
{ 
  MyDelegateOptionDidFinishedWithTaskOne = 1 << 0,
  MyDelegateOptionDidFinishedWithTaskTwo = 1 << 1,
  MyDelegateOptionDidFinishedWithTaskThree = 1 << 2
};

然后，您可以创建可以保存的属性bitmask：

@property (nonatomic, assign) MyDelegateOptions delegateOptions;

并检查respondsToSelector:您的设置器中的委托是否像

- (void)setDelegate:(id<MyDelegateProtocol>)delegate
{
  _delegate = delegate;
  if ([delegate respondsToSelector:@selector(myDelegateDidFinishedWithTaskOne:)]) {
  {
    self.delegateOptions = self.delegateOptions | MyDelegateOptionDidFinishedWithTaskOne;
  }

  if ([delegate respondsToSelector:@selector(myDelegateDidFinishedWithTaskTwo:)]) {
  {
    self.delegateOptions = self.delegateOptions | MyDelegateOptionDidFinishedWithTaskTwo;
  }

  if ([delegate respondsToSelector:@selector(myDelegateDidFinishedWithTaskThree:)]) {
  {
    self.delegateOptions = self.delegateOptions | MyDelegateOptionDidFinishedWithTaskThree;
  }
}

然后您可以使用简单地检查分配的位模式bitwise AND

if (self.delegateOptions & MyDelegateOptionDidFinishedWithTaskOne) {
    [self.delegate myDelegateDidFinishedWithTaskTwo:myResult];
}

如您所见，即使设置了其他位，如果将位设置为1bitwise AND ，使用将返回。trueMyDelegateOptionDidFinishedWithTaskOne

因此，如果您假设delegate已在您的设置器中检查并基于此您的delegateOptions持有位模式00000111和您MyDelegateOptionDidFinishedWithTaskOne表示的位模式00000001然后只需使用bitwise AND

00000111 & 00000001 = 00000001

你会得到true你的条件语句。

值得注意的是，在您delegate只需要检查一次或两次的情况下，这太过分了。

于 2016-02-19T10:24:45.767 回答