Custom getter side-effects

Are there side-effects to callin开发者_运维问答g a custom getter with dot notation?

I had been using a synthesized getter in Objective-C via the dot notation, i.e.

tree.fruitnumber

returned the number of fruits in tree. I had to customize the getter (for reasons not pertinent to this question). I wrote it as

-(int) fruitnumber
{
   //climb into tree and hand count fruits. Get n;
   return n;
}

Suprisingly, the dotted getter still works. Is this legit, or there is a nasty bug (which will infect all my fruits down the road (to the market?)).

Dot notation is really just syntactic-sugar for bracket notation. So both messages are the same:

int x = [self fruitNumber];
int x = self.fruitNumber;

The nice thing is, you can @synthesize your properties and the setter/getter methods will be built for you (depending on your property options, of course) but you can write your own instead and they will be used.

In the case where you are providing your own setters/getters, you can alternatively use the @dynamic propertyName line instead of @synthesize to tell the compiler these are being provided by you.

There's are some side effects that no one has mentioned:

• Atomicity - if you don't declare a property as nonatomic, then (by default) it is an atomic property, which means that the value of the property will be full retrieved regardless of what other threads might be doing to mutate the property at the same time. If you have an atomic property and then override the getter or setter, you lose the atomicity (unless you implement it yourself).
• Key-Value observation - by using the @synthesized methods, you are ensuring KVO compliance, which makes it very easy to observe values of the object as they change (and be notified of such changes). If you override the synthesized methods, you risk breaking that compliance.

So it is generally safe to override synthesized getters and setters, but there are caveats, and it is very important that you understand what they are so that if/when things break, you know why.

You can specify a custom getter when declaring the property, i.e.:

@property (readwrite, getter=numberOfFruitsCountedByTheCustomGetter) int fruitnumber;

In your implementation, synthesize it as usual:

@synthesize fruitnumber;

Then implement the getter:

- (int) numberOfFruitsCountedByTheCustomGetter {
    return fruitnumber;
}

It doesn't matter whether you write the getter or it is synthesized, it gets called when you use the dotted notation (or the bracket notation). This is the way it is supposed to work.

The dot notation is just shorthand for calling the getter or setter method. There is no difference beyond how it looks.

A common side effect used in getters is a lazy getter.

-(id) something {
  if ( nil == something ) {
    something = ...;
  }
  return something;
}

A getter does not have to be related to a specific member. It can return the result of a calculation or lookup, or pass on something from a member object.

Progrmr is correct. However I'd consider putting in the @dynamic declaration to explicitly tell the compiler you are creating the getter. Here's a link to the documentation om properties. It's worth a wad if you have had a chance.

http://developer.apple.com/mac/library/iPad/index.html#documentation/Cocoa/Conceptual/ObjectiveC/Articles/ocProperties.html