iOS. Приемы программирования Нахавандипур Вандад
NSUInteger insideVariable = 20;
NSLog(@"Outside variable = %lu", (unsigned long)outsideVariable);
NSLog(@"Inside variable = %lu", (unsigned long)insideVariable);
/* Возвращаем значение для блокового объекта. */
return NSOrderedSame;
}];
}
Метод экземпляра sortUsingComparator:, относящийся к классу NSMutableArray, пытается сортировать изменяемый массив. Цель кода, приведенного в данном примере, — просто продемонстрировать использование локальных переменных. Можно и не задаваться тем, что именно делает этот метод.
Блоковый объект может считывать информацию и записывать данные в собственную локальную переменную insideVariable. При этом по умолчанию блоковый объект имеет доступ только для чтения к переменной outsideVariable. Чтобы блоковый объект мог записывать информацию в outsideVariable, нужно поставить перед outsideVariable префикс __block, указывающий соответствующий тип хранения:
— (void) simpleMethod{
__block NSUInteger outsideVariable = 10;
NSMutableArray *array = [[NSMutableArray alloc]
initWithObjects:@"obj1",
@"obj2", nil];
[array sortUsingComparator: ^NSComparisonResult(id obj1, id obj2) {
NSUInteger insideVariable = 20;
outsideVariable = 30;
NSLog(@"Outside variable = %lu", (unsigned long)outsideVariable);
NSLog(@"Inside variable = %lu", (unsigned long)insideVariable);
/* Возвращаем значение для блокового объекта. */
return NSOrderedSame;
}];
}
Доступ к self во встраиваемых блоковых объектах не вызывает никаких проблем, пока self определяется в лексической области видимости, внутри которой создается встраиваемый блоковый объект. Например, в данной ситуации блоковый объект сможет получить доступ к self, поскольку метод simpleMethod является методом экземпляра класса языка Objective-C:
— (void) simpleMethod{
NSMutableArray *array = [[NSMutableArray alloc]
initWithObjects:@"obj1",
@"obj2", nil];
[array sortUsingComparator: ^NSComparisonResult(id obj1, id obj2) {
NSLog(@"self = %@", self);
/* Возвращаем значение для блокового объекта. */
return NSOrderedSame;
}];
}
Не внеся изменений в реализацию вашего блокового объекта, вы не сможете получить доступ к self в независимом блоковом объекте. При попытке скомпилировать данный код мы получим ошибку времени компиляции:
void (^incorrectBlockObject)(void) = ^{
NSLog(@"self = %@", self); /* self здесь не определен. */
};
Если вы хотите получить доступ к self в независимом блоковом объекте, просто передайте объект, представляемый self, вашему блоковому объекту в качестве параметра:
void (^correctBlockObject)(id) = ^(id self){
NSLog(@"self = %@", self);
};
— (void) callCorrectBlockObject{
correctBlockObject(self);
}
Этому параметру не обязательно присваивать имя self. Ему можно дать любое имя. Тем не менее если назвать этот параметр self, то можно будет просто собрать код блокового объекта позже и поместить его в реализацию метода на языке Objective-C. Не придется менять имя каждого экземпляра переменной на self, чтобы код был воспринят компилятором.
Рассмотрим объявленные свойства и посмотрим, как блоковые объекты могут получать к ним доступ. При работе со встраиваемыми блоковыми объектами можно применять точечную нотацию — она позволяет считывать информацию из объявленных свойств self или записывать в них данные. Допустим, например, что у нас в классе есть объявленное свойство типа NSString, которое называется stringProperty:
#import «AppDelegate.h»
@interface AppDelegate()
@property (nonatomic, copy) NSString *stringProperty;
@end
@implementation AppDelegate
Теперь не составляет труда получить доступ к этому свойству во встраиваемом блоковом объекте:
— (void) simpleMethod{
NSMutableArray *array = [[NSMutableArray alloc]
initWithObjects:@"obj1",
@"obj2", nil];
[array sortUsingComparator: ^NSComparisonResult(id obj1, id obj2) {
NSLog(@"self = %@", self);
self.stringProperty = @"Block Objects";
NSLog(@"String property = %@", self.stringProperty);
/* Возвращаем значение для блокового объекта. */
return NSOrderedSame;
}];
}
Но в независимом блоковом объекте нельзя использовать точечную нотацию для считывания объявленного свойства или записи информации в это свойство:
void (^correctBlockObject)(id) = ^(id self){
NSLog(@"self = %@", self);
/* Вместо этого используем метод-установщик */
self.stringProperty = @"Block Objects"; /* Ошибка времени компиляции */
/* Вместо этого используем метод-получатель. */
NSLog(@"self.stringProperty = %@",
self.stringProperty); /* Ошибка времени компиляции */
};
В данном сценарии будем пользоваться методом-установщиком и методом-получателем синтезированного свойства:
void (^correctBlockObject)(id) = ^(id self){
NSLog(@"self = %@", self);
/* Это будет работать нормально. */
[self setStringProperty:@"Block Objects"];
/* Это также будет работать нормально. */
NSLog(@"self.stringProperty = %@",
[self stringProperty]);
};
Когда дело касается встраиваемых блоковых объектов, необходимо учитывать лишь одно очень важное правило: встраиваемые блоковые объекты копируют значения для переменных в своей лексической области видимости. Если вы не понимаете, что это значит, — не волнуйтесь. Рассмотрим пример:
typedef void (^BlockWithNoParams)(void);
— (void) scopeTest{
NSUInteger integerValue = 10;
BlockWithNoParams myBlock = ^{
NSLog(@"Integer value inside the block = %lu",
(unsigned long)integerValue);
};
integerValue = 20;
/* Вызываем блок здесь после изменения
значения переменной integerValue. */
myBlock();
NSLog(@"Integer value outside the block = %lu",
(unsigned long)integerValue);
}
Мы определяем целочисленную локальную переменную и сначала присваиваем ей значение 10. Затем реализуем блоковый объект, но пока не вызываем его. После того как блоковый объект реализован, мы просто изменяем значение локальной переменной, которую затем (после того как мы его вызовем) попытается считать блоковый объект. Сразу после изменения значения локальной переменной на 20 вызываем блоковый объект. Логично предположить, что блоковый объект выведет для переменной на консоль значение 20, но этого не произойдет. Он выведет значение 10, как показано здесь:
Integer value inside the block = 10
Integer value outside the block = 20
Вот что здесь происходит. Блоковый объект сохраняет для себя копию переменной integerValue, доступную только для чтения, и делает это именно там, где реализуется блок. Напрашивается вопрос: почему же блоковый объект принимает доступное только для чтения значение переменной integerValue? Ответ прост, и мы уже дали его в этом разделе. Если у локальной переменной нет префикса __block, означающего соответствующий тип хранения, локальные переменные в лексической области видимости блокового объекта просто передаются блоковому объекту как переменные, доступные только для чтения. Следовательно, чтобы изменить это поведение, мы могли бы изменить реализацию метода scopeTest и сопроводить переменную integerValue префиксом __block, указывающим тип хранения. Это делается так:
— (void) scopeTest{
__block NSUInteger integerValue = 10;
BlockWithNoParams myBlock = ^{
NSLog(@"Integer value inside the block = %lu",
(unsigned long)integerValue);
};
integerValue = 20;
/* Вызываем блок здесь после изменения
значения переменной integerValue. */
myBlock();
NSLog(@"Integer value outside the block = %lu",
(unsigned long)integerValue);
}
Теперь, если вывести на консоль результаты после вызова метода scopeTest, мы увидим следующее:
Integer value inside the block = 20
Integer value outside the block = 20
Итак, в данном разделе мы довольно подробно рассмотрели вопросы использования переменных с блоковыми объектами. Рекомендую вам написать несколько блоковых объектов и попытаться использовать в них переменные. Присваивайте им переменные, считывайте из них информацию, чтобы лучше разобраться с тем, как в блоковых объектах применяются переменные. Перечитайте этот раздел, если случайно забудете правила, регулирующие доступ к переменным в блоковых объектах.
7.3. Вызов блоковых объектов
Постановка задачи
Вы научились создавать блоковые объекты, а теперь требуется их исполнять и получать определенные результаты.
Решение
Исполняйте ваши блоковые объекты так же, как и функции на языке C. Подробнее об этом — в подразделе «Обсуждение».
Обсуждение
В разделах 7.1 и 7.2 вы видели примеры вызова блоковых объектов. В данном разделе приводятся более конкретные примеры.
Если у вас есть независимый блоковый объект, его можно вызвать так же, как мы вызывали бы функцию на языке C:
void (^simpleBlock)(NSString *) = ^(NSString *paramString){
/* Реализуем блоковый объект и используем параметр paramString. */
};
— (void) callSimpleBlock{
simpleBlock(@"O'Reilly");
}
Если вы хотите вызвать независимый блоковый объект внутри другого независимого блокового объекта, действуйте так же, как при активизации метода на языке C:
NSString *(^trimString)(NSString *) = ^(NSString *inputString){
NSString *result = [inputString stringByTrimmingCharactersInSet:
[NSCharacterSet whitespaceCharacterSet]];
return result;
};
NSString *(^trimWithOtherBlock)(NSString *) = ^(NSString *inputString){
return trimString(inputString);
};
— (void) callTrimBlock{
NSString *trimmedString = trimWithOtherBlock(@" O'Reilly ");
NSLog(@"Trimmed string = %@", trimmedString);
}
Продолжим данный пример и вызовем метод callTrimBlock на языке Objective-C:
[self callTrimBlock];
Метод callTrimBlock вызовет блоковый объект trimWithOtherBlock, а этот объект вызовет блоковый объект trimString, чтобы обрезать указанную строку. Отсечение строки — простая операция, для ее выполнения требуется всего одна строка кода. Но этот пример демонстрирует, как можно вызывать блоковые объекты внутри блоковых объектов.
См. также
Разделы 7.1 и 7.2.
7.4. Решение с помощью GCD задач, связанных с пользовательским интерфейсом
Постановка задачи
Интерфейс программирования приложений GCD используется для параллельного программирования, и необходимо узнать, каков оптимальный способ его применения с другими API, связанными с пользовательским интерфейсом.
Решение
Воспользуйтесь функцией dispatch_get_main_queue.
Обсуждение
Задачи, связанные с пользовательским интерфейсом, должны выполняться в главном потоке. Поэтому единственным каналом для передачи в GCD задач, связанных с пользовательским интерфейсом, и их выполнения оказывается главная очередь. В качестве описателя главной диспетчерской очереди можно применять функцию dispatch_get_main_queue.
Существует два способа направления задач в основную очередь. Оба этих способа асинхронны и позволяют не прерывать исполнения программы на время, пока завершается операция:
функция dispatch_async выполняет блоковый объект применительно к диспетчерской очереди;
функция dispatch_async_f выполняет функцию C применительно к диспетчерской очереди.
Метод dispatch_sync нельзя применять к главной очереди, поскольку он заблокирует поток на неопределенное время и ваше приложение войдет во взаимную блокировку. Все задачи, направляемые в GCD через главную очередь, должны туда направляться асинхронно.
Рассмотрим использование функции dispatch_async, которая принимает два параметра:
описатель диспетчерской очереди — диспетчерская очередь, в которой должна выполняться задача;
блоковый объект — блоковый объект, посылаемый в диспетчерскую очередь для асинхронного выполнения.
Рассмотрим пример. В операционной системе iOS следующий код будет выводить пользователю предупреждение, и при этом будет применяться главная очередь:
dispatch_queue_t mainQueue = dispatch_get_main_queue();
dispatch_async(mainQueue, ^(void) {
[[[UIAlertView alloc] initWithTitle:@"GCD"
message:@"GCD is amazing!"
delegate: nil
cancelButtonTitle:@"OK"
otherButtonTitles: nil, nil] show];
});
Как видите, функция GCD dispatch_async не имеет ни параметров, ни возвращаемого значения. Блоковый объект, передаваемый данной функции для выполнения задачи, должен самостоятельно собирать данные для этого. В только что рассмотренном примере кода присутствует вид с предупреждением, имеющий все значения, которые требуются ему для выполнения задачи. Но так бывает не всегда. Иногда вам необходимо удостовериться, что блоковый объект, передаваемый GCD, располагает в собственной области видимости всеми значениями, которые требуются для решения стоящей перед ним задачи.
Если запустить данное приложение в эмуляторе iOS, пользователь увидит примерно такую картинку, как на рис. 7.1.
Рис. 7.1. Предупреждение, при выводе которого применялись асинхронные вызовы к GCD.
В общем-то, этот результат не слишком впечатляет. Так благодаря чему же главная очередь так интересна? Ответ прост: когда приходится задействовать GCD на полную мощность, например, чтобы выполнить сложные вычисления в параллельных или последовательных потоках, вам, возможно, понадобится отображать текущие результаты для пользователя или перемещать какой-либо компонент на экране. В таких случаях необходимо применять основную очередь, так как это задачи, связанные с пользовательским интерфейсом. Функции, рассмотренные в этом разделе, дают единственную возможность выйти из параллельной или последовательной очереди для обновления пользовательского интерфейса, не прекращая работу с GCD. Можете себе представить, насколько они важны.
Если вы не хотите передавать блоковый объект для выполнения в главную очередь, можно передать объект, представляющий собой функцию на языке C. Передавайте функции dispatch_async_f все те функции C, которые предполагается направлять на выполнение в GCD и которые относятся к работе пользовательского интерфейса. Мы можем получить такие же результаты, как на рис. 7.1, используя вместо блоковых объектов функции на языке C, при этом потребуется внести в код лишь незначительные корректировки.
Как было указано ранее, функция dispatch_async_f позволяет передавать указатель на контекст, определяемый приложением. Этот контекст впоследствии может использоваться вызываемой нами функцией C. Итак, создадим структуру, в которой будут содержаться значения — в частности, заголовок предупреждающего вида, сообщение и надпись Cancel (Отмена) на соответствующей кнопке. Когда приложение запустится, мы поместим в эту структуру все значения и передадим ее функции C для отображения. Вот как определяется эта структура:
typedef struct{
char *h2;
char *message;
char *cancelButtonTitle;
} AlertViewData;
Итак, продолжим и реализуем функцию C, которая в дальнейшем будет вызываться с GCD. Эта функция должна ожидать параметр типа void *, тип которого затем приводится к AlertViewData *. Иными словами, мы ожидаем от вызывающей стороны этой функции, что нам будет передана ссылка на данные, необходимые для работы предупреждающего вида, которые инкапсулированы в структуре AlertViewData:
void displayAlertView(void *paramContext){
AlertViewData *alertData = (AlertViewData *)paramContext;
NSString *h2 =
[NSString stringWithUTF8String: alertData->h2];
NSString *message =
[NSString stringWithUTF8String: alertData->message];
NSString *cancelButtonTitle =
[NSString stringWithUTF8String: alertData->cancelButtonTitle];
[[[UIAlertView alloc] initWithTitle: h2
message: message
delegate: nil
cancelButtonTitle: cancelButtonTitle
otherButtonTitles: nil, nil] show];
free(alertData);
Читать бесплатно другие книги:
