Objective-C Fundamentals

How messaging works
169
8.3.2 Handling unknown selectors
Because method binding occurs at runtime, it’s possible for an object to receive a message
to which it doesn’t know how to respond. This situation is an error, but before
announcing the error, the runtime system gives the receiving object a second chance to
handle the message. The process is commonly called message forwarding and can be used
to easily implement certain design patterns such as the Decorator or Proxy patterns.
When Objective-C can’t determine via class metadata which method to invoke for a
message selector, it first checks to see if the class wants the entire message sent
unchanged to another object. It attempts to invoke the forwardingTargetForSelector:
message, which could be implemented by a class as follows:
- (id)forwardingTargetForSelector:(SEL)sel {
return anotherObject;
}
With this implementation, any unknown message sent to the object is redirected, or
forwarded, to the object represented by anotherObject. This makes the original
object appear from the outside as though it combined the features of both objects.
Obviously the implementation of forwardingTargetForSelector: could become
more complex. As an example, you could dynamically return different objects on the
basis of the particular method selector passed in as an argument.
forwardingTargetForSelector: is commonly called the “fast-forwarding path,”
because it quickly and easily causes a message to be forwarded to another object without
requiring too much code to be developed (or executed during runtime). It does have
limitations, however: for instance, it isn’t possible to “rewrite” a message send to redirect
a message addressed to one selector to be processed by another; nor is it possible to
“drop” a message and ignore it. Fortunately, a “normal forwarding path” goes into
action whenever the fast path doesn’t provide a suitable implementation for a missing
method selector, and this feature provides more flexibility in how a message is handled.
If forwardingTargetForSelector: isn’t implemented or fails to find a suitable target
object (it returns nil), the runtime, before announcing an error, sends the object
a forwardInvocation: message with an NSInvocation object as its sole argument.
An NSInvocation object encapsulates the message being sent. It contains details
about the target, selector, and all arguments specified in a message send and allows
full control over the return value.
Because your implementation of forwardInvocation: has full access to the
NSInvocation object, it can inspect the selector and arguments, modify them, and potentially
replace them, leading to a wide range of possibilities for altering the behavior.
NSObject’s default implementation of forwardInvocation
Every object that inherits from NSObject has a default implementation of the forwardInvocation:
message. But NSObject’s version of the method invokes
doesNotRecognizeSelector:, which logs an error message.