• Choose a category
• All
• Classic-Fiction

Now, what about the notifier itself, in our case the network-reading object that’s going to broadcast its status? That’s taken care of as simply as this:

The idea is that the notifier can fling out a notification like that, and the notification center takes care of the actual delivery. The notifier can also pass along additional information, in the form of a dictionary which can be retrieved by an observer, like this:

Blocks

In Chapter 16, we introduced you to blocks, an addition to C that Apple has come up with and included in Snow Leopard. We brought up blocks in the context of the concurrency features provided by Grand Central Dispatch, where blocks fit in really well, but there are many more uses for blocks. In Snow Leopard, Apple extended several Cocoa classes, adding dozens of new methods that take blocks as parameters. Let’s take a look at some of them.

Enumeration

Let’s start with something simple: enumeration. You’re probably familiar with the standard C-based ways of stepping through a list, and perhaps the use of NSEnumerator and even the new fast enumeration (“for - in” loops) that’s been available since the release of Leopard. Now, blocks provide us with yet another way to do the same thing:

The block we pass in to enumerateObjectsUsingBlock: takes three arguments, and returns nothing. That’s the block signature declared by the method, and that’s what we have to follow. The three arguments sent into our block are an object from the array, an integer containing that object’s index in the array, and a BOOL passed by reference that lets us halt the enumeration by setting its value to YES.

Looking at it that way, it may not be obvious at first why the block version is any better than the others, but the fact is that it really combines the best of all the other ways of enumerating. For one thing, it gives you the index of the current object, which is really handy if you want to do something like print out a numbered list of the items in an array. We can’t tell you how many times we’ve dropped down to C-style iteration just for easy access to each object’s index value! Also, there’s a variant of this method that lets you specify options defining how the enumeration runs, such as make it run concurrently:

That method actually uses GCD to spread the work around to all available processor cores, which will make your app run more quickly and better utilize system resources. And you get it for free!

Similar enumeration methods exist for the NSSet class, but without the index parameter (because the objects in a set are, by definition, unordered). NSDictionary has also gotten some good block action, with new methods such as enumerateKeysAndObjectsUsingBlock: (and its options-taking variant that allows for concurrency), letting you specify a block that gets the key and value together. This is much better than previous ways of enumerating the contents of a dictionary, which typically involved stepping through all the keys, and looking up the value for each key.

Observing Notifications Using Blocks

We realize that we just threw notifications at you a few pages ago, but guess what: Apple’s already taken the block concept and applied it to the NSNotification class as well, which boasts a new method in Snow Leopard that lets you specify a block rather than a selector, like this:

This is cool in a couple of ways. For one thing, it frees you from the burden of creating a method for your notification-handling code, letting you instead put it inline with the code that’s setting it up, which can make your code easier to read. The other cool thing, which is true of all blocks, is that because the block you create picks up its context from the location it’s defined in, it has access to not only instance variables, but also local variables defined earlier in the same method. That means that you can defer access to some values until a later time, without needing to explicitly put them into instance variables or pass them along