public static async Task ExtractTarAsync(IEnumerable <FileSystemStorageFile> FileList, ProgressChangedEventHandler ProgressHandler = null) { long TotalSize = 0; foreach (FileSystemStorageFile File in FileList) { TotalSize += Convert.ToInt64(File.SizeRaw); } if (TotalSize == 0) { return; } long Step = 0; foreach (FileSystemStorageFile File in FileList) { if (await FileSystemStorageItemBase.CreateAsync(Path.Combine(Path.GetDirectoryName(File.Path), Path.GetFileNameWithoutExtension(File.Name)), StorageItemTypes.Folder, CreateOption.GenerateUniqueName).ConfigureAwait(false) is FileSystemStorageFolder NewFolder) { await ExtractTarAsync(NewFolder, File, (s, e) => { ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32((e.ProgressPercentage *Convert.ToDouble(File.SizeRaw) + Step * 100) / TotalSize), null)); }).ConfigureAwait(true); Step += Convert.ToInt64(File.SizeRaw); } else { throw new UnauthorizedAccessException(); } } }
public static async Task CreateGzipAsync(FileSystemStorageFile Source, string NewZipPath, CompressionLevel Level, ProgressChangedEventHandler ProgressHandler = null) { if (Level == CompressionLevel.Undefine) { throw new ArgumentException("Undefine is not allowed in this function", nameof(Level)); } if (await FileSystemStorageItemBase.CreateAsync(NewZipPath, StorageItemTypes.File, CreateOption.GenerateUniqueName).ConfigureAwait(false) is FileSystemStorageFile NewFile) { using (FileStream SourceFileStream = await Source.GetFileStreamFromFileAsync(AccessMode.Read)) using (FileStream NewFileStream = await NewFile.GetFileStreamFromFileAsync(AccessMode.Exclusive)) using (GZipOutputStream GZipStream = new GZipOutputStream(NewFileStream)) { GZipStream.SetLevel((int)Level); GZipStream.IsStreamOwner = false; GZipStream.FileName = Source.Name; await SourceFileStream.CopyToAsync(GZipStream, ProgressHandler : ProgressHandler).ConfigureAwait(false); } } else { throw new UnauthorizedAccessException(); } }
private static async Task <string> MakeSureCreateFolderHelperAsync(string Path) { switch (await FileSystemStorageItemBase.OpenAsync(Path)) { case FileSystemStorageFile: { if (await FileSystemStorageItemBase.CreateAsync(Path, StorageItemTypes.Folder, CreateOption.GenerateUniqueName) is FileSystemStorageFolder NewFolder) { return(NewFolder.Path); } else { throw new UnauthorizedAccessException("Could not create folder"); } } default: { if (await FileSystemStorageItemBase.CreateAsync(Path, StorageItemTypes.Folder, CreateOption.OpenIfExist) is FileSystemStorageFolder) { return(Path); } else { throw new UnauthorizedAccessException("Could not create folder"); } } } }
/// <summary> /// 执行ZIP文件创建功能 /// </summary> /// <param name="Source">待压缩文件</param> /// <param name="NewZipPath">生成的Zip文件名</param> /// <param name="ZipLevel">压缩等级</param> /// <param name="ProgressHandler">进度通知</param> public static async Task CreateZipAsync(FileSystemStorageItemBase Source, string NewZipPath, int ZipLevel, ProgressChangedEventHandler ProgressHandler = null) { if (await FileSystemStorageItemBase.CreateAsync(NewZipPath, StorageItemTypes.File, CreateOption.GenerateUniqueName).ConfigureAwait(false) is FileSystemStorageFile NewFile) { ZipStrings.CodePage = EncodingSetting.CodePage; using (FileStream NewFileStream = await NewFile.GetFileStreamFromFileAsync(AccessMode.Exclusive).ConfigureAwait(false)) using (ZipOutputStream OutputStream = new ZipOutputStream(NewFileStream)) { OutputStream.SetLevel(ZipLevel); OutputStream.UseZip64 = UseZip64.Dynamic; OutputStream.IsStreamOwner = false; switch (Source) { case FileSystemStorageFile File: { using (FileStream FileStream = await File.GetFileStreamFromFileAsync(AccessMode.Read).ConfigureAwait(false)) { ZipEntry NewEntry = new ZipEntry(File.Name) { DateTime = DateTime.Now, CompressionMethod = CompressionMethod.Deflated, Size = FileStream.Length }; OutputStream.PutNextEntry(NewEntry); await FileStream.CopyToAsync(OutputStream, ProgressHandler).ConfigureAwait(false); } break; } case FileSystemStorageFolder Folder: { await ZipFolderCore(Folder, OutputStream, Folder.Name, ProgressHandler).ConfigureAwait(false); break; } } await OutputStream.FlushAsync().ConfigureAwait(false); } } else { throw new UnauthorizedAccessException(); } }
public static async Task ExtractGZipAsync(FileSystemStorageFile Item, ProgressChangedEventHandler ProgressHandler = null) { if (await FileSystemStorageItemBase.CreateAsync(Path.Combine(Path.GetDirectoryName(Item.Path), Path.GetFileNameWithoutExtension(Item.Name)), StorageItemTypes.File, CreateOption.GenerateUniqueName).ConfigureAwait(false) is FileSystemStorageFile NewFile) { using (FileStream SourceFileStream = await Item.GetFileStreamFromFileAsync(AccessMode.Exclusive).ConfigureAwait(false)) using (FileStream NewFileStrem = await NewFile.GetFileStreamFromFileAsync(AccessMode.Write)) using (GZipInputStream GZipStream = new GZipInputStream(SourceFileStream)) { await GZipStream.CopyToAsync(NewFileStrem, ProgressHandler).ConfigureAwait(false); } } else { throw new UnauthorizedAccessException(); } }
public static async Task ExtractBZip2Async(FileSystemStorageFile Source, string NewDirectoryPath, ProgressChangedEventHandler ProgressHandler = null) { if (await FileSystemStorageItemBase.CreateAsync(Path.Combine(NewDirectoryPath, Path.GetFileNameWithoutExtension(Source.Name)), StorageItemTypes.File, CreateOption.GenerateUniqueName).ConfigureAwait(false) is FileSystemStorageFile NewFile) { using (FileStream SourceFileStream = await Source.GetFileStreamFromFileAsync(AccessMode.Exclusive).ConfigureAwait(false)) using (FileStream NewFileStrem = await NewFile.GetFileStreamFromFileAsync(AccessMode.Write)) using (BZip2InputStream BZip2Stream = new BZip2InputStream(SourceFileStream)) { BZip2Stream.IsStreamOwner = false; await BZip2Stream.CopyToAsync(NewFileStrem, ProgressHandler : ProgressHandler).ConfigureAwait(false); } } else { throw new UnauthorizedAccessException(); } }
public static async Task CreateBZip2Async(FileSystemStorageFile Source, string NewZipPath, ProgressChangedEventHandler ProgressHandler = null) { if (await FileSystemStorageItemBase.CreateAsync(NewZipPath, StorageItemTypes.File, CreateOption.GenerateUniqueName).ConfigureAwait(false) is FileSystemStorageFile NewFile) { using (FileStream SourceFileStream = await Source.GetFileStreamFromFileAsync(AccessMode.Read)) using (FileStream NewFileStream = await NewFile.GetFileStreamFromFileAsync(AccessMode.Exclusive)) using (BZip2OutputStream BZip2Stream = new BZip2OutputStream(NewFileStream)) { BZip2Stream.IsStreamOwner = false; await SourceFileStream.CopyToAsync(BZip2Stream, ProgressHandler : ProgressHandler).ConfigureAwait(false); } } else { throw new UnauthorizedAccessException(); } }
public static async Task CreateTarAsync(FileSystemStorageItemBase Source, string NewZipPath, ProgressChangedEventHandler ProgressHandler = null) { if (await FileSystemStorageItemBase.CreateAsync(NewZipPath, StorageItemTypes.File, CreateOption.GenerateUniqueName).ConfigureAwait(false) is FileSystemStorageFile NewFile) { using (FileStream NewFileStream = await NewFile.GetFileStreamFromFileAsync(AccessMode.Exclusive).ConfigureAwait(false)) using (TarOutputStream OutputTarStream = new TarOutputStream(NewFileStream, Encoding.UTF8)) { OutputTarStream.IsStreamOwner = false; switch (Source) { case FileSystemStorageFile File: { using (FileStream FileStream = await File.GetFileStreamFromFileAsync(AccessMode.Read).ConfigureAwait(false)) { TarEntry NewEntry = TarEntry.CreateTarEntry(File.Name); NewEntry.ModTime = DateTime.Now; NewEntry.Size = FileStream.Length; OutputTarStream.PutNextEntry(NewEntry); await FileStream.CopyToAsync(OutputTarStream, ProgressHandler).ConfigureAwait(false); } break; } case FileSystemStorageFolder Folder: { await TarFolderCore(Folder, OutputTarStream, Folder.Name, ProgressHandler).ConfigureAwait(false); break; } } await OutputTarStream.FlushAsync().ConfigureAwait(false); } } else { throw new UnauthorizedAccessException(); } }
public static async Task ExtractGZipAsync(FileSystemStorageFile Source, string NewDirectoryPath, ProgressChangedEventHandler ProgressHandler = null) { using (FileStream SourceFileStream = await Source.GetFileStreamFromFileAsync(AccessMode.Exclusive)) { string NewFilePath = Path.Combine(NewDirectoryPath, Path.GetFileNameWithoutExtension(Source.Path)); using (GZipInputStream GZipStream = new GZipInputStream(SourceFileStream)) { GZipStream.IsStreamOwner = false; await GZipStream.ReadAsync(new byte[128], 0, 128); string GZipInnerFileName = GZipStream.GetFilename(); if (!string.IsNullOrEmpty(GZipInnerFileName)) { NewFilePath = Path.Combine(NewDirectoryPath, GZipInnerFileName); } } SourceFileStream.Seek(0, SeekOrigin.Begin); using (GZipInputStream GZipStream = new GZipInputStream(SourceFileStream)) { GZipStream.IsStreamOwner = false; if (await FileSystemStorageItemBase.CreateAsync(NewFilePath, StorageItemTypes.File, CreateOption.GenerateUniqueName).ConfigureAwait(false) is FileSystemStorageFile NewFile) { using (FileStream NewFileStrem = await NewFile.GetFileStreamFromFileAsync(AccessMode.Write)) { await GZipStream.CopyToAsync(NewFileStrem, ProgressHandler : ProgressHandler).ConfigureAwait(false); } } else { throw new UnauthorizedAccessException(); } } } }
private static async void LogProcessThread() { while (!ExitSignal) { try { if (LogQueue.IsEmpty) { Locker.WaitOne(); } if (await FileSystemStorageItemBase.CreateAsync(Path.Combine(ApplicationData.Current.TemporaryFolder.Path, UniqueName), StorageItemTypes.File, CreateOption.OpenIfExist) is FileSystemStorageItemBase Item) { using (FileStream LogFileStream = Item.GetFileStreamFromFile(AccessMode.Exclusive)) { LogFileStream.Seek(0, SeekOrigin.End); using (StreamWriter Writer = new StreamWriter(LogFileStream, Encoding.Unicode, 1024, true)) { while (LogQueue.TryDequeue(out string LogItem)) { Writer.WriteLine(LogItem); Debug.WriteLine(LogItem); } Writer.Flush(); } } } } catch (Exception ex) { Debug.WriteLine($"Error in writing log file: {ex.Message}"); } } }
public static async Task ExtractAllAsync(IEnumerable <string> SourceItemGroup, string BaseDestPath, bool CreateFolder, ProgressChangedEventHandler ProgressHandler) { ulong TotalSize = 0; ulong CurrentPosition = 0; List <FileSystemStorageFile> TransformList = new List <FileSystemStorageFile>(); foreach (string FileItem in SourceItemGroup) { if (await FileSystemStorageItemBase.OpenAsync(FileItem).ConfigureAwait(false) is FileSystemStorageFile File) { TransformList.Add(File); TotalSize += File.SizeRaw; } else { throw new FileNotFoundException("Could not found the file or path is a directory"); } } if (TotalSize == 0) { return; } foreach (FileSystemStorageFile File in TransformList) { string DestPath = BaseDestPath; //如果解压到独立文件夹,则要额外创建目录 if (CreateFolder) { string NewFolderName = File.Name.EndsWith(".tar.gz", StringComparison.OrdinalIgnoreCase) ? File.Name.Substring(0, File.Name.Length - 7) : (File.Name.EndsWith(".tar.bz2", StringComparison.OrdinalIgnoreCase) ? File.Name.Substring(0, File.Name.Length - 8) : Path.GetFileNameWithoutExtension(File.Name)); if (string.IsNullOrEmpty(NewFolderName)) { NewFolderName = Globalization.GetString("Operate_Text_CreateFolder"); } DestPath = await MakeSureCreateFolderHelperAsync(Path.Combine(BaseDestPath, NewFolderName)); } if (File.Name.EndsWith(".gz", StringComparison.OrdinalIgnoreCase) && !File.Name.EndsWith(".tar.gz", StringComparison.OrdinalIgnoreCase)) { await ExtractGZipAsync(File, DestPath, (s, e) => { ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32((CurrentPosition + Convert.ToUInt64(e.ProgressPercentage / 100d * File.SizeRaw)) * 100d / TotalSize), null)); }); CurrentPosition += Convert.ToUInt64(File.SizeRaw); ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32(CurrentPosition * 100d / TotalSize), null)); } else if (File.Name.EndsWith(".bz2", StringComparison.OrdinalIgnoreCase) && !File.Name.EndsWith(".tar.bz2", StringComparison.OrdinalIgnoreCase)) { await ExtractBZip2Async(File, DestPath, (s, e) => { ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32((CurrentPosition + Convert.ToUInt64(e.ProgressPercentage / 100d * File.SizeRaw)) * 100d / TotalSize), null)); }); CurrentPosition += Convert.ToUInt64(File.SizeRaw); ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32(CurrentPosition * 100d / TotalSize), null)); } else { ReaderOptions ReadOptions = new ReaderOptions(); ReadOptions.ArchiveEncoding.Default = EncodingSetting; using (FileStream InputStream = await File.GetFileStreamFromFileAsync(AccessMode.Read)) using (IReader Reader = ReaderFactory.Open(InputStream, ReadOptions)) { Dictionary <string, string> DirectoryMap = new Dictionary <string, string>(); while (Reader.MoveToNextEntry()) { if (Reader.Entry.IsDirectory) { string DirectoryPath = Path.Combine(DestPath, Reader.Entry.Key.Replace("/", @"\").TrimEnd('\\')); string NewDirectoryPath = await MakeSureCreateFolderHelperAsync(DirectoryPath); if (!DirectoryPath.Equals(NewDirectoryPath, StringComparison.OrdinalIgnoreCase)) { DirectoryMap.Add(DirectoryPath, NewDirectoryPath); } } else { string[] PathList = (Reader.Entry.Key?.Replace("/", @"\")?.Split(@"\")) ?? Array.Empty <string>(); string LastFolder = DestPath; for (int i = 0; i < PathList.Length - 1; i++) { LastFolder = Path.Combine(LastFolder, PathList[i]); if (DirectoryMap.ContainsKey(LastFolder)) { LastFolder = DirectoryMap[LastFolder]; } string NewDirectoryPath = await MakeSureCreateFolderHelperAsync(LastFolder); if (!LastFolder.Equals(NewDirectoryPath, StringComparison.OrdinalIgnoreCase)) { DirectoryMap.Add(LastFolder, NewDirectoryPath); LastFolder = NewDirectoryPath; } } string DestFileName = Path.Combine(LastFolder, PathList.LastOrDefault() ?? Path.GetFileNameWithoutExtension(File.Name)); if (await FileSystemStorageItemBase.CreateAsync(DestFileName, StorageItemTypes.File, CreateOption.GenerateUniqueName).ConfigureAwait(false) is FileSystemStorageFile NewFile) { using (FileStream OutputStream = await NewFile.GetFileStreamFromFileAsync(AccessMode.Write)) using (EntryStream EntryStream = Reader.OpenEntryStream()) { await EntryStream.CopyToAsync(OutputStream, Reader.Entry.Size, (s, e) => { ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32((CurrentPosition + Convert.ToUInt64(e.ProgressPercentage / 100d * Reader.Entry.CompressedSize)) * 100d / TotalSize), null)); }); CurrentPosition += Convert.ToUInt64(Reader.Entry.CompressedSize); ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32(CurrentPosition * 100d / TotalSize), null)); } } } } } } } }
private static async Task CreateTarAsync(IEnumerable <FileSystemStorageItemBase> SourceItemGroup, string NewZipPath, ProgressChangedEventHandler ProgressHandler = null) { if (await FileSystemStorageItemBase.CreateAsync(NewZipPath, StorageItemTypes.File, CreateOption.GenerateUniqueName).ConfigureAwait(false) is FileSystemStorageFile NewFile) { ulong TotalSize = 0; ulong CurrentPosition = 0; foreach (FileSystemStorageItemBase StorageItem in SourceItemGroup) { switch (StorageItem) { case FileSystemStorageFile File: { TotalSize += File.SizeRaw; break; } case FileSystemStorageFolder Folder: { TotalSize += await Folder.GetFolderSizeAsync().ConfigureAwait(false); break; } } } if (TotalSize > 0) { using (FileStream NewFileStream = await NewFile.GetFileStreamFromFileAsync(AccessMode.Exclusive).ConfigureAwait(false)) using (TarOutputStream OutputTarStream = new TarOutputStream(NewFileStream, EncodingSetting)) { OutputTarStream.IsStreamOwner = false; foreach (FileSystemStorageItemBase StorageItem in SourceItemGroup) { switch (StorageItem) { case FileSystemStorageFile File: { using (FileStream FileStream = await File.GetFileStreamFromFileAsync(AccessMode.Read).ConfigureAwait(false)) { TarEntry NewEntry = TarEntry.CreateTarEntry(File.Name); NewEntry.ModTime = DateTime.Now; NewEntry.Size = FileStream.Length; OutputTarStream.PutNextEntry(NewEntry); await FileStream.CopyToAsync(OutputTarStream, ProgressHandler : (s, e) => { ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32((CurrentPosition + Convert.ToUInt64(e.ProgressPercentage / 100d * File.SizeRaw)) * 100d / TotalSize), null)); }).ConfigureAwait(false); } OutputTarStream.CloseEntry(); CurrentPosition += File.SizeRaw; ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32(CurrentPosition * 100d / TotalSize), null)); break; } case FileSystemStorageFolder Folder: { ulong InnerFolderSize = 0; await TarFolderCore(Folder, OutputTarStream, Folder.Name, (ByteRead) => { InnerFolderSize = ByteRead; ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32((CurrentPosition + ByteRead) * 100d / TotalSize), null)); }).ConfigureAwait(false); CurrentPosition += InnerFolderSize; ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32(CurrentPosition * 100d / TotalSize), null)); break; } } } await OutputTarStream.FlushAsync().ConfigureAwait(false); } } } else { throw new UnauthorizedAccessException(); } }
/// <summary> /// 执行ZIP文件创建功能 /// </summary> /// <param name="SourceItemGroup">待压缩文件</param> /// <param name="NewZipPath">生成的Zip文件名</param> /// <param name="ZipLevel">压缩等级</param> /// <param name="ProgressHandler">进度通知</param> /// <returns>无</returns> public static async Task CreateZipAsync(IEnumerable <FileSystemStorageItemBase> SourceItemGroup, string NewZipPath, CompressionLevel Level, CompressionAlgorithm Algorithm, ProgressChangedEventHandler ProgressHandler = null) { if (Level == CompressionLevel.Undefine) { throw new ArgumentException("Undefine is not allowed in this function", nameof(Level)); } if (Algorithm == CompressionAlgorithm.GZip) { throw new ArgumentException("GZip is not allowed in this function", nameof(Algorithm)); } if (await FileSystemStorageItemBase.CreateAsync(NewZipPath, StorageItemTypes.File, CreateOption.GenerateUniqueName).ConfigureAwait(false) is FileSystemStorageFile NewFile) { ulong TotalSize = 0; ulong CurrentPosition = 0; foreach (FileSystemStorageItemBase StorageItem in SourceItemGroup) { switch (StorageItem) { case FileSystemStorageFile File: { TotalSize += File.SizeRaw; break; } case FileSystemStorageFolder Folder: { TotalSize += await Folder.GetFolderSizeAsync().ConfigureAwait(false); break; } } } if (TotalSize > 0) { ZipStrings.CodePage = EncodingSetting.CodePage; using (FileStream NewFileStream = await NewFile.GetFileStreamFromFileAsync(AccessMode.Exclusive).ConfigureAwait(false)) using (ZipOutputStream OutputStream = new ZipOutputStream(NewFileStream)) { OutputStream.SetLevel((int)Level); OutputStream.UseZip64 = UseZip64.Dynamic; OutputStream.IsStreamOwner = false; foreach (FileSystemStorageItemBase StorageItem in SourceItemGroup) { switch (StorageItem) { case FileSystemStorageFile File: { using (FileStream FileStream = await File.GetFileStreamFromFileAsync(AccessMode.Read).ConfigureAwait(false)) { ZipEntry NewEntry = new ZipEntry(File.Name) { DateTime = DateTime.Now, CompressionMethod = Algorithm == CompressionAlgorithm.None ? CompressionMethod.Stored : Enum.Parse <CompressionMethod>(Enum.GetName(typeof(CompressionAlgorithm), Algorithm)), Size = FileStream.Length }; OutputStream.PutNextEntry(NewEntry); await FileStream.CopyToAsync(OutputStream, ProgressHandler : (s, e) => { ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32((CurrentPosition + Convert.ToUInt64(e.ProgressPercentage / 100d * File.SizeRaw)) * 100d / TotalSize), null)); }).ConfigureAwait(false); } OutputStream.CloseEntry(); CurrentPosition += File.SizeRaw; ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32(CurrentPosition * 100d / TotalSize), null)); break; } case FileSystemStorageFolder Folder: { ulong InnerFolderSize = 0; await ZipFolderCore(Folder, OutputStream, Folder.Name, Algorithm, (ByteRead) => { InnerFolderSize = ByteRead; ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32((CurrentPosition + ByteRead) * 100d / TotalSize), null)); }).ConfigureAwait(false); CurrentPosition += InnerFolderSize; ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32(CurrentPosition * 100d / TotalSize), null)); break; } } } await OutputStream.FlushAsync().ConfigureAwait(false); } } } else { throw new UnauthorizedAccessException(); } }
public static async Task <FileSystemStorageFile> GetBingPictureAsync() { string Path = await GetDailyPhotoPath().ConfigureAwait(false); if (await FileSystemStorageItemBase.OpenAsync(System.IO.Path.Combine(ApplicationData.Current.LocalFolder.Path, "BingDailyPicture.jpg")) is FileSystemStorageFile ExistFile) { try { if (string.IsNullOrWhiteSpace(Path)) { return(ExistFile); } if (await CheckIfNeedToUpdate()) { if (await FileSystemStorageItemBase.CreateAsync(System.IO.Path.Combine(ApplicationData.Current.TemporaryFolder.Path, $"BingDailyPicture_Cache_[{DateTime.Now:yyyy-MM-dd HH-mm-ss}].jpg"), StorageItemTypes.File, CreateOption.GenerateUniqueName) is FileSystemStorageFile TempFile) { using (FileStream TempFileStream = await TempFile.GetFileStreamFromFileAsync(AccessMode.ReadWrite)) { HttpWebRequest Request = WebRequest.CreateHttp(new Uri($"https://www.bing.com{Path}")); Request.Timeout = 10000; Request.ReadWriteTimeout = 10000; using (WebResponse Response = await Request.GetResponseAsync()) using (Stream ResponseStream = Response.GetResponseStream()) { await ResponseStream.CopyToAsync(TempFileStream); } using (Stream FileStream = await ExistFile.GetFileStreamFromFileAsync(AccessMode.Read)) 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); if (ResultArray[0] == ResultArray[1]) { return(ExistFile); } } TempFileStream.Seek(0, SeekOrigin.Begin); using (StorageStreamTransaction Transaction = await ExistFile.GetTransactionStreamFromFileAsync()) { await TempFileStream.CopyToAsync(Transaction.Stream.AsStreamForWrite()); await Transaction.CommitAsync(); } } } else { LogTracer.Log($"Could not create temp file as needed in {nameof(GetBingPictureAsync)}"); } return(ExistFile); } else { return(ExistFile); } } catch (Exception ex) { LogTracer.Log(ex, $"An error was threw in {nameof(GetBingPictureAsync)}"); return(ExistFile); } } else { try { if (string.IsNullOrWhiteSpace(Path)) { return(null); } if (await FileSystemStorageItemBase.CreateAsync(System.IO.Path.Combine(ApplicationData.Current.TemporaryFolder.Path, $"BingDailyPicture_Cache_[{DateTime.Now:yyyy-MM-dd HH-mm-ss}].jpg"), StorageItemTypes.File, CreateOption.GenerateUniqueName) is FileSystemStorageFile TempFile) { using (Stream TempFileStream = await TempFile.GetFileStreamFromFileAsync(AccessMode.ReadWrite)) { HttpWebRequest Request = WebRequest.CreateHttp(new Uri($"https://www.bing.com{Path}")); Request.Timeout = 10000; Request.ReadWriteTimeout = 10000; using (WebResponse Response = await Request.GetResponseAsync()) using (Stream ResponseStream = Response.GetResponseStream()) { await ResponseStream.CopyToAsync(TempFileStream); } if (await FileSystemStorageItemBase.CreateAsync(System.IO.Path.Combine(ApplicationData.Current.LocalFolder.Path, "BingDailyPicture.jpg"), StorageItemTypes.File, CreateOption.ReplaceExisting) is FileSystemStorageFile BingDailyPictureFile) { using (StorageStreamTransaction Transaction = await BingDailyPictureFile.GetTransactionStreamFromFileAsync()) { TempFileStream.Seek(0, SeekOrigin.Begin); await TempFileStream.CopyToAsync(Transaction.Stream.AsStreamForWrite()); await Transaction.CommitAsync(); } return(BingDailyPictureFile); } else { LogTracer.Log($"Could not create BingPicture file as needed in {nameof(GetBingPictureAsync)}"); return(null); } } } else { LogTracer.Log($"Could not create temp file as needed in {nameof(GetBingPictureAsync)}"); return(null); } } catch (Exception ex) { LogTracer.Log(ex, $"An error was threw in {nameof(GetBingPictureAsync)}"); return(null); } } }
/// <summary> /// 执行ZIP解压功能 /// </summary> /// <param name="File">ZIP文件</param> /// <returns>无</returns> public static async Task ExtractZipAsync(FileSystemStorageFolder NewFolder, FileSystemStorageFile File, ProgressChangedEventHandler ProgressHandler = null) { ZipStrings.CodePage = EncodingSetting.CodePage; using (FileStream BaseStream = await File.GetFileStreamFromFileAsync(AccessMode.Exclusive).ConfigureAwait(false)) using (ZipInputStream InputZipStream = new ZipInputStream(BaseStream)) { BaseStream.Seek(0, SeekOrigin.Begin); InputZipStream.IsStreamOwner = false; long CurrentPosition = 0; while (InputZipStream.GetNextEntry() is ZipEntry Entry) { if (!InputZipStream.CanDecompressEntry || Entry.IsCrypted) { throw new NotImplementedException(); } if (Entry.Name.Contains("/")) { string[] SplitFolderPath = Entry.Name.Split('/', StringSplitOptions.RemoveEmptyEntries); string TempFolderPath = NewFolder.Path; for (int i = 0; i < SplitFolderPath.Length - 1; i++) { if (await FileSystemStorageItemBase.CreateAsync(Path.Combine(TempFolderPath, SplitFolderPath[i]), StorageItemTypes.Folder, CreateOption.OpenIfExist).ConfigureAwait(false) is FileSystemStorageFolder NextFolder) { TempFolderPath = NextFolder.Path; } else { throw new UnauthorizedAccessException("Could not create directory"); } } if (Entry.Name.Last() == '/') { if (await FileSystemStorageItemBase.CreateAsync(Path.Combine(TempFolderPath, SplitFolderPath.Last()), StorageItemTypes.Folder, CreateOption.OpenIfExist).ConfigureAwait(false) == null) { throw new UnauthorizedAccessException("Could not create directory"); } } else { if (await FileSystemStorageItemBase.CreateAsync(Path.Combine(TempFolderPath, SplitFolderPath.Last()), StorageItemTypes.File, CreateOption.GenerateUniqueName).ConfigureAwait(false) is FileSystemStorageFile NewFile) { using (FileStream NewFileStream = await NewFile.GetFileStreamFromFileAsync(AccessMode.Write).ConfigureAwait(false)) { //For some files in Zip, CompressedSize or Size might less than zero, then we could not get progress by reading ZipInputStream.Length if (Entry.CompressedSize > 0 && Entry.Size > 0) { await InputZipStream.CopyToAsync(NewFileStream, (s, e) => { ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32((CurrentPosition + Convert.ToInt64(e.ProgressPercentage / 100d * Entry.CompressedSize)) * 100d / BaseStream.Length), null)); }).ConfigureAwait(false); } else { await InputZipStream.CopyToAsync(NewFileStream).ConfigureAwait(false); } } } else { throw new UnauthorizedAccessException(); } } } else { if (await FileSystemStorageItemBase.CreateAsync(Path.Combine(NewFolder.Path, Entry.Name), StorageItemTypes.File, CreateOption.GenerateUniqueName).ConfigureAwait(false) is FileSystemStorageFile NewFile) { using (FileStream NewFileStream = await NewFile.GetFileStreamFromFileAsync(AccessMode.Write).ConfigureAwait(false)) { //For some files in Zip, CompressedSize or Size might less than zero, then we could not get progress by reading ZipInputStream.Length if (Entry.CompressedSize > 0 && Entry.Size > 0) { await InputZipStream.CopyToAsync(NewFileStream, (s, e) => { ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32((CurrentPosition + Convert.ToInt64(e.ProgressPercentage / 100d * Entry.CompressedSize)) * 100d / BaseStream.Length), null)); }).ConfigureAwait(true); } else { await InputZipStream.CopyToAsync(NewFileStream).ConfigureAwait(false); } } } else { throw new UnauthorizedAccessException(); } } ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32((CurrentPosition = BaseStream.Position) * 100d / BaseStream.Length), null)); } } }
/// <summary> /// 执行ZIP文件创建功能 /// </summary> /// <param name="SourceItemGroup">待压缩文件</param> /// <param name="NewZipPath">生成的Zip文件名</param> /// <param name="ZipLevel">压缩等级</param> /// <param name="ProgressHandler">进度通知</param> /// <returns>无</returns> public static async Task CreateZipAsync(IEnumerable <FileSystemStorageItemBase> SourceItemGroup, string NewZipPath, int ZipLevel, ProgressChangedEventHandler ProgressHandler = null) { if (await FileSystemStorageItemBase.CreateAsync(NewZipPath, StorageItemTypes.File, CreateOption.GenerateUniqueName).ConfigureAwait(false) is FileSystemStorageFile NewFile) { ulong TotalSize = 0; ulong CurrentPosition = 0; using (FileStream NewFileStream = await NewFile.GetFileStreamFromFileAsync(AccessMode.Exclusive).ConfigureAwait(false)) using (ZipOutputStream OutputStream = new ZipOutputStream(NewFileStream)) { OutputStream.SetLevel(ZipLevel); OutputStream.UseZip64 = UseZip64.Dynamic; OutputStream.IsStreamOwner = false; foreach (FileSystemStorageItemBase StorageItem in SourceItemGroup) { switch (StorageItem) { case FileSystemStorageFile File: { TotalSize += File.SizeRaw; break; } case FileSystemStorageFolder Folder: { TotalSize += await Folder.GetFolderSizeAsync().ConfigureAwait(false); break; } } } foreach (FileSystemStorageItemBase StorageItem in SourceItemGroup) { switch (StorageItem) { case FileSystemStorageFile File: { using (FileStream FileStream = await File.GetFileStreamFromFileAsync(AccessMode.Read).ConfigureAwait(false)) { ZipEntry NewEntry = new ZipEntry(File.Name) { DateTime = DateTime.Now, CompressionMethod = CompressionMethod.Deflated, Size = FileStream.Length }; OutputStream.PutNextEntry(NewEntry); await FileStream.CopyToAsync(OutputStream, (s, e) => { ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32((CurrentPosition + Convert.ToUInt64(e.ProgressPercentage / 100d * File.SizeRaw)) * 100d / TotalSize), null)); }).ConfigureAwait(false); } if (TotalSize > 0) { CurrentPosition += File.SizeRaw; ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32(CurrentPosition * 100d / TotalSize), null)); } break; } case FileSystemStorageFolder Folder: { ulong InnerFolderSize = await Folder.GetFolderSizeAsync().ConfigureAwait(false); await ZipFolderCore(Folder, OutputStream, Folder.Name, (s, e) => { if (TotalSize > 0) { ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32((CurrentPosition + Convert.ToUInt64(e.ProgressPercentage / 100d * InnerFolderSize)) * 100d / TotalSize), null)); } }).ConfigureAwait(false); if (TotalSize > 0) { CurrentPosition += InnerFolderSize; ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32(CurrentPosition * 100d / TotalSize), null)); } break; } } } await OutputStream.FlushAsync().ConfigureAwait(false); } } else { throw new UnauthorizedAccessException(); } }
public static async Task ExtractTarAsync(FileSystemStorageFolder NewFolder, FileSystemStorageFile File, ProgressChangedEventHandler ProgressHandler = null) { using (FileStream BaseStream = await File.GetFileStreamFromFileAsync(AccessMode.Exclusive).ConfigureAwait(false)) using (TarInputStream InputTarStream = new TarInputStream(BaseStream, Encoding.UTF8)) { BaseStream.Seek(0, SeekOrigin.Begin); InputTarStream.IsStreamOwner = false; long CurrentPosition = 0; while (InputTarStream.GetNextEntry() is TarEntry Entry) { if (Entry.Name.Contains("/")) { string[] SplitFolderPath = Entry.Name.Split('/', StringSplitOptions.RemoveEmptyEntries); string TempFolderPath = NewFolder.Path; for (int i = 0; i < SplitFolderPath.Length - 1; i++) { if (await FileSystemStorageItemBase.CreateAsync(Path.Combine(TempFolderPath, SplitFolderPath[i]), StorageItemTypes.Folder, CreateOption.OpenIfExist).ConfigureAwait(false) is FileSystemStorageFolder NextFolder) { TempFolderPath = NextFolder.Path; } else { throw new UnauthorizedAccessException("Could not create directory"); } } if (Entry.Name.Last() == '/') { if (await FileSystemStorageItemBase.CreateAsync(Path.Combine(TempFolderPath, SplitFolderPath.Last()), StorageItemTypes.Folder, CreateOption.OpenIfExist).ConfigureAwait(false) == null) { throw new UnauthorizedAccessException("Could not create directory"); } } else { if (await FileSystemStorageItemBase.CreateAsync(Path.Combine(TempFolderPath, SplitFolderPath.Last()), StorageItemTypes.File, CreateOption.GenerateUniqueName).ConfigureAwait(false) is FileSystemStorageFile NewFile) { using (FileStream NewFileStream = await NewFile.GetFileStreamFromFileAsync(AccessMode.Write).ConfigureAwait(false)) { if (Entry.Size > 0) { await InputTarStream.CopyToAsync(NewFileStream, (s, e) => { ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32((CurrentPosition + Convert.ToInt64(e.ProgressPercentage / 100d * Entry.Size)) * 100d / BaseStream.Length), null)); }).ConfigureAwait(false); } else { await InputTarStream.CopyToAsync(NewFileStream).ConfigureAwait(false); } } } else { throw new UnauthorizedAccessException(); } } } else { if (await FileSystemStorageItemBase.CreateAsync(Path.Combine(NewFolder.Path, Entry.Name), StorageItemTypes.File, CreateOption.GenerateUniqueName).ConfigureAwait(false) is FileSystemStorageFile NewFile) { using (FileStream NewFileStream = await NewFile.GetFileStreamFromFileAsync(AccessMode.Write).ConfigureAwait(false)) { if (Entry.Size > 0) { await InputTarStream.CopyToAsync(NewFileStream, (s, e) => { ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32((CurrentPosition + Convert.ToInt64(e.ProgressPercentage / 100d * Entry.Size)) * 100d / BaseStream.Length), null)); }).ConfigureAwait(false); } else { await InputTarStream.CopyToAsync(NewFileStream).ConfigureAwait(false); } } } else { throw new UnauthorizedAccessException(); } } ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32((CurrentPosition = BaseStream.Position) * 100d / BaseStream.Length), null)); } } }