Synthesizing properties in categories

Question

I'm trying to declare properties that are for internal use only in a Private category as such:

@interface BarLayer (Private)

@property (readwrite, retain) MenuItemFont  *menuButton;
@property (readwrite, retain) Menu          *menuMenu;
@property (readwrite, retain) LabelAtlas    *messageLabel;

@end

Now I'm trying to figure out where exactly I'm supposed to @synthesize those.

I tried:

@implementation BarLayer (Private)

@synthesize menuButton      = _menuButton;
@synthesize menuMenu        = _menuMenu;
@synthesize messageLabel    = _messageLabel;

@end

Here, the compiler complains:

@synthesize not allowed in a category's implementation

So I tried putting it in my BarLayer implementation, but here it doesn't find the declarations in the BarLayer interface.

no declaration of property ‘menuButton’ found in the interface

What would the correct way be?

Answer 1

Because categories can only add methods to a class you can't get around this by trying to define property methods in the category.

You can declare properties that are derived from already existing classes. For example. If your class has a firstName and a lastName property, you can declare a property called fullName in a category @implementation.

@interface Bar (Private)
@property (readonly) NSString *fullName; // Note readonly, you have nothing to write to.
@end

However, you can't just @synthesize this property, you would have to write your own accessor because the compiler has no idea where you want to get this value from.

@implementation Bar (Private)
- (NSString *)fullName {
    NSString *returnString = [NSString stringWithFormat:@"%@ %@", 
                             self.firstName, self.lastName];
}

From a class design point of view, I'm not sure that the idea of a private property makes sense: I personally think of properties as something that are exposed publically by a class.

you could use the @private keyword in the BarLayer class to at least add some protection to its state.

Answer 2

You can't use @synthesize with a category. (I've run into this before - it looks like a bug to me.)

You can do this with an extension, which is just a category without a name whose methods must be implemented in the main @implementation block for that class. For your code, just change "(Private)" to "()" and use @synthesize in the main @implementation block along with the rest of your code for that class.

See the Apple docs on extensions for more about that. (Apparently this is new in Mac OS 10.5.)

EDIT: An example:

// Main interface (in .h)
@interface Foo : NSObject
{
    int myData;
}
- (void) bar;
@end

// Private interface (in .m, or private .h)
@interface Foo ()
    @property myData;
@end

@implementation Foo
    - (void) bar { ... }
    @synthesize myData;
@end

Answer 3

Scott Stevenson (http://theocacao.com/) explains in his blog post "A Quick Objective-C 2.0 Tutorial: Part II" how to get Public Properties with Private Setters. Following his advice you will get a property that is read-only to the public, but has a private setter which can be used with the dot-syntax. Hope this helps...

Answer 4

I found an explanation of why synthesis of properties is prohibited in categories, but how you can use class extensions instead:

The following information comes from http://www.friday.com/bbum/2009/09/11/class-extensions-explained/

"The reason synthesis was prohibited in categories was because synthesis requires storage and there was no way of declaring storage in a category efficiently and it wasn’t deemed acceptable to allow a category to synthesize methods that would then diddle the class’s ivars directly. Too fragile and ugly.

However, it was also obviously desirable to be able to declare a property that was publicly readonly, but whose implementation was readwrite for internal-to-the-class-or-framework purposes.

One additional requirement is that the synthesis such properties must always be able to synthesize both the setter and getter naturally and precisely. Specifically, when declaring a property as atomic, there is no way the developer can correctly manually write only 1/2 of the getter setter pair; the locking infrastructure is not exposed and, thus, there is no way to guarantee atomicity in such a situation.

Class extensions addressed this problem elegantly.

Specifically, you can declare a property like:

@interface MyClass : NSObject
@property(readonly) NSView *targetView;
@end

And, then, in the implementation file:

@interface MyClass()
@property(readwrite) NSView *targetView;
@end

@implementation MyClass
@synthesize targetView;
@end

End result? A property that is publicly readonly, but privately readwrite without opening properties up to all of the fun fragility associated with categories."