Getting started in Cocoa can be hard. Just learning the frameworks is a challenge.
Once you get to that point, most or your journey still lies ahead. If you were like me, you probably learned a lot about iPhone programming from online tutorials and books. Then one day, after your 16th tutorial and 3rd book, you looked around and said, “Now what?”
The truth is that technologies like Core Animation, Core Data, and Core Graphics are just tools. They are only a means to an end.
A full toolbox does not make a carpenter good. You still need experience, planning, and vision.
With this in mind, I want to talk about Key-Value Observing. This won’t be a full coding example, per se, but a discussion of how you may use this tool in your code.
Many readers may know the gist of KVO, as well as KVC and bindings. Although bindings are beyond the scope of this post, we will give a quick definition of keys and Key-Value Coding.
KVC is a technology that allows you to access an instance variable by using a string referred to as a key. So using an example:
To access are aptly named dictionary, we can type the two equivalent statements:
They do exactly the same thing, but in KVC we use supply keys using the “valueForKey:” method available to all NSObject subclasses.
To set this property we can use either of the following statements:
Now to KVO. For those who don’t know, KVO provides a mechanism to receive notifications that an instance variable, has been modified. Of course you know now we will be using keys to do this. First you register as an observer for the key:
(Note: I won’t engage in any “self=[super init]” talk here)
We simply registered the class to receive notifications about its own instance variable, but we could have easily selected an ivar of another object.
We also have set some options and a context here, but nothing that need be delved into for our discussion.
To receive the notification, we need to implement one method:
Every time the instance variable is changed, this method will be called automagically.
Now that we have a very, very rudimentary understanding of what KVO (and KVC) are, we can begin to talk about how to use them.
One very common use of KVO is model observation. On stack overflow, I see many questions like: “If I have a variable in view controller A, how do I pass it to view controller B?” Of course the real problem is that we are asking the wrong question.
The right question is: “How can I get two view controllers to know about changes of a single variable?”
We know now that we can use KVO. What we want to do is make our views observe our models. By registering view controllers as observers to the model, we can have an unlimited of views showing and/or using the same data. This also gives us well defined MVC boundaries. What’s more, is that we will write almost no code to accomplish this feat.
As you will read elsewhere, KVO has some (few) disadvantages. The one that sticks out, is that it may make your code harder to debug. This is because it is hard to sometimes tell who is observing who. Otherwise this is a very elegant solution that will eliminate some of your glue code.
What are some uses and patterns of KVO and KVC in your programming?