objective C underscore property vs self

Question

I\'m was playing around with the standard sample split view that gets created when you select a split view application in Xcode, and after adding a few fields i needed to ad

Answer 1

_property means you are directly accessing the property.

self.property means you are using accessors.

In your case, in the setter method you are calling it, creating a recursive call.

Answer 2

In the course of your experiment, you've set up an endless loop which is why the simulator goes non-responsive.

Calling self.detailItem within the scope of setDetailItem: calls setDetailItem: recursively since your class implements a custom setter method for the property detailItem.

I would refer you to the Apple documentation on declared properties for the scoop on properties, ivars, etc; but briefly, declared properties are a simplified way of providing accessor methods for your class. Rather than having to write your own accessor methods (as we had to do before Objective-C 2.0) they are now generated for you through the property syntax.

Answer 3

The properties are basically a way of the compiler to generate a setter and getter for a given instance variable.

So when you use something like:

id detailItem = self.detailItem;

what you are doing under the hood is:

id detailItem = [self detailItem];

Same for:

self.detailItem = otherDetailItem;

would be:

[self setDetailItem:otherDetailItem];

So when you write the setter yourself.. you get in an infinite loop since you access the method itself in itself. You can freely make use of the 'self.' notation in your class, just not when you're overriding the setter or accessor because of the mechanism I described above.

Cases in a class where I use the . notation over simply accessing the ivar is when I change the value, you never know inside your class what needs to happen when you change the value. do you have something in terms of a status that should notify some delegate that a status changed? Usually this is not the case, however, just by using the . notation you are making sure that in the future you won't have to refactor some code if you did decide to do some magic in your setter method.

Answer 4

I'll make an example (without ARC enabled):

@property (nonatomic, retain) NSNumber* number;

If you don't synthesize it, you can access it this way:

self.number= [NSNumber numberWithBool: YES];

This case the number is retained.If instead you synthesize it and don't use the property:

@synthesize number;

Later in the file:

number=[NSNUmber numberWithBool: YES];

You haven't used the property, so the number is not retained.That makes a relevant difference between using accessors and synthesized properties.