How cancel Async Call in Windows Phone?

Question

I have a list wich is loaded with elements each time the user make a research...These elements contain an Icon which is dowloaded with an async method GetByteArrayAsync of the HttpClient object.
I have an issue when the user make a second research while the icon of the first list are still downloading.Because the list of elements is changing while Icon downloads are processing on each element of the first list.
So my guess is that I need to cancel these requests each time the user proceed to a new research...Ive readen some stuuf on Task.run and CancellationTokenSource but I can't find really helpful example for my case so here is my code...
Hope you can help me with that ...Thank you

public static async Task<byte[]> DownloadElementFile(BdeskElement bdeskElement)
{
    //create and send the request

    DataRequest requesteur = new DataRequest();

    byte[] encryptedByte = await requesteur.GetBytesAsync(dataRequestParam);

    return encryptedByte;
}


public async Task<Byte[]> GetBytesAsync(DataRequestParam datarequesparam)
{
    var handler = new HttpClientHandler { Credentials = new NetworkCredential(datarequesparam.AuthentificationLogin, datarequesparam.AuthentificationPassword, "bt0d0000") };
    HttpClient httpClient = new HttpClient(handler);

    try
    {
        byte[] BytesReceived = await httpClient.GetByteArrayAsync(datarequesparam.TargetUri);

        if (BytesReceived.Length > 0)
        {
            return BytesReceived;
        }

        else
        {
            return null;

        }
    }
    catch (WebException)
    {
        throw new MyException(MyExceptionsMessages.Webexception);
    }

}

EDIT

public async Task<Byte[]> GetBytesAsync(DataRequestParam datarequesparam)
        {
            var handler = new HttpClientHandler { Credentials = new NetworkCredential(datarequesparam.AuthentificationLogin, datarequesparam.AuthentificationPassword, "bt0d0000") };
            HttpClient httpClient = new HttpClient(handler);

            try
            {
                cts = new CancellationTokenSource();

                HttpResponseMessage reponse = await httpClient.GetAsync(datarequesparam.TargetUri,cts.Token);

               if (reponse.StatusCode == HttpStatusCode.OK)
               {
                   byte[] BytesReceived = reponse.Content.ReadAsByteArrayAsync().Result;

                   if (BytesReceived.Length > 0)
                   {
                       return BytesReceived;
                   }

                   else
                   {
                       return null;

                   }
               }

               else
               {
                   return null;
               }

            }
            catch (WebException)
            {
                throw new MyException(MyExceptionsMessages.Webexception);
            }
              catch(OperationCanceledException)
            {
                  throw new OperationCanceledException();
            }

EDIT2 I need to cancel this funntion when the user make a new research and the list "listBoxGetDocsLibs" changed.

 private async void LoadIconDocLibs()
        {

            foreach (var doclib in listBoxGetDocsLibs)//ERROR HERE COLLECTION HAS CHANGED
            {

                doclib.Icon = new BitmapImage();


                    try
                    {

                        byte[] Icon = await ServerFunctions.GetDocLibsIcon(doclib);

                        if (Icon != null)
                        {
                            {

                                var ms = new MemoryStream(Icon);

                                BitmapImage photo = new BitmapImage();
                                photo.DecodePixelHeight = 64;
                                photo.DecodePixelWidth = 92;
                                photo.SetSource(ms);
                                doclib.Icon = photo;
                            }
                        }
                    }
                    catch(OperationCanceledException)
                    {

                    }
                }


        }

Answer 1

First you need to define CancellationTokenSource:

private System.Threading.CancellationTokenSource cts;

place above code somewhere, where you can access it with your Button or other method.

Unfortunately GetByteArrayAsync lacks Cancelling - so it cannot be used with cts.Token, but maybe you can accomplish your task using GetAsync - which supports Cancelling:

ctsDownload = new System.Threading.CancellationTokenSource();
HttpResponseMessage response = await httpClient.GetAsync(requestUri, cts.Token);

Then you can get your content from response.

And when you want to Cancel your Task it can look like this:

private void cancelBtn_Click(object sender, RoutedEventArgs e)
{
   if (this.cts != null)
       this.cts.Cancel();
}

When you Cancel task an Exception will be thrown.

If you want to cancel your own async Task, a good example you can find at Stephen Cleary blog.

EDIT - you can also build your own method (for example with HttpWebRequest) which will support Cancelling:

For this purpose you will have to extend HttpWebRequest (under WP it lacks GetResponseAsync):

// create a static class in your namespace
public static class Extensions
{
    public static Task<HttpWebResponse> GetResponseAsync(this HttpWebRequest webRequest)
    {
        TaskCompletionSource<HttpWebResponse> taskComplete = new TaskCompletionSource<HttpWebResponse>();
        webRequest.BeginGetResponse(
            asyncResponse =>
            {
                try
                {
                    HttpWebRequest responseRequest = (HttpWebRequest)asyncResponse.AsyncState;
                    HttpWebResponse someResponse = (HttpWebResponse)responseRequest.EndGetResponse(asyncResponse);
                    taskComplete.TrySetResult(someResponse);
                }
                catch (WebException webExc)
                {
                    HttpWebResponse failedResponse = (HttpWebResponse)webExc.Response;
                    taskComplete.TrySetResult(failedResponse);
                }
                catch (Exception exc) { taskComplete.SetException(exc); }
            }, webRequest);
        return taskComplete.Task;
    }
}

Then your method can look like this:

public async Task<Byte[]> GetBytesAsync(DataRequestParam datarequesparam, CancellationToken ct)
{
   HttpWebRequest request = HttpWebRequest.CreateHttp(datarequesparam.TargetUri);
   request.Method = "GET";
   request.Credentials = new NetworkCredential(datarequesparam.AuthentificationLogin, datarequesparam.AuthentificationPassword, "bt0d0000");
   request.AllowReadStreamBuffering = false;

   try
   {
       if (request != null)
       {
           using (HttpWebResponse response = await request.GetResponseAsync())
           using (Stream mystr = response.GetResponseStream())
           using (MemoryStream output = new MemoryStream())
           {
               const int BUFFER_SIZE = 10 * 1024;
               byte[] buf = new byte[BUFFER_SIZE];

               int bytesread = 0;
               while ((bytesread = await mystr.ReadAsync(buf, 0, BUFFER_SIZE)) > 0)
               {
                   output.Write(buf, 0, bytesread);
                   ct.ThrowIfCancellationRequested();
               }
               return output.ToArray();
           }
       }
       else return null;
  }
  catch (WebException)
  {
      throw new MyException(MyExceptionsMessages.Webexception);
  }
}

You can freely change Buffer Size which will affect how often Cancellation will be checked.

I haven't tried this but I think it should work.