Objective c 如何将dispatch\u block\t类型的块传递给方法

在下面的代码中，我试图将

dispatch\u block\t

类型的块传递给

dispatch\u async

，如下所示。 我尝试了以下方法：

dispatch_async(defaultPriority, block1(2, 3000));
dispatch_async(defaultPriority, (^block1)(2, 3000));
dispatch_async(defaultPriority, ^(block1)(2, 3000));

但是，由于块如何传递到

dispatch\u async

方法而产生错误，因此代码不可编译。 请让我知道如何修理它。如果您可以提供不同的传递方式（如果适用），那就太好了

dispatch_block_t ^block1(int, int) = ^(int x1, int delay) {
    [NSThread sleepForTimeInterval: delay];
};
dispatch_queue_t defaultPriority = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_queue_t backgroundPriority = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);

dispatch_async(defaultPriority, block1(2, 3000));

synchName andId: (NSString *) synchId;

---

dispatch\u block\t

被定义为不带参数的块：

typedef void (^dispatch_block_t)(void);

- (void)fooWithValue:(int)value delay:(int)delay block:(void (^)(int, int))block {
    dispatch_queue_t queue = dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0);

    dispatch_async(queue, ^{
        block(value, delay);
    });
}

因此，说“我想将具有两个参数的块定义为

dispatch\u block\t

”是没有意义的，因为

dispatch\u block\t

不接受任何参数

因此，假设您想要定义一个方法，该方法接受一个具有两个参数的块。你应该这样做：

- (void)foo:(void (^)(int, int))block {
    dispatch_queue_t queue = dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0);

    dispatch_async(queue, ^{
        block(42, 3);
    });
}

void (^block1)(int, int) = ^(int value, int delay) {
    [NSThread sleepForTimeInterval:(NSTimeInterval)delay];
    NSLog(@"value = %d", value);
};
[self foo:block1];

void (^block1)(int, int) = ^(int value, int delay) {
    [NSThread sleepForTimeInterval:(NSTimeInterval)delay];
    NSLog(@"value = %d", value);
};

[self fooWithValue:2 delay:3 block:block1];

注意，我不仅仅是将我的

块

作为第二个参数直接传递给

dispatch\u async

，因为

dispatch\u block\t

不接受任何参数，而我的块接受两个参数。因此，我使用

^{…}

语法作为

dispatch_async

的第二个参数，在该块中，我使用提供的两个参数调用我的

块

无论如何，你可以这样称呼它：

- (void)foo:(void (^)(int, int))block {
    dispatch_queue_t queue = dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0);

    dispatch_async(queue, ^{
        block(42, 3);
    });
}

void (^block1)(int, int) = ^(int value, int delay) {
    [NSThread sleepForTimeInterval:(NSTimeInterval)delay];
    NSLog(@"value = %d", value);
};
[self foo:block1];

void (^block1)(int, int) = ^(int value, int delay) {
    [NSThread sleepForTimeInterval:(NSTimeInterval)delay];
    NSLog(@"value = %d", value);
};

[self fooWithValue:2 delay:3 block:block1];

或

如果还希望将块的两个参数传递给
foo
，则添加这两个参数：

typedef void (^dispatch_block_t)(void);

- (void)fooWithValue:(int)value delay:(int)delay block:(void (^)(int, int))block {
    dispatch_queue_t queue = dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0);

    dispatch_async(queue, ^{
        block(value, delay);
    });
}

你可以这样称呼它：

- (void)foo:(void (^)(int, int))block {
    dispatch_queue_t queue = dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0);

    dispatch_async(queue, ^{
        block(42, 3);
    });
}

void (^block1)(int, int) = ^(int value, int delay) {
    [NSThread sleepForTimeInterval:(NSTimeInterval)delay];
    NSLog(@"value = %d", value);
};
[self foo:block1];

void (^block1)(int, int) = ^(int value, int delay) {
    [NSThread sleepForTimeInterval:(NSTimeInterval)delay];
    NSLog(@"value = %d", value);
};

[self fooWithValue:2 delay:3 block:block1];


dispatch\u block\t
类型的优点是它使我们摆脱了上述神秘的块语法。但我们可以为可能需要的任何参数组合定义自定义类型：

typedef void (^CustomBlock)(int, int);

这与
dispatch\u block\t
类似，只是这一个接受两个整数参数

然后你可以做如下事情：

- (void)fooWithValue:(int)value delay:(int)delay block:(CustomBlock)block {
    dispatch_queue_t queue = dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0);

    dispatch_async(queue, ^{
        block(value, delay);
    });
}

及

块的这种语法很难记住，如果忘记了语法，这也是一个很好的备忘


顺便说一下，您的代码将“delay”与
sleepForTimeInterval
结合使用。您通常不想使用
sleepForTimeInterval
。您通常会在

之后使用

dispatch\u，例如，要在3秒钟内完成某项任务，您会执行以下操作：

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    [self doSomething];
});