MICROSOFT_PRESS_EBOOK_PROGRAMMING_WINDOWS_8_APPS_WITH_HTML_CSS_AND_JAVASCRIPT_PDF

When this worker is started, the only code that executes is the onmessage assignment. When that
handler receives the appropriate message, it then invokes countFromZero, which in turn posts its results.
In other words, setting up a worker just means converting method calls and results into messages.
Invoking this method from the app now looks like this:
var worker = new Worker('worker_count.js');
worker.onmessage = function (e) { //e.data.sum is the result }
//Call the method
worker.postMessage({ method: "countFromZero", max: 1000, increment: .00005 });
Keep in mind with all of this that postMessage is itself an asynchronous operation—there’s no
particular guarantee about how quickly those messages will be dispatched to the worker or the app.
Furthermore, when a worker is created, it won’t start executing until script execution yields (as when you
call setImmediate). This means that workers are not particularly well suited for async operations that you
want to start as soon as possible or for those where you want to get the results as soon as they are
available. For this reason, workers are better for relatively large operations and ongoing processing;
small, responsive, and high-performance routines are better placed within WinRT components.
The postMessage mechanism is also not the best for chaining multiple async operations together, as
we’re easily able to do with promises that come back from WinRT APIs. To be honest, I don’t even want
to start thinking about that kind of code! I prefer instead of ask whether there’s a way that we can
effectively wrap a worker’s messaging mechanism within a promise, such that we can treat async
operations the same regardless of their implementation.
To do this, we somehow need a way to get the result from within the worker.onmessage handler and
send it to a promise’s completed handler. To do that, we use a bit of code in the main app that’s
essentially what the JavaScript projection layer uses to turn an async WinRT API into a promise itself:
// This is the function variable we're wiring up.
var workerCompleteDispatcher = null;
var promiseJS = new WinJS.Promise(function (completeDispatcher, errorDispatcher,
progressDispatcher) {
workerCompleteDispatcher = completeDispatcher;
});
// Worker would be created here and stored in the 'worker' variable
// Listen for worker events
worker.onmessage = function (e) {
if (workerCompleteDispatcher != null) {
workerCompleteDispatcher(e.data.sum);
}
}
promiseJS.done(function (sum) {
// Output for JS worker
});
735