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?