Lexical Scope

One of the unique features of blocks is its support for lexical scoping. In contrast, C functions do not have access to local variables declared outside of their definition. The example shown in Listing 15-9 will not compile because the local variable myVar is not visible within the logValue function definition.

Listing 15-9.  C Function Attempting to Access a Local Variable Outside Its Scope

void logValue()
{
  // ERROR, illegal access of myVar, not within scope
  NSLog(@"Variable value = %d", myVar);
}

int main(int argc, const char * argv[])
{
  @autoreleasepool
  {
    int myVar = 10;
    logValue();
  }
  return 0;
}

A block supports lexical scoping, thus a block literal expression has access to variables declared within the same lexical scope. In addition, blocks can be defined anywhere other variables can; for example, within other blocks, functions, and methods. C functions, on the other hand, cannot be defined within other functions or methods. Listing 15-10 compiles and runs successfully because the variable myVar is declared within the same lexical scope as the block logValueBlock.

Listing 15-10.  Block Accessing Local Variable Through Lexical Scoping

{
  int myVar = 10;
  void (^logValueBlock)(void) = ^{
    NSLog(@"Variable value = %d", myVar);
  };
  logValueBlock();
}

Listing 15-10 shows that a block has access to local variables declared outside its definition. Specifically, these local variables are declared (and initialized) within an enclosing scope, prior to the block literal expression. Braces delimit a local scope; in addition scopes may be nested. Referring again to Listing 15-10, the variable myVar is declared at the same scope as the block definition assigned to logValueBlock, prior to the literal expression, and thus can be used within the expression. On the other hand, Listing 15-11 will not compile, because the local variable myVar is declared and initialized after the block literal expression.

Listing 15-11.  Illegal Access of Local Variable in Block, Declared After Block Literal Expression

void (^logValueBlock)(void) = ^{
  // ERROR, illegal access of myVar, declared after literal expression
  NSLog(@"Variable value = %d", myVar);
};
int myVar = 10;
logValueBlock();

Local variables accessed through lexical scoping behave as constant values (for primitive types) or by reference variables (for objects) within a block literal expression. Listing 15-12 will not compile because a primitive variable accessed through lexical scoping cannot be modified within a block literal.

Listing 15-12.  Block Attempting to Modify a Local Variable Accessed Through Lexical Scoping

int myVar = 10;
void (^logValueBlock)(void) = ^{
  // ERROR, lexical scope variable not assignable
  myVar = 5;
  NSLog(@"Variable value = %d", myVar);
};
logValueBlock();

As local scopes can be nested, a block can capture local variables within multiple (nested) scopes. This is demonstrated in the code from Listing 15-13.

Listing 15-13.  Block Capturing Local Variables Within Multiple Nested Scopes

for (int ii=0; ii<2; ii++)
{
  for (int jj=0; jj<3; jj++)
  {
    void (^logValueBlock)(void) = ^{
      NSLog(@"Variable values = %d, %d", ii, jj);
    };
    logValueBlock();
  }
}

Mutable __block Variables

By default, block local variables accessed through lexical scoping are visible but not writeable within a block literal expression. The __block storage type modifier can be used to make these variables read-write (i.e., mutable). The __block modifier can be used on all supported Objective-C types, except for C variable-length arrays (an array with a length that is not a constant expression) and C structures that contain variable-length arrays. Its use cannot be combined with the existing local storage modifiers auto, register, and static. Listing 15-14 illustrates the use of a __block variable.

Listing 15-14.  Correct Use of __block Storage

__block int myVar = 10;
void (^incBlock)(int) = ^(int amount){
  myVar += amount;
  NSLog(@"New value = %d", myVar);
};
incBlock(5);

Variables qualified with the __block storage type are copied to the heap if the referencing block is copied to heap storage. This last point brings up the topic of memory management with blocks, the subject of the next section.

Sorting an Array Using Blocks

Now you will create a program that demonstrates array sorting using blocks. In Xcode, create a new project by selecting New Project . . . from the Xcode File menu. In the New Project Assistant pane, create a command-line application. In the Project Options window, specify BlockArraySorter for the Product Name, choose Foundation for the Project Type, and select ARC memory management by checking the Use Automatic Reference Counting check box. Specify the location in your file system where you want the project to be created (if necessary, select New Folder and enter the name and location for the folder), uncheck the Source Control check box, and then click the Create button.

