public static async Task <FileSystemStorageItemBase> OpenAsync(string Path) { if (System.IO.Path.GetPathRoot(Path) != Path && WIN_Native_API.GetStorageItem(Path) is FileSystemStorageItemBase Item) { return(Item); } else { LogTracer.Log($"Native API could not found the path: \"{Path}\", fall back to UWP storage API"); try { string DirectoryPath = System.IO.Path.GetDirectoryName(Path); if (string.IsNullOrEmpty(DirectoryPath)) { StorageFolder Folder = await StorageFolder.GetFolderFromPathAsync(Path); return(await FileSystemStorageFolder.CreateFromExistingStorageItem(Folder)); } else { StorageFolder ParentFolder = await StorageFolder.GetFolderFromPathAsync(DirectoryPath); switch (await ParentFolder.TryGetItemAsync(System.IO.Path.GetFileName(Path))) { case StorageFolder Folder: { return(await FileSystemStorageFolder.CreateFromExistingStorageItem(Folder)); } case StorageFile File: { return(await FileSystemStorageFile.CreateFromExistingStorageItem(File)); } default: { LogTracer.Log($"UWP storage API could not found the path: \"{Path}\""); return(null); } } } } catch (Exception ex) { LogTracer.Log(ex, $"UWP storage API could not found the path: \"{Path}\""); return(null); } } }
public static async Task ExtractGZipAsync(FileSystemStorageFolder NewFolder, FileSystemStorageFile Item, ProgressChangedEventHandler ProgressHandler = null) { if (await FileSystemStorageItemBase.CreateAsync(Path.Combine(NewFolder.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 override async IAsyncEnumerable <FileSystemStorageItemBase> SearchAsync(string SearchWord, bool SearchInSubFolders = false, bool IncludeHiddenItem = false, bool IncludeSystemItem = false, bool IsRegexExpresstion = false, bool IgnoreCase = true, [EnumeratorCancellation] CancellationToken CancelToken = default) { foreach (DriveDataBase Drive in CommonAccessCollection.DriveList) { if (WIN_Native_API.CheckLocationAvailability(Drive.Path)) { foreach (FileSystemStorageItemBase Item in await Task.Factory.StartNew(() => WIN_Native_API.Search(Drive.Path, SearchWord, SearchInSubFolders, IncludeHiddenItem, IncludeSystemItem, IsRegexExpresstion, IgnoreCase, CancelToken), TaskCreationOptions.LongRunning)) { yield return(Item); } } else { if (Drive.DriveFolder != null) { QueryOptions Options = new QueryOptions { FolderDepth = FolderDepth.Shallow, IndexerOption = IndexerOption.DoNotUseIndexer }; Options.SetThumbnailPrefetch(ThumbnailMode.ListView, 150, ThumbnailOptions.UseCurrentScale); Options.SetPropertyPrefetch(PropertyPrefetchOptions.BasicProperties, new string[] { "System.FileName", "System.Size", "System.DateModified", "System.DateCreated" }); StorageItemQueryResult Query = Drive.DriveFolder.CreateItemQueryWithOptions(Options); for (uint Index = 0; !CancelToken.IsCancellationRequested; Index += 50) { IReadOnlyList <IStorageItem> ReadOnlyItemList = await Query.GetItemsAsync(Index, 50).AsTask(CancelToken); if (ReadOnlyItemList.Count > 0) { foreach (IStorageItem Item in IsRegexExpresstion ? ReadOnlyItemList.AsParallel().Where((Item) => Regex.IsMatch(Item.Name, SearchWord, IgnoreCase ? RegexOptions.IgnoreCase : RegexOptions.None)) : ReadOnlyItemList.AsParallel().Where((Item) => Item.Name.Contains(SearchWord, IgnoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal))) { if (CancelToken.IsCancellationRequested) { yield break; } switch (Item) { case StorageFolder SubFolder: { yield return(await CreatedByStorageItemAsync(SubFolder)); break; } case StorageFile SubFile: { yield return(await CreatedByStorageItemAsync(SubFile)); break; } } } if (SearchInSubFolders) { foreach (StorageFolder Item in ReadOnlyItemList.OfType <StorageFolder>()) { if (CancelToken.IsCancellationRequested) { yield break; } FileSystemStorageFolder FSubFolder = await CreatedByStorageItemAsync(Item); await foreach (FileSystemStorageItemBase FSubItem in FSubFolder.SearchAsync(SearchWord, SearchInSubFolders, IncludeHiddenItem, IncludeSystemItem, IsRegexExpresstion, IgnoreCase, CancelToken)) { if (CancelToken.IsCancellationRequested) { yield break; } yield return(FSubItem); } } } } else { break; } } } } } }
public virtual Task CopyAsync(FileSystemStorageFolder Directory, ProgressChangedEventHandler ProgressHandler = null) { return(CopyAsync(Directory.Path, ProgressHandler)); }
private DriveChangeDeferredEventArgs(FileSystemStorageFolder StorageItem) { this.StorageItem = StorageItem; }
private static async Task TarFolderCore(FileSystemStorageFolder Folder, TarOutputStream OutputStream, string BaseFolderName, ByteReadChangedEventHandler ByteReadHandler = null) { IReadOnlyList <FileSystemStorageItemBase> ItemList = await Folder.GetChildItemsAsync(true, true).ConfigureAwait(false); if (ItemList.Count == 0) { if (!string.IsNullOrEmpty(BaseFolderName)) { TarEntry NewEntry = TarEntry.CreateTarEntry($"{BaseFolderName}/"); OutputStream.PutNextEntry(NewEntry); OutputStream.CloseEntry(); } } else { ulong CurrentPosition = 0; foreach (FileSystemStorageItemBase Item in ItemList) { switch (Item) { case FileSystemStorageFolder InnerFolder: { ulong InnerFolderSize = 0; await TarFolderCore(InnerFolder, OutputStream, $"{BaseFolderName}/{InnerFolder.Name}", ByteReadHandler : (ByteRead) => { InnerFolderSize = ByteRead; ByteReadHandler?.Invoke(CurrentPosition + ByteRead); }).ConfigureAwait(false); ByteReadHandler?.Invoke(CurrentPosition += InnerFolderSize); break; } case FileSystemStorageFile InnerFile: { using (FileStream FileStream = await InnerFile.GetFileStreamFromFileAsync(AccessMode.Read).ConfigureAwait(false)) { TarEntry NewEntry = TarEntry.CreateTarEntry($"{BaseFolderName}/{InnerFile.Name}"); NewEntry.ModTime = DateTime.Now; NewEntry.Size = FileStream.Length; OutputStream.PutNextEntry(NewEntry); await FileStream.CopyToAsync(OutputStream, ProgressHandler : (s, e) => { ByteReadHandler?.Invoke(CurrentPosition + Convert.ToUInt64(e.ProgressPercentage / 100d * InnerFile.SizeRaw)); }).ConfigureAwait(false); } OutputStream.CloseEntry(); ByteReadHandler?.Invoke(CurrentPosition += InnerFile.SizeRaw); break; } } } } }
private static async Task ZipFolderCore(FileSystemStorageFolder Folder, ZipOutputStream OutputStream, string BaseFolderName, CompressionAlgorithm Algorithm, ByteReadChangedEventHandler ByteReadHandler = null) { IReadOnlyList <FileSystemStorageItemBase> ItemList = await Folder.GetChildItemsAsync(true, true).ConfigureAwait(false); if (ItemList.Count == 0) { if (!string.IsNullOrEmpty(BaseFolderName)) { ZipEntry NewEntry = new ZipEntry($"{BaseFolderName}/") { DateTime = DateTime.Now }; OutputStream.PutNextEntry(NewEntry); OutputStream.CloseEntry(); } } else { ulong CurrentPosition = 0; foreach (FileSystemStorageItemBase Item in ItemList) { switch (Item) { case FileSystemStorageFolder InnerFolder: { ulong InnerFolderSize = 0; await ZipFolderCore(InnerFolder, OutputStream, $"{BaseFolderName}/{Item.Name}", Algorithm, (ByteRead) => { InnerFolderSize = ByteRead; ByteReadHandler?.Invoke(CurrentPosition + ByteRead); }).ConfigureAwait(false); ByteReadHandler?.Invoke(CurrentPosition += InnerFolderSize); break; } case FileSystemStorageFile InnerFile: { using (FileStream FileStream = await InnerFile.GetFileStreamFromFileAsync(AccessMode.Read).ConfigureAwait(false)) { ZipEntry NewEntry = new ZipEntry($"{BaseFolderName}/{Item.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) => { ByteReadHandler?.Invoke(CurrentPosition + Convert.ToUInt64(e.ProgressPercentage / 100d * InnerFile.SizeRaw)); }).ConfigureAwait(false); } OutputStream.CloseEntry(); ByteReadHandler?.Invoke(CurrentPosition += Item.SizeRaw); break; } } } } }
public virtual Task CopyAsync(FileSystemStorageFolder Directory, CollisionOptions Option = CollisionOptions.None, ProgressChangedEventHandler ProgressHandler = null) { return(CopyAsync(Directory.Path, Option, ProgressHandler)); }
public virtual Task CopyAsync(FileSystemStorageFolder Directory, ProgressChangedEventHandler ProgressHandler = null, bool IsUndoOperation = false) { return(CopyAsync(Directory.Path, ProgressHandler, IsUndoOperation)); }
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)); } } }
private static async Task ZipFolderCore(FileSystemStorageFolder Folder, ZipOutputStream OutputStream, string BaseFolderName, ProgressChangedEventHandler ProgressHandler = null) { List <FileSystemStorageItemBase> ItemList = await Folder.GetChildItemsAsync(true).ConfigureAwait(false); if (ItemList.Count == 0) { if (!string.IsNullOrEmpty(BaseFolderName)) { ZipEntry NewEntry = new ZipEntry($"{BaseFolderName}/"); OutputStream.PutNextEntry(NewEntry); OutputStream.CloseEntry(); } } else { ulong TotalSize = await Folder.GetFolderSizeAsync().ConfigureAwait(false); ulong CurrentPosition = 0; foreach (FileSystemStorageItemBase Item in ItemList) { switch (Item) { case FileSystemStorageFolder InnerFolder: { ulong InnerFolderSize = await InnerFolder.GetFolderSizeAsync().ConfigureAwait(false); await ZipFolderCore(InnerFolder, OutputStream, $"{BaseFolderName}/{Item.Name}", ProgressHandler : (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; } case FileSystemStorageFile InnerFile: { using (FileStream FileStream = await InnerFile.GetFileStreamFromFileAsync(AccessMode.Read).ConfigureAwait(false)) { ZipEntry NewEntry = new ZipEntry($"{BaseFolderName}/{Item.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 * InnerFile.SizeRaw)) * 100d / TotalSize), null)); }).ConfigureAwait(false); } if (TotalSize > 0) { CurrentPosition += Item.SizeRaw; ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32(CurrentPosition * 100d / TotalSize), null)); } break; } } } } }
public static async Task <FileSystemStorageItemBase> CreateAsync(string Path, StorageItemTypes ItemTypes, CreateOption Option) { switch (ItemTypes) { case StorageItemTypes.File: { if (WIN_Native_API.CreateFileFromPath(Path, Option, out string NewPath)) { return(await OpenAsync(NewPath)); } else { LogTracer.Log($"Native API could not create file: \"{Path}\", fall back to UWP storage API"); try { StorageFolder Folder = await StorageFolder.GetFolderFromPathAsync(System.IO.Path.GetDirectoryName(Path)); switch (Option) { case CreateOption.GenerateUniqueName: { StorageFile NewFile = await Folder.CreateFileAsync(System.IO.Path.GetFileName(Path), CreationCollisionOption.GenerateUniqueName); return(await FileSystemStorageFile.CreateFromExistingStorageItem(NewFile)); } case CreateOption.OpenIfExist: { StorageFile NewFile = await Folder.CreateFileAsync(System.IO.Path.GetFileName(Path), CreationCollisionOption.OpenIfExists); return(await FileSystemStorageFile.CreateFromExistingStorageItem(NewFile)); } case CreateOption.ReplaceExisting: { StorageFile NewFile = await Folder.CreateFileAsync(System.IO.Path.GetFileName(Path), CreationCollisionOption.ReplaceExisting); return(await FileSystemStorageFile.CreateFromExistingStorageItem(NewFile)); } default: { return(null); } } } catch { LogTracer.Log($"UWP storage API could not create file: \"{Path}\""); return(null); } } } case StorageItemTypes.Folder: { if (WIN_Native_API.CreateDirectoryFromPath(Path, Option, out string NewPath)) { return(await OpenAsync(NewPath)); } else { LogTracer.Log($"Native API could not create file: \"{Path}\", fall back to UWP storage API"); try { StorageFolder Folder = await StorageFolder.GetFolderFromPathAsync(System.IO.Path.GetDirectoryName(Path)); switch (Option) { case CreateOption.GenerateUniqueName: { StorageFolder NewFolder = await Folder.CreateFolderAsync(System.IO.Path.GetFileName(Path), CreationCollisionOption.GenerateUniqueName); return(await FileSystemStorageFolder.CreateFromExistingStorageItem(NewFolder)); } case CreateOption.OpenIfExist: { StorageFolder NewFolder = await Folder.CreateFolderAsync(System.IO.Path.GetFileName(Path), CreationCollisionOption.OpenIfExists); return(await FileSystemStorageFolder.CreateFromExistingStorageItem(NewFolder)); } case CreateOption.ReplaceExisting: { StorageFolder NewFolder = await Folder.CreateFolderAsync(System.IO.Path.GetFileName(Path), CreationCollisionOption.ReplaceExisting); return(await FileSystemStorageFolder.CreateFromExistingStorageItem(NewFolder)); } default: { return(null); } } } catch { LogTracer.Log($"UWP storage API could not create folder: \"{Path}\""); return(null); } } } default: { 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)); } } }