private async Task<bool> DownloadBookAsync(DownloadItem item)
        {

            cts = new CancellationTokenSource();
            Problem fileDownloaded = await DownloadFileFromWeb(item, cts.Token);
            switch (fileDownloaded)
            {
                case Problem.Ok:
                               //ok processing
                    break;
                case Problem.Cancelled:
							//cancel processing
                    break;
                case Problem.Other:
                default:
                    break;
            }
            return true;
        }

		CancellationTokenSource cts = new CancellationTokenSource();
        enum Problem { Ok, Cancelled, Other };

        private async Task<Problem> DownloadFileFromWeb(DownloadItem item, CancellationToken cToken)
        {
            try
            {
                HttpWebRequest wbr = WebRequest.CreateHttp(new Uri(item.Url));
                wbr.Method = "GET";
                wbr.AllowReadStreamBuffering = false;
                WebClient wbc = new WebClient();
                using (HttpWebResponse response = await wbr.GetResponseAsync())
                {
                    using (Stream mystr = response.GetResponseStream())
                    {
                        using (IsolatedStorageFile ISF = IsolatedStorageFile.GetUserStoreForApplication())
                        {
                            //Save zipfile data
                            if (!ISF.DirectoryExists("RootPath/Zips"))
                            {
                                ISF.CreateDirectory("RootPath/Zips");
                            }
                            double totalSize = 0;
                            double downloaded = 0;
                            string dir = "RootPath/Zips" + item.Id.Trim();
                            using (IsolatedStorageFileStream file = ISF.CreateFile(dir))
                            {
                                const int BUFFER_SIZE = 100 * 1024;
                                byte[] buf = new byte[BUFFER_SIZE];

                                int bytesread = 0;
                                while ((bytesread = await mystr.ReadAsync(buf, 0, BUFFER_SIZE)) > 0)
                                {
                                    totalSize += bytesread;
                                    downloaded = Math.Round((totalSize / 1048576),3);
                                    lableProgress.Content =string.Concat(downloaded.ToString()," MB");
                                    cToken.ThrowIfCancellationRequested();
                                    file.Write(buf, 0, bytesread);
                                }
                            }
                        }
                        return Problem.Ok;
                    }
                }
            }
            catch (Exception exc)
            {
                if (exc is OperationCanceledException)
                    return Problem.Cancelled;
                else return Problem.Other;
            }
        }

	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;
        }
    }