@property (nonatomic, copy) void (^simpleBlock)(void);
@property (nonatomic, copy) BOOL (^blockWithParamter)(NSString *input);

Если вы собираетесь повторять один и тот же блок в нескольких местах, используйте тип def

typedef void(^MyCompletionBlock)(BOOL success, NSError *error);
@property (nonatomic) MyCompletionBlock completion;

Вот пример того, как вы могли бы выполнить такую ​​задачу:

#import <Foundation/Foundation.h>
typedef int (^IntBlock)();

@interface myobj : NSObject
{
    IntBlock compare;
}

@property(readwrite, copy) IntBlock compare;

@end

@implementation myobj

@synthesize compare;

- (void)dealloc 
{
   // need to release the block since the property was declared copy. (for heap
   // allocated blocks this prevents a potential leak, for compiler-optimized 
   // stack blocks it is a no-op)
   // Note that for ARC, this is unnecessary, as with all properties, the memory management is handled for you.
   [compare release];
   [super dealloc];
}
@end

int main () {
    @autoreleasepool {
        myobj *ob = [[myobj alloc] init];
        ob.compare = ^
        {
            return rand();
        };
        NSLog(@"%i", ob.compare());
        // if not ARC
        [ob release];
    }

    return 0;
}

Теперь единственное, что нужно будет изменить, если вам нужно изменить тип сравнения, - это typedef int (^IntBlock)(). Если вам нужно передать ему два объекта, измените его на это: typedef int (^IntBlock)(id, id) и измените свой блок на:

^ (id obj1, id obj2)
{
    return rand();
};

Надеюсь, это поможет.

ИЗМЕНИТЬ 12 марта 2012 г .:

Для ARC особых изменений не требуется, так как ARC будет управлять блоками за вас, пока они определены как копии. Вам также не нужно устанавливать свойство равным nil в деструкторе.

Для получения дополнительной информации ознакомьтесь с этим документом: http://clang.llvm.org/docs/AutomaticReferenceCounting.html

Для Swift просто используйте замыкания: пример.

В Objective-C:

@property (копия) недействительна

@property (copy)void (^doStuff)(void);

Это так просто.

Вот актуальная документация Apple, в которой точно указано, что использовать:

Apple doco.

В вашем .h файле:

// Here is a block as a property:
//
// Someone passes you a block. You "hold on to it",
// while you do other stuff. Later, you use the block.
//
// The property 'doStuff' will hold the incoming block.

@property (copy)void (^doStuff)(void);

// Here's a method in your class.
// When someone CALLS this method, they PASS IN a block of code,
// which they want to be performed after the method is finished.

-(void)doSomethingAndThenDoThis:(void(^)(void))pleaseDoMeLater;

// We will hold on to that block of code in "doStuff".

Вот ваш .m файл:

 -(void)doSomethingAndThenDoThis:(void(^)(void))pleaseDoMeLater
    {
    // Regarding the incoming block of code, save it for later:
    self.doStuff = pleaseDoMeLater;

    // Now do other processing, which could follow various paths,
    // involve delays, and so on. Then after everything:
    [self _alldone];
    }

-(void)_alldone
    {
    NSLog(@"Processing finished, running the completion block.");
    // Here's how to run the block:
    if ( self.doStuff != nil )
       self.doStuff();
    }

Остерегайтесь устаревшего примера кода.

С современными системами (2014+) делайте то, что показано здесь. Это так просто.

Для потомков / полноты ... Вот два ПОЛНЫХ примера того, как реализовать этот смехотворно универсальный "способ делать вещи". @ Ответ Роберта блаженно лаконичен и точен, но здесь я хочу также показать способы фактического «определения» блоков.

@interface       ReusableClass : NSObject
@property (nonatomic,copy) CALayer*(^layerFromArray)(NSArray*);
@end

@implementation  ResusableClass
static  NSString const * privateScope = @"Touch my monkey.";

- (CALayer*(^)(NSArray*)) layerFromArray { 
     return ^CALayer*(NSArray* array){
        CALayer *returnLayer = CALayer.layer
        for (id thing in array) {
            [returnLayer doSomethingCrazy];
            [returnLayer setValue:privateScope
                         forKey:@"anticsAndShenanigans"];
        }
        return list;
    };
}
@end

Глупый? Да. Полезно? Черт возьми. Вот другой, "более атомарный" способ установки свойства ... и класс, который до смешного полезен ...

@interface      CALayoutDelegator : NSObject
@property (nonatomic,strong) void(^layoutBlock)(CALayer*);
@end

@implementation CALayoutDelegator
- (id) init { 
   return self = super.init ? 
         [self setLayoutBlock: ^(CALayer*layer){
          for (CALayer* sub in layer.sublayers)
            [sub someDefaultLayoutRoutine];
         }], self : nil;
}
- (void) layoutSublayersOfLayer:(CALayer*)layer {
   self.layoutBlock ? self.layoutBlock(layer) : nil;
}   
@end

Это иллюстрирует установку свойства блока через аксессор (хотя и внутри init, спорно рискованная практика ..) по сравнению с "неатомарным" механизмом "геттера" из первого примера. В любом случае ... "жестко запрограммированные" реализации всегда можно перезаписать для каждого экземпляра .. a lá ..

CALayoutDelegator *littleHelper = CALayoutDelegator.new;
littleHelper.layoutBlock = ^(CALayer*layer){
  [layer.sublayers do:^(id sub){ [sub somethingElseEntirely]; }];
};
someLayer.layoutManager = littleHelper;

