I have a block of objective-c code that responsible for handling HTTP errors by checking the NSError code error. The code sends the error message back to a delegate (unless it's a error code that the app ignores, such as cancelled requests)
failure:^(NSURLSessionTask *task, NSError *error, id responseObject) {
NSString *errorMessage = [self getErrorMessage:responseObject withError:error];
if (error.code!=kCFURLErrorCancelled &&
error.code!=kCFURLErrorCannotFindHost &&
error.code!=kCFURLErrorCannotConnectToHost &&
error.code!=kCFURLErrorNetworkConnectionLost &&
error.code!=kCFURLErrorDNSLookupFailed &&
error.code!=kCFURLErrorNotConnectedToInternet &&
error.code!=kCFURLErrorTimedOut) {
if ([self.delegate respondsToSelector:#selector(didFailed:)]) {
[self.delegate didFailed:errorMessage];
}
}
if (completionBlock != nil) completionBlock(NO);
}];
I have several questions / issues related to this code block.
Is is sufficient to just check the error code? The framework I'm using might return a different type of errors and I'm not sure those error codes are unique.
How would I go and write the same code in Swift? I did find the error codes definitions under CFNetworkErrors enum. However, the error.code & the value from the CFNetworkErrors enum cannot be compared directly, as they have different types. Is it possible to cast error.code to a CFNetworkErrors and then compare the error codes?
Can I safely switch to use the NSURL errors such as NSURLErrorCancelled? Is there a 1-to-1 mapping between the CFNetworks errors and NSURL errors?
It is probably not sufficient to check the error code. You almost certainly need to check the HTTP status code as well, unless the delegate method you're calling already does that. An NSError typically tells you about transport-level failures, whereas the status code tells you about server-side failures, such as a file not existing.
No idea. That question is mostly unrelated to networking, so you should probably ask a separate question for it, and tag it as a Swift question. :-)
Yes, you should be using the Foundation codes. The values should always be identical, but there are likely to be more Foundation error codes than CF codes going forward, as not all of the Foundation-level functionality is exposed publicly at the CF layer.
When using CodeRunner to test Objective-C code snippets, any exception thrown during run time will cause a crash, followed by the <my program> quit unexpectedly alert with complete stack trace and crash report saved in ~/Library/Logs/DiagnosticReports.
The exception can for instance be the result of a misspelled method name, and can happen quite often, depending on your personal development style. It is worth noticing that this crash report is also sent to Apple, which can seem a bit excessive for a misspelled method name.
Can this alert and crash report be avoided?
The default code template can be changed for each programming language in the app's Preferences settings.
If a try-catch block is added, the snippet can catch all its own exceptions and for instance just print out a log statement, hence avoiding the crash report.
For Objective-C, it can look like this:
#import <Foundation/Foundation.h>
int main(int argc, char *argv[]) {
#autoreleasepool {
#try {
%#
} #catch (NSException *e) {
NSLog(#"Exception caught: %#", e);
}
}
}
The %# defines the initial insertion point when a new file is opened.
I wrote a test to experiment with RestKit using blocks. I thought that the RKRequest.onDidLoadResponse would need to contain a dispatch_async() call to get the response on the main UI thread, though to my surprise this turned out to cause a runtime exception, so I took it out and I could update the interface quite fine.
My code in question is as follows:
- (IBAction)loadSeasons:(UIButton *)sender {
[[RKClient sharedClient] get:#"/api/v1/seasons" usingBlock:^(RKRequest* req) {
req.onDidLoadResponse = ^(RKResponse* res) {
NSLog(#"Request Performed: %#", res.bodyAsString);
self.textResponse.text = res.bodyAsString;
//dispatch_async(dispatch_get_main_queue(), ^{
// NSLog(#"In main queue: %#", res.bodyAsString);
//});
};
}];
}
If I uncomment the dispatch_async block I get the exception. So how do I know when I need to use this and when I should not need to? Should I test for something that tells me if the code being executed is on the main thread or not?
I am new to Objective-C and it's early days for me so I do apologise for what may be a newbie question.
UPDATE: When uncommenting the code above the following happens:
The console outputs the text (lldb) in blue, no other information is provided.
A break on libobjc.A.dylibobjc_msgSend:is shown in the editor on0x1c2009b: movl 8(%edx), %ediwith the message in green:Thread 1: EXC_BAD_ACCESS (code=1, address=0x40000008)`.
To answer your question you can check your current thread by calling [NSThread isMainThread]. However, you DONT need to do this for your issue and in fact its perfectly legal to dispatch an execution block to the main thread if you are already running in the main thread.
The crash is because of the way that variables are stored when executing a block. When the first block is completed the stack memory used by the variable can be overwritten, so by the time your async NSLog statement runs in the second block, your variable res has been destroyed, so its pointing to garbage when its used in your log statement, triggering a crash.
For completeness, research __block variable declarations. To make res referenceable in your second dispatch block I believe you'd have to declare it as a __block variable to move it to heap by declaring this in your first block: __block RKResponse* response = res; and then using response in your dispatched log statement.
This code is breaking for a non-fatal exception, but no significant error information is provided. This is after a core data entity has been updated.
-(void) commitBackgroundChangesAndNotify:(NSString *)notification{
NSLog(#"enter commit");
if([self.backgroundMOC hasChanges]) {
NSError *error = nil;
if (!([self.backgroundMOC save:&error])){ // breaks here
NSLog(#"Unresolved Error %# %#", error, [error userInfo]);
}
// [[NSNotificationCenter defaultCenter] postNotificationName:notification object:nil];
}
NSLog(#"exit commit");
}
It breaks in the debugger whether I have breakpoints enabled or not. If I run it without the debugger, it appears to run okay.
This code is run several times during an NSOperation. During the operation, the break occurs the second time it is called to save (meaning changes to the context have already been successfully saved once.) I verified that the backgroundMOC was created in the same thread that the changes and the commits are being made, which is the thread of the NSOperation. I also looked at the counts for the moc insertedObjects, updatedObjects, and deletedObjects. These all look right.
The calling code looks like this:
- (void) calculateBoundsForSearch {
NSArray *searchesArray = [currentSearchEntity.resultOfSearch allObjects];
MyMKMapBounds bounds = [MapController calculateBoundsForArrayOfSearchResults:searchesArray];
currentSearchEntity.minLatitude = [NSNumber numberWithFloat:bounds.min.latitude];
currentSearchEntity.minLongitude = [NSNumber numberWithFloat:bounds.min.longitude];
currentSearchEntity.maxLatitude = [NSNumber numberWithFloat:bounds.max.latitude];
currentSearchEntity.maxLongitude = [NSNumber numberWithFloat:bounds.max.longitude];
[dataInterface commitBackgroundChangesAndNotify:#"bounds"];
}
This is called by two objects. For one, there is no exception.
The only output in the console is this:
2012-07-22 10:47:13.790 myApp[46578:17e07] enter commit
Catchpoint 7 (exception thrown).2012-07-22 10:47:21.160 myApp[46578:17e07] exit commit
This is a non-fatal exception. One thing I noticed, which I don't understand, is that when it breaks, I have to click continue twice to get past it. The message Catchpoint 7 (exception thrown). is shown after the first click.
I'm trying to figure out what tools I have on hand to determine the cause of the exception. Of course, any ideas on what is causing the exception would be helpful, too.
What's the best way to throw an exception in objective-c/cocoa?
I use [NSException raise:format:] as follows:
[NSException raise:#"Invalid foo value" format:#"foo of %d is invalid", foo];
A word of caution here. In Objective-C, unlike many similar languages, you generally should try to avoid using exceptions for common error situations that may occur in normal operation.
Apple's documentation for Obj-C 2.0 states the following: "Important: Exceptions are resource-intensive in Objective-C. You should not use exceptions for general flow-control, or simply to signify errors (such as a file not being accessible)"
Apple's conceptual Exception handling documentation explains the same, but with more words: "Important: You should reserve the use of exceptions for programming or unexpected runtime errors such as out-of-bounds collection access, attempts to mutate immutable objects, sending an invalid message, and losing the connection to the window server. You usually take care of these sorts of errors with exceptions when an application is being created rather than at runtime. [.....] Instead of exceptions, error objects (NSError) and the Cocoa error-delivery mechanism are the recommended way to communicate expected errors in Cocoa applications."
The reasons for this is partly to adhere to programming idioms in Objective-C (using return values in simple cases and by-reference parameters (often the NSError class) in more complex cases), partly that throwing and catching exceptions is much more expensive and finally (and perpaps most importantly) that Objective-C exceptions are a thin wrapper around C's setjmp() and longjmp() functions, essentially messing up your careful memory handling, see this explanation.
#throw([NSException exceptionWith…])
Xcode recognizes #throw statements as function exit points, like return statements. Using the #throw syntax avoids erroneous "Control may reach end of non-void function" warnings that you may get from [NSException raise:…].
Also, #throw can be used to throw objects that are not of class NSException.
Regarding [NSException raise:format:]. For those coming from a Java background, you will recall that Java distinguishes between Exception and RuntimeException. Exception is a checked exception, and RuntimeException is unchecked. In particular, Java suggests using checked exceptions for "normal error conditions" and unchecked exceptions for "runtime errors caused by a programmer error." It seems that Objective-C exceptions should be used in the same places you would use an unchecked exception, and error code return values or NSError values are preferred in places where you would use a checked exception.
I think to be consistant it's nicer to use #throw with your own class that extends NSException. Then you use the same notations for try catch finally:
#try {
.....
}
#catch{
...
}
#finally{
...
}
Apple explains here how to throw and handle exceptions:
Catching Exceptions
Throwing Exceptions
Since ObjC 2.0, Objective-C exceptions are no longer a wrapper for C's setjmp() longjmp(), and are compatible with C++ exception, the #try is "free of charge", but throwing and catching exceptions is way more expensive.
Anyway, assertions (using NSAssert and NSCAssert macro family) throw NSException, and that sane to use them as Ries states.
Use NSError to communicate failures rather than exceptions.
Quick points about NSError:
NSError allows for C style error codes (integers) to clearly identify the root cause and hopefully allow the error handler to overcome the error. You can wrap error codes from C libraries like SQLite in NSError instances very easily.
NSError also has the benefit of being an object and offers a way to describe the error in more detail with its userInfo dictionary member.
But best of all, NSError CANNOT be thrown so it encourages a more proactive approach to error handling, in contrast to other languages which simply throw the hot potato further and further up the call stack at which point it can only be reported to the user and not handled in any meaningful way (not if you believe in following OOP's biggest tenet of information hiding that is).
Reference Link: Reference
This is how I learned it from "The Big Nerd Ranch Guide (4th edition)":
#throw [NSException exceptionWithName:#"Something is not right exception"
reason:#"Can't perform this operation because of this or that"
userInfo:nil];
You can use two methods for raising exception in the try catch block
#throw[NSException exceptionWithName];
or the second method
NSException e;
[e raise];
I believe you should never use Exceptions to control normal program flow. But exceptions should be thrown whenever some value doesn't match a desired value.
For example if some function accepts a value, and that value is never allowed to be nil, then it's fine to trow an exception rather then trying to do something 'smart'...
Ries
You should only throw exceptions if you find yourself in a situation that indicates a programming error, and want to stop the application from running. Therefore, the best way to throw exceptions is using the NSAssert and NSParameterAssert macros, and making sure that NS_BLOCK_ASSERTIONS is not defined.
Sample code for case: #throw([NSException exceptionWithName:...
- (void)parseError:(NSError *)error
completionBlock:(void (^)(NSString *error))completionBlock {
NSString *resultString = [NSString new];
#try {
NSData *errorData = [NSData dataWithData:error.userInfo[#"SomeKeyForData"]];
if(!errorData.bytes) {
#throw([NSException exceptionWithName:#"<Set Yours exc. name: > Test Exc" reason:#"<Describe reason: > Doesn't contain data" userInfo:nil]);
}
NSDictionary *dictFromData = [NSJSONSerialization JSONObjectWithData:errorData
options:NSJSONReadingAllowFragments
error:&error];
resultString = dictFromData[#"someKey"];
...
} #catch (NSException *exception) {
NSLog( #"Caught Exception Name: %#", exception.name);
NSLog( #"Caught Exception Reason: %#", exception.reason );
resultString = exception.reason;
} #finally {
completionBlock(resultString);
}
}
Using:
[self parseError:error completionBlock:^(NSString *error) {
NSLog(#"%#", error);
}];
Another more advanced use-case:
- (void)parseError:(NSError *)error completionBlock:(void (^)(NSString *error))completionBlock {
NSString *resultString = [NSString new];
NSException* customNilException = [NSException exceptionWithName:#"NilException"
reason:#"object is nil"
userInfo:nil];
NSException* customNotNumberException = [NSException exceptionWithName:#"NotNumberException"
reason:#"object is not a NSNumber"
userInfo:nil];
#try {
NSData *errorData = [NSData dataWithData:error.userInfo[#"SomeKeyForData"]];
if(!errorData.bytes) {
#throw([NSException exceptionWithName:#"<Set Yours exc. name: > Test Exc" reason:#"<Describe reason: > Doesn't contain data" userInfo:nil]);
}
NSDictionary *dictFromData = [NSJSONSerialization JSONObjectWithData:errorData
options:NSJSONReadingAllowFragments
error:&error];
NSArray * array = dictFromData[#"someArrayKey"];
for (NSInteger i=0; i < array.count; i++) {
id resultString = array[i];
if (![resultString isKindOfClass:NSNumber.class]) {
[customNotNumberException raise]; // <====== HERE is just the same as: #throw customNotNumberException;
break;
} else if (!resultString){
#throw customNilException; // <======
break;
}
}
} #catch (SomeCustomException * sce) {
// most specific type
// handle exception ce
//...
} #catch (CustomException * ce) {
// most specific type
// handle exception ce
//...
} #catch (NSException *exception) {
// less specific type
// do whatever recovery is necessary at his level
//...
// rethrow the exception so it's handled at a higher level
#throw (SomeCustomException * customException);
} #finally {
// perform tasks necessary whether exception occurred or not
}
}
There is no reason not to use exceptions normally in objective C even to signify business rule exceptions. Apple can say use NSError who cares. Obj C has been around a long time and at one time ALL C++ documentation said the same thing. The reason it doesnt matter how expensive throwing and catching an exception is, is the lifetime of an exception is exceedingly short and...its an EXCEPTION to the normal flow. I have never heard anyone say ever in my life, man that exception took a long time to be thrown and caught.
Also, there are people that think that objective C itself is too expensive and code in C or C++ instead. So saying always use NSError is ill-informed and paranoid.
But the question of this thread hasnt yet been answered whats the BEST way to throw an exception. The ways to return NSError are obvious.
So is it: [NSException raise:... #throw [[NSException alloc] initWithName....
or #throw [[MyCustomException... ?
I use the checked/unchecked rule here slightly differently than above.
The real difference between the (using the java metaphor here) checked/unchecked is important --> whether you can recover from the exception. And by recover I mean not just NOT crash.
So I use custom exception classes with #throw for recoverable exceptions, because
its likely I will have some app method looking for certain types of failures in multiple
#catch blocks. For example if my app is an ATM machine, I would have a #catch block for the
"WithdrawalRequestExceedsBalanceException".
I use NSException:raise for runtime exceptions since I have no way to recover from the exception,
except to catch it at a higher level and log it. And theres no point in creating a custom class for that.
Anyway thats what I do, but if there's a better, similarly expressive way I would like to know as well. In my own code, since I stopped coding C a hella long time ago I never return an NSError even if I am passed one by an API.