Cocoa way of doing applications with delegates

Question

i have a method, in which i want to accomplish a given task, however, the asynchronous commands and delegates made it difficult

i can do this :

- (void) fooPart1 
{
    ...
    SomeAssynchronousMethos * assync = [[SomeAssynchronousMethos alloc] init];
    assync.delegate = self;
    [assync start];

}

- (void) fooPart2
{
   ...
   possibly some other assync
}

- (void)someAssynchronousMethosDelegateDidiFinish
{
    [self fooPart2];
}

But isn't there a way to do smith. like this

- (void) foo
{
    ...
    SomeAssynchronousMethos * assync = [[SomeAssynchronousMethos alloc] init];
    assync.delegate = self;
    [assync start];

    wait for signal, but class is not blocked
    ...
    possibly some other assync

}

- (void)someAssynchronousMethosDelegateDidiFinish
{
    continue in foo after [assync start]
}

I don't like the idea of splitting a function to 2 or more parts, but is this the way how it is done in cocoa? or is there a better practice?

why i dont like this concept and searching for a better way of doing it :

• lets say, i want to use a variable only for compleating a task - if i have everything in one function, i just use it, and than the var dies as i leave the function, if its split, i have to keep the var somehow around, until it doesnt finish
• the code becomes fragmented and more difficult to read and maintain
• may lead to bug
• i end up with a set of part function, that needs to be called in precise order to accomplish one task (for which one function would be more suitable)

i used to make a thread and do only synchronous calls there, but not everything supports a synchronous call

what would be realy nice, is to have smth, like

- (void) foo
{
    ...
    int smth = 5;
    SomeAssynchronousMethos * assync = [[SomeAssynchronousMethos alloc] init];
    assync.delegate = self;
    @freez([assync start]);
    // when freez - the local function variables are frozen 
    // (next commands in function are not excuted until unfreez)
    // from outer look, it looks like the function finished      
    // however when unfreeze, it is called from this point on

    //int smth is still 5
}

- (void)someAssynchronousMethosDelegateDidiFinish
{
    @unfreez([assync start]);
}

when the execution would reach freez, it would store all local vars allocated in function and when called unfreez, it would continue from that point on, when it was freez with that command

Answer 1

This seems like an ideal application of a completion handler block.

Alter your start method to take a parameter which is a block and call it like so:

- (void) fooPart1 
{
    ...
    SomeAssynchronousMethos * assync = [[SomeAssynchronousMethos alloc] init];
    [assync startOnComplete: ^(NSError* error) // example, you can have any params or none
        {
            // handle error if not nil
            if (error != nil)
            {
                // do something with it
            }
            // code to do on completion
        }]; 
}

Your start method would look something like this

-(void) startOnComplete: (void(^)(NSError*)) completionBlock
{
    // copy the block somewhere
    theSavedCompletionBlock = [completionBlock copy];
    // kick off async operation
}

-(void) someMethodThatRunsAttheEndOfTheAsyncOp
{
    theSavedCompletionBlock(nilOrError);
    [theSavedCompletionBlock release];
}