I am just a beginner in Objective-C but this seems very much like the reflection in Java that lets you create a Method object that you can then invoke() on any given instance. What are the differences (granted you know them)?

Notice that Scott's example doesn't indicate what class is actually implementing the method. Due to the dynamic nature of Objective-C, the object passed to setTarget: could be any object, not just self or a object of a particular class.

Instances of Java's Method class represent a "fully qualified" method. That is, the instance is a reference to both the method signature and the class that implements it. As such, you can't successfully invoke the method on an instance just because it has a method with the same signature. The target must be an instance of the same class as well.

Selectors in Objective-C represent "messages" that can be sent to any object, regardless of what class they are instantiated from. As long as the target object responds to the selector, the invocation is successful. If the target object does not respond to the selector, an exception is thrown or the target can optional forward the message on to another object.

You don't need to ask the class for the method signature, you can ask any object for the method signature corresponding to a selector:

sig = [self methodSignatureForSelector:mySelector];

Thank you.

I was playing around with NSInvocation to get around the argument number limitation in the performSelectorXXX methods.

I failed to pass in the addresses of the arguments and got the folowing announcement: *** Uncaught exception: <NSInvalidArgumentException> *** +[NSCFString length]: selector not recognized

I spent a lot of time trying to figure out the error but failed.

Finally, I ran to Google and found this page.

Again, thank you.

Here's a complete example:


@interface CurrentDate: NSObject
{
}

- (NSString *) stringForDate: (NSDate *)date usingFormatter: (NSDateFormatter *)formatter;

@end


@implementation CurrentDate;

- (NSString *) stringForDate: (NSDate *)date usingFormatter: (NSDateFormatter *)formatter
{

// yes, this doesn't do anything interesting.
// just using it as a simple example

return [formatter stringFromDate: date];

}

@end



int main (int argc, char *argv[]) {

NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

NSDateFormatter * dateFormat = [[NSDateFormatter alloc] initWithDateFormat:@"%b %d %Y" allowNaturalLanguage: NO];

CurrentDate * currentDateClassObject = [[CurrentDate alloc] init];
NSString * currentDate = [currentDateClassObject stringForDate: [NSDate date] usingFormatter: dateFormat];

NSLog(@"currentDate: %@", currentDate);


// get an Objective-C selector variable for the method

SEL mySelector;
mySelector = @selector(stringForDate:usingFormatter:);


// create a singature from the selector

NSMethodSignature * sig = nil;
sig = [[currentDateClassObject class] instanceMethodSignatureForSelector: mySelector];


// create an actual invocation object and set the target to currentDateClassObject

NSInvocation * myInvocation = nil;
myInvocation = [NSInvocation invocationWithMethodSignature: sig];
[myInvocation setTarget: currentDateClassObject];
[myInvocation setSelector: mySelector];


// add first argument

NSDate * myDate = [NSDate date];
[myInvocation setArgument: &myDate atIndex: 2];


// add second argument

NSDateFormatter * dateFormatter = [[NSDateFormatter alloc] init];
[dateFormatter setDateStyle: NSDateFormatterMediumStyle];
[myInvocation setArgument: &dateFormatter atIndex: 3];

NSString * result = nil;
[myInvocation retainArguments];
[myInvocation invoke];
[myInvocation getReturnValue: &result];

NSLog(@"The result is: %@", result);

[pool release];

return 0;

}

an excellent post. it's proven useful for catching accidental missing methods. here's a (perhaps naive) implementation:

- (void) forwardInvocation: (NSInvocation*)invocation
{
NSString* missingMethod = NSStringFromSelector([invocation selector]);
NSObject* object = [invocation target];
[invocation setArgument: &missingMethod atIndex: 2];
[invocation setArgument: &object atIndex: 3];
[invocation setSelector: NSSelectorFromString(@"methodMissing:object:arguments:")];
return [invocation invokeWithTarget:self];
}

-(void) methodMissing: (NSString*)method object:(id)object arguments:(NSMutableArray*)arguments {
println(@"%@ is missing %@", ((NSObject*)object).description, method);
}

- (NSMethodSignature *)methodSignatureForSelector:(SEL)sel
{
NSMethodSignature* sig = nil;
if ([self respondsToSelector:sel]) {
sig = [[self class] instanceMethodSignatureForSelector:sel];
}
else {
SEL methodMissingSelector = NSSelectorFromString(@"methodMissing:object:arguments:");
sig = [[self class] instanceMethodSignatureForSelector: methodMissingSelector];
}
return sig;
}


I wonder though if you know how to capture the arguments sent to a method without knowing the method signature? In this case, I'd like to actually capture the arguments being sent to the unknown method, put them into an array, and then send that along to my methodMissing method for later use. something like Ruby's method_missing.

any thoughts?

This is the most beautiful web page I've ever seen in my life.
Great article too.

@Kevin: This is the most beautiful web page I've ever seen in my life.
Great article too.

Kevin, much appreciated. Thanks.

Scott,
thanks for you post. It helped me in two respects:
a) I over-read the information about having to start at index 2 with setArgument: in Apple's documentation.
b) I assumed, I wouldn't need to use setSelector: on the invocation as that information was already contained in the NSMethodSignature that I used to create the NSInvocation using invocationWithMethodSignature:

So thanks again,
Chris

Thank you! Saved me a few more hours of really strange bugs!

a function i threw together for a project to store a message for later use

NSInvocation* storeMessage(id target, SEL selector, ...) { NSMethodSignature *sig = [[target class] instanceMethodSignatureForSelector:selector]; NSInvocation *nsInvocation = [NSInvocation invocationWithMethodSignature:sig]; [nsInvocation setTarget:target]; [nsInvocation setSelector:selector]; id eachObject; int cur = 2; va_list args; va_start(args, selector); while( eachObject = va_arg(args, id) ) { [nsInvocation setArgument:&eachObject atIndex:cur]; cur++; } va_end(args); [nsInvocation retain]; return nsInvocation; }

use:
NSInvocation* inv = storeMessage(targetObject, @selector(functionToCall), arg1, arg2, arg3, nil); [inv invoke];

Almost right! What you're doing when you set the arguments is passing the address of the POINTERS of the objects, not the objects themselves because remember, in Objective-C, what we usually call objects are technically pointers. So in essence, you're passing a pointer to a pointer (a.k.a. an objective-c class).

Great article.

I was wondering if this would also work for invoking class methods on a class object? For example if +stringForDate:usingFormatter: was a class method instead of an instance method:

SEL mySelector; mySelector = @selector(stringForDate:usingFormatter:); NSMethodSignature * sig = nil; sig = [self methodSignatureForSelector:mySelector]; NSInvocation * myInvocation = nil; myInvocation = [NSInvocation invocationWithMethodSignature:sig]; [myInvocation setTarget:[self class]]; // <-- will this work? [myInvocation setSelector:mySelector];

and the rest given as above?

Best,
Dalmazio

Nice piece of explanation. Better than Apple's. What would be interesting is talk about performance and introspection, especially on the iPhone. Does anyone know a solid benchmark available on the web?