MICROSOFT_PRESS_EBOOK_PROGRAMMING_WINDOWS_8_APPS_WITH_HTML_CSS_AND_JAVASCRIPT_PDF

Arrays, Vectors, and Other Alternatives
Now that we’ve seen the basic structure of asynchronous methods in WinRT components, let’s see how
we might create an asynchronous variant of the synchronous Convert methods we implemented earlier.
For the purpose of this exercise we’ll just stick with the C# component.
It would be natural with Convert to consider IAsyncAction as the method’s type, because we already
return results in an output array. This would, in fact, be a great choice if we were using types other than
an array. However, arrays present a variety of problems with asynchronous methods. First, although we
can pass the method both the input and output arrays, and the method can do its job and populate that
output array, its contents won’t actually be transferred back across the async task boundary at present.
So the completed handler in the app will be called as it would expect, but the output array passed to the
async method will still be empty.
The next thing we can try is to turn the async action into an operation that produces a result. We
might consider a return type of IAsyncOperation (or an equivalent one using progress), where
the method would create and populate the array it returns. The problem here, however, is that the app
receiving this array wouldn’t know how to release it—clearly some memory was allocated for it, but that
allocation happened inside a component and not inside JavaScript, so there’s no clear rule on what to
do. Because this is a sure fire recipe for memory leaks, returning arrays like this isn’t supported.
An alternative is for the async method to return a specific WinRT collection type (where there are
clear rules for deallocation), such as an IList, which will be converted to a vector in JavaScript
that can also be accessed as an array. (Note that IList is specific to .NET languages; the C++
walkthrough topic shows how to use a vector directly with the concurrent_vector type.) Here’s a simple
example of such a method:
public static IAsyncOperation CreateByteListAsync(int size)
{
var task = Task.Run(() =>
{
Byte [] list = new Byte[size];
for (int i = 0; i < size; i++)
{
list[i] = (Byte)(i % 256);
}
return list.ToList();
});
}
return task.AsAsyncOperation();
Applying this approach to the grayscale routine, we get the following ConvertPixelArrayAsync (see
PixelCruncherCS > ConvertGrayscale.cs), where the DoGrayscale is the core code of the routine broken
out into a separate function, the third parameter of which is a periodic callback that we can use to
handle cancellation):
742