Beste Weg, zu überprüfen, ob Delegierte reagiert auf optional selector

Habe ich benutzt, Verpackung Versand @optional delegate-Methoden in:

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

Es funktioniert gut, aber wenn es gibt viele delegate-Methoden, es sieht aus wie das duplizieren respondToSelector: code...

Irgendwann Zeit habe ich respondsToSelector: zu trennen Methode:

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

Als Ergebnis habe ich nur eine respondToSelector: überprüfen, aber Es immer noch nicht sehen, wie gut verbessert.

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

Was denkst du? Macht es Sinn in der Verwendung von einigen Helfern oder Kategorie zu wickeln senden alle @optional delegate-Methoden, oder ist es etwas, das nicht sollte verbessert werden?

InformationsquelleAutor Injectios | 2013-09-23

13

Performance-Weise, es hängt davon ab, welchen Einsatz Sie machen die Delegierten, ob es direkt Auswirkungen auf die UI (in dem Fall, dass Sie wollen, haben eine schnellere Reaktionszeit) etc.

Einen guten Geschwindigkeits-Optimierung ist, sich zu registrieren alle Methoden implementiert, die von den Delegierten in einer Daten-Struktur, wenn Sie zuerst die Stellvertretung. Sie tun konnten:
```
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)];
}
```
Dann können Sie einfach tun
```
if ( delegateRespondsTo.myFirstMethod )
    [self.delegate myFirstMethod];
```
Überprüfen Sie diese große Antwort für die ausführliche Erklärung.

InformationsquelleAutor micantox

Können Sie ein Trampolin für dieses. Ein Trampolin ist ein Objekt, das leitet Nachrichten an ein anderes Objekt. Hier ist eine einfache 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

Hier ist, wie Sie es benutzen würden:

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

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

Einige Hinweise:

Dies ist sehr langsam im Vergleich zu anderen Ansätzen. Es erfordert die Schaffung einer NSInvocation Objekt, die mehrere hundert mal langsamer als ein einfacher Methodenaufruf. Das heißt, es sei denn, Sie fordern Ihre Delegat-Methode in einer engen Schleife, es ist wahrscheinlich nicht ein problem.
Müssen Sie erklären delegateTrampoline Typ id. Dies ermöglicht die übergabe von beliebigen Selektoren, um es. Es bedeutet aber auch, dass der compiler nicht erkennen, wenn Sie passieren einen Selektor delegateTrampoline, die nicht in das Protokoll. Wirst du Abstürzen zur Laufzeit, wenn Sie dies tun. Der compiler kann erkennen, wenn Sie passieren ein völlig unbekannter Selektor, so dass es dann Fang einfach Tippfehler.

klingt gut, aber ich meinte - so reduzieren Sie den Umfang des Codes, nicht aber auf die Leistung zu reduzieren.. Und wenn gibt es viele delegate-Methoden werden ausgeführt, es kann wirkt app perofrmance
Wenn von den vielen meinst du, ein Dutzend oder zwei Dutzend Anrufe, wird dies keine nennenswerten Auswirkungen auf die performance. Wenn Sie viel Sie bedeuten, dass Hunderte oder Tausende von anrufen in einer engen Schleife, dann ja, dann könnte es sich auf die Leistung auswirken. Der Unterschied zwischen einer Nanosekunde und eine Millisekunde ist Massiv, aber auf ein Dutzend Anrufe, die Sie nie den Unterschied bemerken.
Ich habe festgestellt ähnlichen Ansatz hier borkware.com/rants/agentm/elegant-delegation mit NSProxy

InformationsquelleAutor Rob Napier

Oben auf Antwort @micantox ich möchte hinzufügen, dass statt struct könnten Sie NS_OPTIONS zu definieren bitmask.

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

Dann könnten Sie erstellen, die Eigenschaft, die halten kann bitmask:

@property (nonatomic, assign) MyDelegateOptions delegateOptions;

tun und prüfen, ob delegieren respondsToSelector:in Ihre setter wie

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

Dann können Sie einfach überprüfen belegt bit-Muster durch die Verwendung bitwise AND

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

Wie Sie sehen können, die Verwendung von bitwise AND zurück true wenn etwas für MyDelegateOptionDidFinishedWithTaskOne wird als 1, auch wenn die anderen bits sind auch gesetzt werden.

So, wenn Sie vermuten, dass delegate war aktiviert, in den setter und auf dieser Basis Ihre delegateOptions hält die bit-Muster der 00000111 und Ihre MyDelegateOptionDidFinishedWithTaskOne repräsentiert die bit-Muster der 00000001 dann einfach mit bitwise AND

00000111 & 00000001 = 00000001

erhalten Sie true mit Ihrem bedingten Anweisung.

Lohnt es sich, notting, dass dies übertrieben ist, in Situationen, wenn Sie brauchen, um zu überprüfen, Ihre delegate nur einmal oder zweimal.

InformationsquelleAutor Bartosz Szczepaniak

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.