In the Xcode project navigator, select the main.m file and update the file, as shown in Listing 15-18.

Listing 15-18.  BlockArraySorter main.m File

#import <Foundation/Foundation.h>
#include <stdlib.h>

#define ArrayElements 10

int main(int argc, const char * argv[])
{
  @autoreleasepool
  {
    // Create an array of numbers with random values (0-99)
    NSMutableArray *numbers = [NSMutableArray arrayWithCapacity:ArrayElements];
    for (int elem=0; elem<ArrayElements; elem++)
    {
      unsigned int value = arc4random() % 100;
      [numbers addObject:[NSNumber numberWithUnsignedInt:value]];
    }
    NSLog(@"Values: %@", numbers);      // Log the numbers unsorted
     
    // Sort the array of numbers in ascending order
    [numbers sortUsingComparator:^(id obj1, id obj2){
      if ([obj1 integerValue] > [obj2 integerValue])
      {
        return (NSComparisonResult)NSOrderedDescending;
      }
      if ([obj1 integerValue] < [obj2 integerValue])
      {
        return (NSComparisonResult)NSOrderedAscending;
      }
      return (NSComparisonResult)NSOrderedSame;
    }];
    NSLog(@"Values: %@", numbers);      // Log the numbers sorted
  }
  return 0;
}

First, the file imports the stdlib.h header file via an #include preprocessor directive. This header file is required for the arc4random() function used later in the code. Next, the file defines a constant value, ArrayElements, which is used to control the number of elements in an array.

The main() function contains the body of the program logic. It first creates an NSMutableArray object and then adds 10 elements to the array; each element is an NSNumber object with a random number. The random number, obtained using the arc4random() function, is constrained to a value between 0–99 (inclusive) with the following statement.

unsigned int value = arc4random() % 100;

The values of the array are then logged to the output pane. Because the numbers were randomly selected and the array has not been sorted, the order of the values displayed in the output pane is random. Next, the array is sorted using the NSMutableArray sortUsingComparator: method. This method sorts the array using the comparison method specified by the block literal input parameter. The full method signature is

- (void)sortUsingComparator:(NSComparator)cmptr

Thus the block literal expression is of block type NSComparator, a Foundation Framework data type whose type definition is

typedef NSComparisonResult (^NSComparator)(id obj1, id obj2);

So an NSComparator is a block type that takes two parameters of type id and returns a value of type NSComparisonResult. NSComparisonResult is a Foundation Framework enumeration used to indicate the ordering of items in a request, its values are as follows:

• NSOrderedAscending (the left operand is smaller than the right)
• NSOrderedSame (the left and right operands are equal)
• NSOrderedDescending (the left operand is larger than the right)

The block literal performs a comparison between array element values and returns the appropriate NSComparisonResult to sort the array elements based on ascending (numerical) order, as shown in Listing 15-18.

[numbers sortUsingComparator:^(id obj1, id obj2){
  if ([obj1 integerValue] > [obj2 integerValue])
  {
    return (NSComparisonResult)NSOrderedDescending;
  }
  if ([obj1 integerValue] < [obj2 integerValue])
  {
    return (NSComparisonResult)NSOrderedAscending;
  }
  return (NSComparisonResult)NSOrderedSame;
}];

Now save, compile, and run the BlockArraySorter program and observe the messages in the output pane (as shown in Figure 15-3).

The messages in the output pane show that the array was correctly sorted using the block literal expression. It first displays the values for the unsorted array elements and then redisplays the array elements, this time sorted based on the numeric value of each element. Many of the Foundation Framework collection classes (NSArray, NSDictionary) contain methods that use a block literal to sort their elements, so this demonstrates a common use of blocks that you will encounter. Perfect. Now that you have one example under your belt, let’s develop another program that uses a block to perform an asynchronous callback function.

Loading a URL Using Blocks