Кроме того ... если вы хотите добавить свойство блока в категорию ... скажем, вы хотите использовать блок вместо какого-то "действия" цели / действия старой школы ... Вы можете просто использовать связанные значения, ну ... связать блоки.

typedef    void(^NSControlActionBlock)(NSControl*); 
@interface       NSControl            (ActionBlocks)
@property (copy) NSControlActionBlock  actionBlock;    @end
@implementation  NSControl            (ActionBlocks)

- (NSControlActionBlock) actionBlock { 
    // use the "getter" method's selector to store/retrieve the block!
    return  objc_getAssociatedObject(self, _cmd); 
} 
- (void) setActionBlock:(NSControlActionBlock)ab {

    objc_setAssociatedObject( // save (copy) the block associatively, as categories can't synthesize Ivars.
    self, @selector(actionBlock),ab ,OBJC_ASSOCIATION_COPY);
    self.target = self;                  // set self as target (where you call the block)
    self.action = @selector(doItYourself); // this is where it's called.
}
- (void) doItYourself {

    if (self.actionBlock && self.target == self) self.actionBlock(self);
}
@end

Теперь, когда вы создаете кнопку, вам не нужно создавать IBAction драму ... Просто ассоциируйте работу, которую нужно выполнить при создании ...

_button.actionBlock = ^(NSControl*thisButton){ 

     [doc open]; [thisButton setEnabled:NO]; 
};

Этот шаблон можно применить OVER и OVER к какао API. Используйте свойства, чтобы сблизить соответствующие части вашего кода, устранить запутанные парадигмы делегирования и усилить возможности объектов, помимо того, что они просто действуют как тупые «контейнеры».

Конечно, вы можете использовать блоки как свойства. Но убедитесь, что они объявлены как @property (copy). Например:

typedef void(^TestBlock)(void);

@interface SecondViewController : UIViewController
@property (nonatomic, copy) TestBlock block;
@end

В MRC блоки, захватывающие переменные контекста, размещаются в стеке; они будут освобождены, когда фрейм стека будет уничтожен. Если они будут скопированы, новый блок будет размещен в куче, который может быть выполнен позже, после того, как будет заполнен кадр стека.

Заявитель

Это не должно быть «хорошим ответом», поскольку этот вопрос явно задается ObjectiveC. Поскольку Apple представила Swift на WWDC14, я хотел бы поделиться различными способами использования блоков (или замыканий) в Swift.

Привет, Свифт

У вас есть много способов передать блок, эквивалентный функции в Swift.

Я нашел три.

Чтобы понять это, я предлагаю вам протестировать на игровой площадке этот небольшой фрагмент кода.

func test(function:String -> String) -> String
{
    return function("test")
}

func funcStyle(s:String) -> String
{
    return "FUNC__" + s + "__FUNC"
}
let resultFunc = test(funcStyle)

let blockStyle:(String) -> String = {s in return "BLOCK__" + s + "__BLOCK"}
let resultBlock = test(blockStyle)

let resultAnon = test({(s:String) -> String in return "ANON_" + s + "__ANON" })


println(resultFunc)
println(resultBlock)
println(resultAnon)

Swift, оптимизирован для закрытия

Поскольку Swift оптимизирован для асинхронной разработки, Apple больше работала над закрытием. Во-первых, сигнатура функции может быть выведена, поэтому вам не нужно ее переписывать.

Параметры доступа по номерам

let resultShortAnon = test({return "ANON_" + $0 + "__ANON" })

Вывод параметров с именованием

let resultShortAnon2 = test({myParam in return "ANON_" + myParam + "__ANON" })

Трейлинг-закрытие

Этот особый случай работает, только если блок является последним аргументом, он называется завершающим закрытием.

Вот пример (объединенный с предполагаемой подписью, чтобы показать мощь Swift)

let resultTrailingClosure = test { return "TRAILCLOS_" + $0 + "__TRAILCLOS" }

Наконец-то:

Используя всю эту мощь, я бы смешал завершающее закрытие и вывод типа (с именованием для удобства чтения)

PFFacebookUtils.logInWithPermissions(permissions) {
    user, error in
    if (!user) {
        println("Uh oh. The user cancelled the Facebook login.")
    } else if (user.isNew) {
        println("User signed up and logged in through Facebook!")
    } else {
        println("User logged in through Facebook!")
    }
}

Привет, Свифт

В дополнение к тому, что ответил @Francescu.

Добавление дополнительных параметров:

func test(function:String -> String, param1:String, param2:String) -> String
{
    return function("test"+param1 + param2)
}

func funcStyle(s:String) -> String
{
    return "FUNC__" + s + "__FUNC"
}
let resultFunc = test(funcStyle, "parameter 1", "parameter 2")

let blockStyle:(String) -> String = {s in return "BLOCK__" + s + "__BLOCK"}
let resultBlock = test(blockStyle, "parameter 1", "parameter 2")

let resultAnon = test({(s:String) -> String in return "ANON_" + s + "__ANON" }, "parameter 1", "parameter 2")


println(resultFunc)
println(resultBlock)
println(resultAnon)

Вы можете следовать приведенному ниже формату и использовать свойство testingObjectiveCBlock в классе.

typedef void (^testingObjectiveCBlock)(NSString *errorMsg);

@interface MyClass : NSObject
@property (nonatomic, strong) testingObjectiveCBlock testingObjectiveCBlock;
@end

Дополнительную информацию см. здесь