How to Work with Asynchronous Functions Recursively

asyncrecursion

I am currently working on FLEX and have to call a web services. once I have the result, I have to call the web service again, with the previous result as the input.

A compounding problem, is that the service might return multiple results, and I have to call the service again with each of the results as the input. Lastly, i need the results to be in a hierarchical array collection, with each result as the child of the input to the web service.

If it were a synchronous function, it would have been very easy, but I have spent half a day trying to come up with something elegant for the web service.

I ended up with having two arrays, one for the input, and one for the results. Every time I had one or more result, I would put it in the Input array and the results. I would then remove the first item from the input array and call the web service with it, and so on, till I finished all the inputs. Once I had all the results, I made a recursive function that would create the hierarchical tree, that I needed.

This seems like a very hacky, WTF Solution. Is there any elegant and better solution? I am all ears.

Best Answer

Maybe you could implement some sort of "auto-loading tree".

Start with the first node. This node fetches data from server. For each item found in the response, it creates a child node that will load the appropriate data. And so on...

One thing you need to know is "When is it complete ?"

This can be handled with events. Each node send an event up when all its children are complete. Recursively this will end up telling the root that all is children are complete. The root node will fire the "I'm complete" event to tell whoever wants to know it, that the tree is complete.

However, I'm wondering : why don't you create a service on the server that returns the whole tree ?

Related Solutions

JavaScript Coding Style – How to Keep Code with Continuations/Callbacks Readable

It's highly unlikely that you can achieve with plain js the same level of conciseness and expressiveness in working with callbacks that C# 5 has. The compiler does the work in writing all that boilerplate for you, and until the js runtimes will do that, you will still have to pass an occasional callback here and there.

However, you may not always want to bring callbacks down to the level of simplicity of linear code - throwing functions around doesn't have to be ugly, there's an entire world working with this kind of code, and they keep sane without async and await.

For instance, use higher-order functions (my js may be a bit rusty):

// generic - this is a library function
function iterateAsync(iterator, action, onSuccess, onFailure) {
var item = iterator();
if(item == null) { // exit condition
    onSuccess();
    return;
}
action(item,
    function (success) {
        if(success)
            iterateAsync(iterator, action, onSuccess, onFailure);
        else
            onFailure();
    });
}


// calling code
var currentImage = 0;
var imageCount = 42;

// you know your library function expects an iterator with no params, 
// and an async action with the current item and its continuation as params
iterateAsync(
// this is your iterator
function () {   
    if(currentImage >= imageCount)
        return null;
    return "http://my/server/GetImage?" + (currentImage++);
},

// this is your action - coincidentally, no adaptor for the correct signature is necessary
LoadImageAsync,

// these are your outs
function () { console.log("All OK."); },
function () { console.log("FAILED!"); }
);

API – How to Optimize Calls to Multiple APIs at Once and Return as One Set

In systems like this, you always have to consider that as far as your code is powerful, at least a call will be delayed, and if your system is successful, that event will happen hundreds of times making your system slow, then maybe unstable.

I do not know the nature of the integration, maybe game providers, maybe social networks or anything else. But if your application is not academic, and it represents a real business requirements (in production) I think this is part of the things to do:

Before code

if possible, all systems that are integrated, they must be aware of the timeouts that are demanded from you (anticipating this from a contractual point of view, it is a good idea mostly because no one guarantees 100% of up-time. It's myth).
if point 1 is not possible, be objective and consider what we are willing to make our customers wait in front of the monitor (45 seconds, 10, 5, 2?). Found the value, we know how to set up the rest.
Should be considered a constant calls/sub-calls prifile and logging;
Should be planned for the possibility of suspending one or more services from the configuration (and not from code);

Technique

As for the technique, I think it is convenient to create a semaphore.

N functions will be called, the callback of each sub-function will be considered only if time set for each integration are respected.

So,

A call is made to the main function,
This considers what services are enabled to be contacted,
The callback functions are configured,
The sub-functions are called,
While making calls, and while the general timer has not expired, all callbacks are considered to be unified in the response of the main function.