Example #1
0
        public static async Task <StorageFile> UpdateBingPicture()
        {
            string Path = await GetDailyPhotoPath().ConfigureAwait(false);

            if ((await ApplicationData.Current.LocalFolder.TryGetItemAsync("BingDailyPicture.jpg")) is StorageFile ExistFile)
            {
                try
                {
                    if (string.IsNullOrWhiteSpace(Path))
                    {
                        return(ExistFile);
                    }

                    if (await CheckIfNeedToUpdate().ConfigureAwait(false))
                    {
                        StorageFile TempFile = await ApplicationData.Current.TemporaryFolder.CreateFileAsync($"BingDailyPicture_Cache_[{DateTime.Now:yyyy-MM-dd HH-mm-ss}].jpg", CreationCollisionOption.GenerateUniqueName);

                        using (Stream TempFileStream = (await TempFile.OpenAsync(FileAccessMode.ReadWrite)).AsStream())
                        {
                            HttpWebRequest Request = (HttpWebRequest)WebRequest.Create(new Uri($"https://www.bing.com{Path}"));

                            using (WebResponse Response = await Request.GetResponseAsync().ConfigureAwait(false))
                                using (Stream ResponseStream = Response.GetResponseStream())
                                {
                                    await ResponseStream.CopyToAsync(TempFileStream).ConfigureAwait(false);
                                }

                            using (Stream FileStream = await ExistFile.OpenStreamForReadAsync().ConfigureAwait(false))
                                using (MD5 MD5Alg1 = MD5.Create())
                                    using (MD5 MD5Alg2 = MD5.Create())
                                    {
                                        Task <string> CalTask1 = MD5Alg1.GetHashAsync(FileStream);
                                        Task <string> CalTask2 = MD5Alg2.GetHashAsync(TempFileStream);

                                        string [] ResultArray = await Task.WhenAll(CalTask1, CalTask2).ConfigureAwait(false);

                                        if (ResultArray[0] == ResultArray[1])
                                        {
                                            return(ExistFile);
                                        }
                                    }

                            TempFileStream.Seek(0, SeekOrigin.Begin);

                            using (StorageStreamTransaction Transaction = await ExistFile.OpenTransactedWriteAsync())
                            {
                                await TempFileStream.CopyToAsync(Transaction.Stream.AsStreamForWrite()).ConfigureAwait(false);

                                await Transaction.CommitAsync();
                            }
                        }

                        return(ExistFile);
                    }
                    else
                    {
                        return(ExistFile);
                    }
                }
                catch (Exception ex)
                {
                    LogTracer.Log(ex, $"An error was threw in {nameof(UpdateBingPicture)}");
                    return(ExistFile);
                }
            }
            else
            {
                try
                {
                    if (string.IsNullOrWhiteSpace(Path))
                    {
                        return(null);
                    }

                    StorageFile TempFile = await ApplicationData.Current.TemporaryFolder.CreateFileAsync($"BingDailyPicture_Cache_[{DateTime.Now:yyyy-MM-dd HH-mm-ss}].jpg", CreationCollisionOption.GenerateUniqueName);

                    using (Stream TempFileStream = (await TempFile.OpenAsync(FileAccessMode.ReadWrite)).AsStream())
                    {
                        HttpWebRequest Request = (HttpWebRequest)WebRequest.Create(new Uri($"https://www.bing.com{Path}"));

                        using (WebResponse Response = await Request.GetResponseAsync().ConfigureAwait(false))
                            using (Stream ResponseStream = Response.GetResponseStream())
                            {
                                await ResponseStream.CopyToAsync(TempFileStream).ConfigureAwait(false);
                            }

                        StorageFile BingDailyPictureFile = await ApplicationData.Current.LocalFolder.CreateFileAsync("BingDailyPicture.jpg", CreationCollisionOption.ReplaceExisting);

                        using (StorageStreamTransaction Transaction = await BingDailyPictureFile.OpenTransactedWriteAsync())
                        {
                            TempFileStream.Seek(0, SeekOrigin.Begin);
                            await TempFileStream.CopyToAsync(Transaction.Stream.AsStreamForWrite()).ConfigureAwait(false);

                            await Transaction.CommitAsync();
                        }

                        return(BingDailyPictureFile);
                    }
                }
                catch (Exception ex)
                {
                    LogTracer.Log(ex, $"An error was threw in {nameof(UpdateBingPicture)}");
                    return(null);
                }
            }
        }
        public static async Task <StorageFile> DownloadDailyPicture()
        {
            string Path = await GetDailyPhotoPath().ConfigureAwait(true);

            try
            {
                if ((await ApplicationData.Current.LocalFolder.TryGetItemAsync("BingDailyPicture.jpg")) is StorageFile ExistFile)
                {
                    if (string.IsNullOrWhiteSpace(Path))
                    {
                        return(ExistFile);
                    }

                    StorageFile TempFile = await ApplicationData.Current.TemporaryFolder.CreateFileAsync("BingDailyPicture_Cache.jpg", CreationCollisionOption.ReplaceExisting);

                    using (Stream TempFileStream = (await TempFile.OpenAsync(FileAccessMode.ReadWrite)).AsStream())
                    {
                        try
                        {
                            await Task.Run(() =>
                            {
                                HttpWebRequest Request = (HttpWebRequest)WebRequest.Create(new Uri($"https://www.bing.com{Path}"));
                                using (WebResponse Response = Request.GetResponse())
                                    using (Stream ResponseStream = Response.GetResponseStream())
                                    {
                                        ResponseStream.CopyTo(TempFileStream);
                                    }
                            }).ConfigureAwait(false);
                        }
                        catch
                        {
                            return(ExistFile);
                        }

                        using (Stream FileStream = await ExistFile.OpenStreamForReadAsync().ConfigureAwait(false))
                        {
                            if (FileStream.ComputeMD5Hash() == TempFileStream.ComputeMD5Hash())
                            {
                                return(ExistFile);
                            }
                        }
                    }

                    await TempFile.MoveAndReplaceAsync(ExistFile);

                    return(ExistFile);
                }
                else
                {
                    if (string.IsNullOrWhiteSpace(Path))
                    {
                        return(null);
                    }

                    StorageFile BingDailyPictureFile = await ApplicationData.Current.LocalFolder.CreateFileAsync("BingDailyPicture.jpg", CreationCollisionOption.ReplaceExisting);

                    using (Stream FileStream = await BingDailyPictureFile.OpenStreamForWriteAsync().ConfigureAwait(false))
                    {
                        await Task.Run(() =>
                        {
                            HttpWebRequest Request = (HttpWebRequest)WebRequest.Create(new Uri($"https://www.bing.com{Path}"));
                            using (WebResponse Response = Request.GetResponse())
                                using (Stream ResponseStream = Response.GetResponseStream())
                                {
                                    ResponseStream.CopyTo(FileStream);
                                }
                        }).ConfigureAwait(false);
                    }

                    return(BingDailyPictureFile);
                }
            }
            catch
            {
                return(null);
            }
        }