How to avoid nested blocks

Question

GCD and blocks are so nice and convenient. But when I fall in love with it, I found that something bad happened. Look at these codes below:

[self functionA:^(BOOL success) {
  if (success) {
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^(void) {
      [self functionB:^(NSError *error) {
        if (error != nil) {
          dispatch_async(dispatch_get_main_queue(), ^(void) {
            [self functionC:^(id result) {
              if (result) {
                [self functionD:^(BOOL success) {
                  if (success) {
                    [self DoSomething];
                  }
                }];
              }
            }];
          });
        }
      }];
    });
  }
}];

Crazy? Yes. I am in this trouble.

Did someone have any experience avoiding nested blocks like this?

Edited:

Thanks guys. Exactly, we have more elegant ways to do this. Such as:

Declare blocks beforehand
Make sub blocks as independent function

But what I expect is a general solution. Maybe like this:(Pseudo code below)

functionA.flat.success = [self functionB];
functionB.flat.isntnil = [self functionC];
functionB.flat.error = {};
functionC.flat.isntnil = [self functionD];
[flat call:functionA];

I'm not quite sure what kind of an answer you expect. If you want to avoid block, don't write methods that take blocks. And even if you need them, like for the dispatching part, there's really nothing bad about it. — IluTov, Aug 19 '13 at 10:45
@NSAddict Yes. Maybe I can redesign the functions in business logic layer that could avoid blocks hell. But I still want to know if there is some frameworks or syntactic sugar can flat these async calls. — nickcheng, Aug 19 '13 at 11:05
You can move the inner part of each block to a separate method to avoid the deep (optical) nesting. — Martin R, Aug 19 '13 at 11:11
what is wrong with the nested blocks? is it hard to understand for you? — holex, Aug 19 '13 at 12:24

Grzegorz Adam Hankiewicz · Answer 1 · 2013-08-19T14:16:20.177

Well, I haven't bothered matching your cloud of closing braces, but here's a try by simply using return, which you can use freely inside blocks too and cuts the nesting a little:

[self functionA:^(BOOL success) {
  if (!success)
    return;

  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^(void) {
    [self functionB:^(NSError *error) {
      if (!error)
        return;

      dispatch_async(dispatch_get_main_queue(), ^(void) {
        [self functionC:^(id result) {
          if (!result)
            return;

          [self functionD:^(BOOL success) {
            if (!success)
              return;

            [self DoSomething];
          }];
        }];
      });
    }];
  });
}];

Also, nobody forces you to write blocks inline, you can declare them as normal variables before and use them later. In fact, by declaring blocks before you are able to reuse them if your API is lenient towards its users and allows being called repeatedly even when no work has to be done:

- (void)foo:(Bar*)bar
{
    // Prepare the success handler.
    void (^successBlock)(Bar*) = ^(Bar *bar) {

        [[NSNotificationCenter defaultCenter]
            postNotificationName:@"barUpdated"
                          object:bar];
    };

    if (!bar.didAlreadyFetchStuff) {
        [self wellYouBetterFetchSomething:bar withSuccess:successBlock];
    } else {
        // Oh, fake we already did the work.
        successBlock(bar);
    }
}

Whenever I see the nest level too high I put the inside blocks as normal methods in the class and simply call them inside the block. The effect is the same, but it looks much cleaner, and it allows you to use appledoc or other documentation tools for each method rather than hoping to understand the mess of nested undocumented blocks.

It only gets crazy if you allow it to get crazy.

Declaring the blocks beforehand is one of the best ways to simplify code. — Sulthan, Aug 19 '13 at 12:14

How to avoid nested blocks

1 Answers1

Linked