Next, you will create a program that uses a block to asynchronously load a URL request, executing the block when the request has finished loading. In Xcode, create a new project by selecting New Project . . . from the Xcode File menu. In the New Project Assistant pane, create a command-line application. In the Project Options window, specify BlockURLLoader for the Product Name, choose Foundation for the Project Type, and select ARC memory management by checking the Use Automatic Reference Counting check box. Specify the location in your file system where you want the project to be created (if necessary, select New Folder and enter the name and location for the folder), uncheck the Source Control check box, and then click the Create button.

In the Xcode project navigator, select the main.m file and update the file, as shown in Listing 15-19.

Listing 15-19.  BlockURLLoader main.m File

#import <Foundation/Foundation.h>

#define IndexURL       @"http://www.wikipedia.com/index.html"

int main(int argc, const char * argv[])
{
  @autoreleasepool
  {
    // Retrieve the current run loop for the connection
    NSRunLoop *loop = [NSRunLoop currentRunLoop];
    BOOL __block downloadComplete = NO;

    // Create the request
    NSURLRequest *request = [NSURLRequest
                             requestWithURL:[NSURL URLWithString:IndexURL]];
    [NSURLConnection sendAsynchronousRequest:request
                                       queue:[NSOperationQueue currentQueue]
                           completionHandler:^(NSURLResponse *response,
                                               NSData *data, NSError *error)
    {
      if (data == nil)
      {
        NSLog(@"Error loading request %@", [error localizedDescription]);
      }
      else
      {
        NSLog(@"
	Downloaded %lu bytes from request %@",
              [data length], [request URL]);
      }
      downloadComplete = YES;
    }];
     
    // Loop until finished downloading the resource
    while ( !downloadComplete &&
           [loop runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]]);
  }
  return 0;
}

After the Foundation Framework import, the file defines a constant value, IndexURL, for the URL to be downloaded.

The main() function contains the body of the program logic. It begins by retrieving the current run loop, required for asynchronous URL loading with NSURLConnection objects. It also declares and initializes a BOOL variable named downloadComplete. This variable is declared with __block storage type, thereby enabling its value to be changed within a block literal of the same scope. Next, an NSURLRequest instance is created (its URL is specified by the #define constant) using the convenience constructor requestWithURL:. Then the code creates an NSURLConnection object to load the request. It uses the sendAsynchronousRequest:queue:completionHandler: method. The completion handler is the handler block literal that is executed. The queue is an NSOperationQueue instance to which the handler block is dispatched when the request completes or fails. It is used to enable the execution of asynchronous operations. The block literal checks the return value of the download request (NSData *). If its value is nil, then an error occurred during the download and this is logged to the console; otherwise, the download was successful and the number of bytes downloaded is logged to the console.

if (data == nil)
{
  NSLog(@"Error loading request %@", [error localizedDescription]);
}
else
{
  NSLog(@"
	Downloaded %lu bytes from request %@",
        [data length], [request URL]);
}
downloadComplete = YES;

The next statement is a loop used to keep the application running until the connection has finished loading the resource.

while (!downloadComplete &&
       [loop runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]]);

This statement was used in examples in previous chapters. To summarize, it runs the loop, receiving events from its input sources and executing any corresponding delegate or callback methods until the connection has finished loading the resource.

Now save, compile, and run the BlockURLLoader program and observe the messages in the output pane (as shown in Figure 15-4).

The messages in the output pane show that the URL was successfully downloaded and processed using the block literal expression. It displays the number of bytes downloaded and the URL for the request. Several Foundation Framework classes (e.g., NSURLConnection), Cocoa Framework classes, and various third-party APIs contain methods that use a block literal to perform callback functions, so it is very important to become familiar with this programming model. All right, enough said. Now let’s conclude this whirlwind tour with another program that uses a block to perform concurrent programming.

Concurrent Programming Using Blocks

You’ll finish this chapter with a program that uses a block to perform concurrent programming. This program employs GCD to concurrently execute several tasks defined with blocks. In Xcode, create a new project by selecting New Project . . . from the Xcode File menu. In the New Project Assistant pane, create a command-line application. In the Project Options window, specify BlockConcurrentTasks for the Product Name, choose Foundation for the Project Type, and select ARC memory management by checking the Use Automatic Reference Counting check box. Specify the location in your file system where you want the project to be created (if necessary, select New Folder and enter the name and location for the folder), uncheck the Source Control check box, and then click the Create button.

In the Xcode project navigator, select the main.m file and update it, as shown in Listing 15-20.

