Question

So, I’ve already read up on the documentation which notes

Objective-C 2.0’s dot syntax and key-value coding are orthogonal technologies. You can use key-value coding whether or not you use the dot syntax, and you can use the dot syntax whether or not you use KVC. Both, though, make use of a “dot syntax.” In the case of key-value coding, the syntax is used to delimit elements in a key path. It is important to remember that when you access a property using the dot syntax, you invoke the receiver’s standard accessor methods.

It then provided an example that supposedly showed the difference between the two. However, I still don’t get, what’s the difference between KVC and property accessor methods? Aren’t they the same? And how do I distinguish between dots that call setValue:forKeyPath: and simple accessors?

Answer 1

However, I still don’t get, what’s the difference between KVC and property accessor methods?

KVC is a way to call property accessor methods, or otherwise access a property.

What do I mean by “otherwise access”? For KVC purposes, an instance variable with no accessor methods counts as an informal property. It’ll get or set the value of the instance variable directly if no matching accessor pair can be found. (Yes, this is not worth using in modern code. Always declare an @property for anything you intend to access elsewhere, and, inversely, don’t use KVC to access anything that isn’t a public property.)

Property accessor methods are what KVC will call if they exist (preferred, both by KVC and by every sane programmer, over direct ivar access). An accessor may get or set an instance variable, as synthesized accessors do, or access some other storage.

Accessors are implementation, properties are interface, and KVC is one way to use them.

And how do I distinguish between dots that call setValue:forKeyPath: and simple accessors?

A key path is a string, whereas a property-access expression is an expression. The compiler evaluates a property-access expression and translates it into one or more Objective-C messages, whereas a key path is evaluated by KVC at run time.

So, when you use a key path:

[someObject setValue:theValue forKeyPath:@"foo.bar.baz"];

You know it’s a key path because (1) it’s a string, as indicated in this case by the string-literal syntax @"…", and (2) you’re passing the key-path string to setValue:forKeyPath: for it to evaluate.

Using a key path is using KVC to access the named properties. It will send any relevant accessor messages on your behalf.

When you use a property-access expression:

someObject.foo.bar.baz = theValue;

You know it’s a property access expression because you are not identifying the properties with a string. You are accessing them (sending the accessor messages) yourself, in your own code.

There isn’t much reason to use KVC in any form; when you know the property at authorship/compile time, it’s best to have an @property declared and to access the property yourself, whether with property-access expressions or message expressions ([[[someObject foo] bar] setBaz:theValue]). The time to use KVC is when you don’t know what property you want to access until run time, which is pretty rare. It’s mainly a building-block technology behind KVO, Cocoa Bindings, parts of Core Animation, etc.

Mostly, you’ll only want to access properties yourself.