Listing 15-20.  BlockConcurrentTasks main.m File

#import <Foundation/Foundation.h>
#define YahooURL       @"http://www.yahoo.com/index.html"
#define ApressURL       @"http://www.apress.com/index.html"

typedef void (^DownloadURL)(void);

/* Retrieve a block used to download a URL */
DownloadURL getDownloadURLBlock(NSString *url)
{
  NSString *urlString = url;
  return ^{
    // Downloads a URL
    NSURLRequest *request = [NSURLRequest
                             requestWithURL:[NSURL URLWithString:urlString]];
    NSError *error;
    NSDate *startTime = [NSDate date];
    NSData *data = [NSURLConnection sendSynchronousRequest:request
                                         returningResponse:nil
                                                     error:&error];
    if (data == nil)
    {
      NSLog(@"Error loading request %@", [error localizedDescription]);
    }
    else
    {
      NSDate *endTime = [NSDate date];
      NSTimeInterval timeInterval = [endTime timeIntervalSinceDate:startTime];
      NSLog(@"Time taken to download %@ = %f seconds", urlString, timeInterval);
    }
  };
}

int main(int argc, const char * argv[])
{
  @autoreleasepool
  {
    // Create queues for tasks
    dispatch_queue_t queue1 =
    dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_queue_t queue2 =
    dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
     
    // Create a task group
    dispatch_group_t group = dispatch_group_create();
     
    // Get current time for metrics
    NSDate *startTime = [NSDate date];
     
    // Now create and dispatch async tasks
    dispatch_group_async(group, queue1, getDownloadURLBlock(YahooURL));
    dispatch_group_async(group, queue2, getDownloadURLBlock(ApressURL));
     
    // Block until all tasks from group are completed
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
     
    // Retrieve time taken for concurrent execution and log
    NSDate *endTime = [NSDate date];
    NSTimeInterval timeInterval = [endTime timeIntervalSinceDate:startTime];
    NSLog(@"Time taken to download URLs concurrently = %f seconds", timeInterval);
  }
  return 0;
}

Listing 15-20 includes, in addition to the main() function, a function named getDownloadURLBlock that returns a block literal used to download a URL. The file begins by defining two constants, YahooURL and ApressURL, which name the URLs to be downloaded. Next, a type definition is provided for the block type to be used. The file then defines the getDownloadURLBlock() function. This function returns a block literal used to synchronously download a URL via the NSURLConnection method sendSynchronousRequest:returningResponse:error. It also computes the amount of time taken to download the URL using several NSDate APIs. The interval is computed as an NSTimeInterval value. Note that the block captures the URL string (provided as an argument to the function) using lexical scoping.

The main() function uses GCD APIs to create and dispatch two tasks for concurrent execution. It first creates two global concurrent dispatch queues for executing tasks in parallel.

dispatch_queue_t queue1 =
  dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_queue_t queue2 =
  dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

Next, it creates a task group, which is used to group tasks and is useful for queuing tasks to perform asynchronous execution, waiting on a group of queued tasks, and so forth. The code then dispatches the two tasks to the task group.

dispatch_group_async(group, queue1, getDownloadURLBlock(YahooURL));
dispatch_group_async(group, queue2, getDownloadURLBlock(ApressURL));

Notice that the task to be executed is specified by a block literal retrieved by the getDownloadURLBlock() function; one using the Yahoo URL and the other using the Apress URL. The GCD dispatch_group_async() function causes these tasks to be performed concurrently. Next, the GCD dispatch_group_wait() function is used to block the main thread until both concurrent tasks complete.

dispatch_group_wait(group, DISPATCH_TIME_FOREVER);

Finally, the amount of time taken to complete the two concurrent tasks is computed and logged to the console. Now save, compile, and run the BlockConcurrentTasks program and observe the messages in the output pane (as shown in Figure 15-5).

The messages in the output pane show that the concurrent tasks were performed successfully. It also shows that the elapsed time to perform the tasks concurrently was less than what would have been taken to perform them sequentially. Cool. You just learned how to use blocks to perform concurrent programming and also received a brief introduction to the Grand Central Dispatch system. Note that Chapter 17 provides a complete introduction on the use of GCD to perform concurrent programming.