Merge branch 'master' into multitasking

tsvietOK · tsvietOK · commit 6d68958b5f86 · 2020-11-09T03:03:08.000+02:00
diff --git a/Files/Commands/Paste.cs b/Files/Commands/Paste.cs
@@ -138,7 +138,7 @@ await AppInstance.FilesystemViewModel.GetFolderFromPathAsync(destinationPath)
                     if (res)
                     {
                         StorageFile clipboardFile = (StorageFile)item;
-                        var pasted = await clipboardFile.CopyAsync(res.Result, item.Name, NameCollisionOption.GenerateUniqueName).AsTask().Wrap();
+                        var pasted = await FilesystemTasks.Wrap(() => clipboardFile.CopyAsync(res.Result, item.Name, NameCollisionOption.GenerateUniqueName).AsTask());
                         if (pasted)
                         {
                             pastedSourceItems.Add(item);
diff --git a/Files/DataModels/SidebarPinnedModel.cs b/Files/DataModels/SidebarPinnedModel.cs
@@ -181,8 +181,8 @@ public int IndexOfItem(INavigationControlItem locationItem, List<INavigationCont
         /// <returns>Task</returns>
         public async Task AddItemToSidebarAsync(string path)
         {
-            var item = await DrivesManager.GetRootFromPathAsync(path).Wrap();
-            var res = await StorageFileExtensions.DangerousGetFolderFromPathAsync(path, item).Wrap();
+            var item = await FilesystemTasks.Wrap(() => DrivesManager.GetRootFromPathAsync(path));
+            var res = await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFolderFromPathAsync(path, item));
             if (res)
             {
                 int insertIndex = MainPage.sideBarItems.IndexOf(MainPage.sideBarItems.Last(x => x.ItemType == NavigationControlItemType.Location
diff --git a/Files/Filesystem/Drives.cs b/Files/Filesystem/Drives.cs
@@ -244,7 +244,7 @@ private async Task<bool> GetDrivesAsync(IList<DriveItem> list)
                     continue;
                 }
 
-                var res = await StorageFolder.GetFolderFromPathAsync(drive.Name).AsTask().Wrap();
+                var res = await FilesystemTasks.Wrap(() => StorageFolder.GetFolderFromPathAsync(drive.Name).AsTask());
                 if (res == FilesystemErrorCode.ERROR_UNAUTHORIZED)
                 {
                     unauthorizedAccessDetected = true;
diff --git a/Files/Filesystem/StorageFileHelpers/FilesystemResult.cs b/Files/Filesystem/StorageFileHelpers/FilesystemResult.cs
@@ -60,7 +60,7 @@ public static explicit operator FilesystemResult(bool res) =>
             new FilesystemResult(res ? FilesystemErrorCode.ERROR_OK : FilesystemErrorCode.ERROR_GENERIC);
     }
 
-    public static class TaskExtensions
+    public static class FilesystemTasks
     {
         private static FilesystemErrorCode GetErrorCode(Exception ex, Type T = null)
         {
@@ -103,23 +103,23 @@ private static FilesystemErrorCode GetErrorCode(Exception ex, Type T = null)
             }
         }
 
-        public async static Task<FilesystemResult<T>> Wrap<T>(this Task<T> wrapped)
+        public async static Task<FilesystemResult<T>> Wrap<T>(Func<Task<T>> wrapped)
         {
             try
             {
-                return new FilesystemResult<T>(await wrapped, FilesystemErrorCode.ERROR_OK);
+                return new FilesystemResult<T>(await wrapped(), FilesystemErrorCode.ERROR_OK);
             }
             catch (Exception ex)
             {
                 return new FilesystemResult<T>(default(T), GetErrorCode(ex, typeof(T)));
             }
         }
 
-        public async static Task<FilesystemResult> Wrap(this Task wrapped)
+        public async static Task<FilesystemResult> Wrap(Func<Task> wrapped)
         {
             try
             {
-                await wrapped;
+                await wrapped();
                 return new FilesystemResult(FilesystemErrorCode.ERROR_OK);
             }
             catch (Exception ex)
@@ -133,7 +133,7 @@ public async static Task<FilesystemResult<T>> OnSuccess<T>(this Task<FilesystemR
             var res = await wrapped;
             if (res)
             {
-                return await func(res.Result).Wrap();
+                return await Wrap(() => func(res.Result));
             }
             return res;
         }
@@ -143,7 +143,7 @@ public async static Task<FilesystemResult> OnSuccess<T>(this Task<FilesystemResu
             var res = await wrapped;
             if (res)
             {
-                return await func(res.Result).Wrap();
+                return await Wrap(() => func(res.Result));
             }
             return res;
         }
diff --git a/Files/Interacts/Interaction.cs b/Files/Interacts/Interaction.cs
@@ -90,7 +90,7 @@ public async void SetAsBackground(WallpaperType type)
                 // Generate unique name if the file already exists.
                 // If the file you are trying to set as the wallpaper has the same name as the current wallpaper,
                 // the system will ignore the request and no-op the operation
-                var file = (StorageFile)await sourceFile.CopyAsync(localFolder, sourceFile.Name, NameCollisionOption.GenerateUniqueName).AsTask().Wrap();
+                var file = (StorageFile)await FilesystemTasks.Wrap(() => sourceFile.CopyAsync(localFolder, sourceFile.Name, NameCollisionOption.GenerateUniqueName).AsTask());
                 if (file == null) return;
 
                 UserProfilePersonalizationSettings profileSettings = UserProfilePersonalizationSettings.Current;
@@ -885,7 +885,7 @@ public async void RestoreItem_Click(object sender, RoutedEventArgs e)
                         restored = sourceFolder.ErrorCode | destFolder.ErrorCode;
                         if (sourceFolder && destFolder)
                         {
-                            restored = await MoveDirectoryAsync(sourceFolder.Result, destFolder.Result, recycleBinItem.ItemName).Wrap()
+                            restored = await FilesystemTasks.Wrap(() => MoveDirectoryAsync(sourceFolder.Result, destFolder.Result, recycleBinItem.ItemName))
                                 .OnSuccess(t => sourceFolder.Result.DeleteAsync(StorageDeleteOption.PermanentDelete).AsTask());
                         }
                     }
@@ -896,7 +896,7 @@ public async void RestoreItem_Click(object sender, RoutedEventArgs e)
                         restored = sourceFile.ErrorCode | destFolder.ErrorCode;
                         if (sourceFile && destFolder)
                         {
-                            restored = await sourceFile.Result.MoveAsync(destFolder.Result, Path.GetFileName(recycleBinItem.ItemOriginalPath), NameCollisionOption.GenerateUniqueName).AsTask().Wrap();
+                            restored = await FilesystemTasks.Wrap(() => sourceFile.Result.MoveAsync(destFolder.Result, Path.GetFileName(recycleBinItem.ItemOriginalPath), NameCollisionOption.GenerateUniqueName).AsTask());
                         }
                     }
                     // Recycle bin also stores a file starting with $I for each item
@@ -1166,17 +1166,17 @@ public async void CreateFileFromDialogResultType(AddItemType itemType)
                 {
                     case AddItemType.Folder:
                         userInput = !string.IsNullOrWhiteSpace(userInput) ? userInput : "NewFolder".GetLocalized();
-                        created = await folderRes.Result.CreateFolderAsync(userInput, CreationCollisionOption.GenerateUniqueName).AsTask().Wrap();
+                        created = await FilesystemTasks.Wrap(() => folderRes.Result.CreateFolderAsync(userInput, CreationCollisionOption.GenerateUniqueName).AsTask());
                         break;
 
                     case AddItemType.TextDocument:
                         userInput = !string.IsNullOrWhiteSpace(userInput) ? userInput : "NewTextDocument".GetLocalized();
-                        created = await folderRes.Result.CreateFileAsync(userInput + ".txt", CreationCollisionOption.GenerateUniqueName).AsTask().Wrap();
+                        created = await FilesystemTasks.Wrap(() => folderRes.Result.CreateFileAsync(userInput + ".txt", CreationCollisionOption.GenerateUniqueName).AsTask());
                         break;
 
                     case AddItemType.BitmapImage:
                         userInput = !string.IsNullOrWhiteSpace(userInput) ? userInput : "NewBitmapImage".GetLocalized();
-                        created = await folderRes.Result.CreateFileAsync(userInput + ".bmp", CreationCollisionOption.GenerateUniqueName).AsTask().Wrap();
+                        created = await FilesystemTasks.Wrap(() => folderRes.Result.CreateFileAsync(userInput + ".bmp", CreationCollisionOption.GenerateUniqueName).AsTask());
                         break;
                 }
             }
@@ -1255,7 +1255,7 @@ public async Task<string> GetHashForFileAsync(ListedItem fileItem, string nameOf
             HashAlgorithmProvider algorithmProvider = HashAlgorithmProvider.OpenAlgorithm(nameOfAlg);
             StorageFile itemFromPath = await AssociatedInstance.FilesystemViewModel.GetFileFromPathAsync((fileItem as ShortcutItem)?.TargetPath ?? fileItem.ItemPath);
             if (itemFromPath == null) return "";
-            Stream stream = await itemFromPath.OpenStreamForReadAsync().Wrap();
+            Stream stream = await FilesystemTasks.Wrap(() => itemFromPath.OpenStreamForReadAsync());
             if (stream == null) return "";
             var inputStream = stream.AsInputStream();
             var str = inputStream.AsStreamForRead();
diff --git a/Files/View Models/ItemViewModel.cs b/Files/View Models/ItemViewModel.cs
@@ -91,12 +91,12 @@ public async Task<FilesystemResult> SetWorkingDirectoryAsync(string value)
             }
             else if (!Path.IsPathRooted(WorkingDirectory) || Path.GetPathRoot(WorkingDirectory) != Path.GetPathRoot(value))
             {
-                _workingRoot = await DrivesManager.GetRootFromPathAsync(value).Wrap();
+                _workingRoot = await FilesystemTasks.Wrap(() => DrivesManager.GetRootFromPathAsync(value));
             }
 
             if (Path.IsPathRooted(value))
             {
-                var res = await StorageFileExtensions.DangerousGetFolderWithPathFromPathAsync(value, _workingRoot, _currentStorageFolder).Wrap();
+                var res = await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFolderWithPathFromPathAsync(value, _workingRoot, _currentStorageFolder));
                 if (res)
                 {
                     _currentStorageFolder = res.Result;
@@ -125,22 +125,22 @@ public async Task<FilesystemResult> SetWorkingDirectoryAsync(string value)
 
         public async Task<FilesystemResult<StorageFolder>> GetFolderFromPathAsync(string value)
         {
-            return await StorageFileExtensions.DangerousGetFolderFromPathAsync(value, _workingRoot, _currentStorageFolder).Wrap();
+            return await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFolderFromPathAsync(value, _workingRoot, _currentStorageFolder));
         }
 
         public async Task<FilesystemResult<StorageFile>> GetFileFromPathAsync(string value)
         {
-            return await StorageFileExtensions.DangerousGetFileFromPathAsync(value, _workingRoot, _currentStorageFolder).Wrap();
+            return await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFileFromPathAsync(value, _workingRoot, _currentStorageFolder));
         }
 
         public async Task<FilesystemResult<StorageFolderWithPath>> GetFolderWithPathFromPathAsync(string value)
         {
-            return await StorageFileExtensions.DangerousGetFolderWithPathFromPathAsync(value, _workingRoot, _currentStorageFolder).Wrap();
+            return await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFolderWithPathFromPathAsync(value, _workingRoot, _currentStorageFolder));
         }
 
         public async Task<FilesystemResult<StorageFileWithPath>> GetFileWithPathFromPathAsync(string value)
         {
-            return await StorageFileExtensions.DangerousGetFileWithPathFromPathAsync(value, _workingRoot, _currentStorageFolder).Wrap();
+            return await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFileWithPathFromPathAsync(value, _workingRoot, _currentStorageFolder));
         }
 
         private bool _IsFolderEmptyTextDisplayed;
@@ -795,7 +795,7 @@ public async Task<bool> EnumerateItemsFromStandardFolderAsync(string path)
             // Flag to use FindFirstFileExFromApp or StorageFolder enumeration
             bool enumFromStorageFolder = false;
 
-            var res = await StorageFolder.GetFolderFromPathAsync(path).AsTask().Wrap();
+            var res = await FilesystemTasks.Wrap(() => StorageFolder.GetFolderFromPathAsync(path).AsTask());
             if (res)
             {
                 _rootFolder = res.Result;
diff --git a/Files/View Models/Properties/FileProperties.cs b/Files/View Models/Properties/FileProperties.cs
@@ -422,7 +422,7 @@ private async Task SavePropertiesAsync(StorageFile file)
             {
                 var newDict = new Dictionary<string, object>();
                 newDict.Add(valuePair.Key, valuePair.Value);
-                var res = await file.Properties.SavePropertiesAsync(newDict).AsTask().Wrap();
+                var res = await FilesystemTasks.Wrap(() => file.Properties.SavePropertiesAsync(newDict).AsTask());
                 if (!res)
                 {
                     Debug.WriteLine(string.Format("{0}\n{1}", valuePair.Key, res.ErrorCode.ToString()));
@@ -444,7 +444,7 @@ public async Task ClearPersonalInformationAsync()
                 foreach (string str in PersonalProperties)
                     dict.Add(str, null);
 
-                await file.Properties.SavePropertiesAsync(dict).AsTask().Wrap();
+                await FilesystemTasks.Wrap(() => file.Properties.SavePropertiesAsync(dict).AsTask());
 
                 GetSpecialProperties();
             }
diff --git a/Files/View Models/SettingsViewModel.cs b/Files/View Models/SettingsViewModel.cs
@@ -265,7 +265,7 @@ private async void DetectOneDrivePreference()
                 PinOneDriveToSideBar = false;
             }
 
-            if (!await StorageFolder.GetFolderFromPathAsync(OneDrivePath).AsTask().Wrap())
+            if (!await FilesystemTasks.Wrap(() => StorageFolder.GetFolderFromPathAsync(OneDrivePath).AsTask()))
             {
                 PinOneDriveToSideBar = false;
             }
diff --git a/Files/Views/ModernShellPage.xaml.cs b/Files/Views/ModernShellPage.xaml.cs
@@ -453,17 +453,17 @@ public async void CheckPathInput(ItemViewModel instance, string currentInput, st
 
                     currentInput = StorageFileExtensions.GetPathWithoutEnvironmentVariable(currentInput);
                     if (currentSelectedPath == currentInput) return;
-                    var item = await DrivesManager.GetRootFromPathAsync(currentInput).Wrap();
+                    var item = await FilesystemTasks.Wrap(() => DrivesManager.GetRootFromPathAsync(currentInput));
 
-                    var resFolder = await StorageFileExtensions.DangerousGetFolderWithPathFromPathAsync(currentInput, item).Wrap();
+                    var resFolder = await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFolderWithPathFromPathAsync(currentInput, item));
                     if (resFolder)
                     {
                         var pathToNavigate = resFolder.Result.Path;
                         ContentFrame.Navigate(AppSettings.GetLayoutType(), new NavigationArguments() { NavPathParam = pathToNavigate, AssociatedTabInstance = this }); // navigate to folder
                     }
                     else // Not a folder or inaccessible
                     {
-                        var resFile = await StorageFileExtensions.DangerousGetFileWithPathFromPathAsync(currentInput, item).Wrap();
+                        var resFile = await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFileWithPathFromPathAsync(currentInput, item));
                         if (resFile)
                         {
                             var pathToInvoke = resFile.Result.Path;
diff --git a/Files/Views/SettingsPages/Preferences.xaml.cs b/Files/Views/SettingsPages/Preferences.xaml.cs
@@ -23,7 +23,7 @@ public Preferences()
 
         private async void TryGetOneDriveFolder()
         {
-            if (!await StorageFolder.GetFolderFromPathAsync(AppSettings.OneDrivePath).AsTask().Wrap())
+            if (!await FilesystemTasks.Wrap(() => StorageFolder.GetFolderFromPathAsync(AppSettings.OneDrivePath).AsTask()))
             {
                 AppSettings.PinOneDriveToSideBar = false;
                 OneDrivePin.IsEnabled = false;

Original file line number	Diff line number	Diff line change
`@@ -138,7 +138,7 @@ await AppInstance.FilesystemViewModel.GetFolderFromPathAsync(destinationPath)`
`138`	`138`	`if (res)`
`139`	`139`	`{`
`140`	`140`	`StorageFile clipboardFile = (StorageFile)item;`
`141`		`- var pasted = await clipboardFile.CopyAsync(res.Result, item.Name, NameCollisionOption.GenerateUniqueName).AsTask().Wrap();`
	`141`	`+ var pasted = await FilesystemTasks.Wrap(() => clipboardFile.CopyAsync(res.Result, item.Name, NameCollisionOption.GenerateUniqueName).AsTask());`
`142`	`142`	`if (pasted)`
`143`	`143`	`{`
`144`	`144`	`pastedSourceItems.Add(item);`
Original file line number	Diff line number	Diff line change
`@@ -181,8 +181,8 @@ public int IndexOfItem(INavigationControlItem locationItem, List<INavigationCont`
`181`	`181`	`/// <returns>Task</returns>`
`182`	`182`	`public async Task AddItemToSidebarAsync(string path)`
`183`	`183`	`{`
`184`		`- var item = await DrivesManager.GetRootFromPathAsync(path).Wrap();`
`185`		`- var res = await StorageFileExtensions.DangerousGetFolderFromPathAsync(path, item).Wrap();`
	`184`	`+ var item = await FilesystemTasks.Wrap(() => DrivesManager.GetRootFromPathAsync(path));`
	`185`	`+ var res = await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFolderFromPathAsync(path, item));`
`186`	`186`	`if (res)`
`187`	`187`	`{`
`188`	`188`	`int insertIndex = MainPage.sideBarItems.IndexOf(MainPage.sideBarItems.Last(x => x.ItemType == NavigationControlItemType.Location`
Original file line number	Diff line number	Diff line change
`@@ -244,7 +244,7 @@ private async Task<bool> GetDrivesAsync(IList<DriveItem> list)`
`244`	`244`	`continue;`
`245`	`245`	`}`
`246`	`246`
`247`		`- var res = await StorageFolder.GetFolderFromPathAsync(drive.Name).AsTask().Wrap();`
	`247`	`+ var res = await FilesystemTasks.Wrap(() => StorageFolder.GetFolderFromPathAsync(drive.Name).AsTask());`
`248`	`248`	`if (res == FilesystemErrorCode.ERROR_UNAUTHORIZED)`
`249`	`249`	`{`
`250`	`250`	`unauthorizedAccessDetected = true;`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ public static explicit operator FilesystemResult(bool res) =>`
`60`	`60`	`new FilesystemResult(res ? FilesystemErrorCode.ERROR_OK : FilesystemErrorCode.ERROR_GENERIC);`
`61`	`61`	`}`
`62`	`62`
`63`		`- public static class TaskExtensions`
	`63`	`+ public static class FilesystemTasks`
`64`	`64`	`{`
`65`	`65`	`private static FilesystemErrorCode GetErrorCode(Exception ex, Type T = null)`
`66`	`66`	`{`
`@@ -103,23 +103,23 @@ private static FilesystemErrorCode GetErrorCode(Exception ex, Type T = null)`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`
`106`		`- public async static Task<FilesystemResult<T>> Wrap<T>(this Task<T> wrapped)`
	`106`	`+ public async static Task<FilesystemResult<T>> Wrap<T>(Func<Task<T>> wrapped)`
`107`	`107`	`{`
`108`	`108`	`try`
`109`	`109`	`{`
`110`		`- return new FilesystemResult<T>(await wrapped, FilesystemErrorCode.ERROR_OK);`
	`110`	`+ return new FilesystemResult<T>(await wrapped(), FilesystemErrorCode.ERROR_OK);`
`111`	`111`	`}`
`112`	`112`	`catch (Exception ex)`
`113`	`113`	`{`
`114`	`114`	`return new FilesystemResult<T>(default(T), GetErrorCode(ex, typeof(T)));`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`
`118`		`- public async static Task<FilesystemResult> Wrap(this Task wrapped)`
	`118`	`+ public async static Task<FilesystemResult> Wrap(Func<Task> wrapped)`
`119`	`119`	`{`
`120`	`120`	`try`
`121`	`121`	`{`
`122`		`- await wrapped;`
	`122`	`+ await wrapped();`
`123`	`123`	`return new FilesystemResult(FilesystemErrorCode.ERROR_OK);`
`124`	`124`	`}`
`125`	`125`	`catch (Exception ex)`
`@@ -133,7 +133,7 @@ public async static Task<FilesystemResult<T>> OnSuccess<T>(this Task<FilesystemR`
`133`	`133`	`var res = await wrapped;`
`134`	`134`	`if (res)`
`135`	`135`	`{`
`136`		`- return await func(res.Result).Wrap();`
	`136`	`+ return await Wrap(() => func(res.Result));`
`137`	`137`	`}`
`138`	`138`	`return res;`
`139`	`139`	`}`
`@@ -143,7 +143,7 @@ public async static Task<FilesystemResult> OnSuccess<T>(this Task<FilesystemResu`
`143`	`143`	`var res = await wrapped;`
`144`	`144`	`if (res)`
`145`	`145`	`{`
`146`		`- return await func(res.Result).Wrap();`
	`146`	`+ return await Wrap(() => func(res.Result));`
`147`	`147`	`}`
`148`	`148`	`return res;`
`149`	`149`	`}`
Original file line number	Diff line number	Diff line change
`@@ -91,12 +91,12 @@ public async Task<FilesystemResult> SetWorkingDirectoryAsync(string value)`
`91`	`91`	`}`
`92`	`92`	`else if (!Path.IsPathRooted(WorkingDirectory) \|\| Path.GetPathRoot(WorkingDirectory) != Path.GetPathRoot(value))`
`93`	`93`	`{`
`94`		`- _workingRoot = await DrivesManager.GetRootFromPathAsync(value).Wrap();`
	`94`	`+ _workingRoot = await FilesystemTasks.Wrap(() => DrivesManager.GetRootFromPathAsync(value));`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`if (Path.IsPathRooted(value))`
`98`	`98`	`{`
`99`		`- var res = await StorageFileExtensions.DangerousGetFolderWithPathFromPathAsync(value, _workingRoot, _currentStorageFolder).Wrap();`
	`99`	`+ var res = await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFolderWithPathFromPathAsync(value, _workingRoot, _currentStorageFolder));`
`100`	`100`	`if (res)`
`101`	`101`	`{`
`102`	`102`	`_currentStorageFolder = res.Result;`
`@@ -125,22 +125,22 @@ public async Task<FilesystemResult> SetWorkingDirectoryAsync(string value)`
`125`	`125`
`126`	`126`	`public async Task<FilesystemResult<StorageFolder>> GetFolderFromPathAsync(string value)`
`127`	`127`	`{`
`128`		`- return await StorageFileExtensions.DangerousGetFolderFromPathAsync(value, _workingRoot, _currentStorageFolder).Wrap();`
	`128`	`+ return await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFolderFromPathAsync(value, _workingRoot, _currentStorageFolder));`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`public async Task<FilesystemResult<StorageFile>> GetFileFromPathAsync(string value)`
`132`	`132`	`{`
`133`		`- return await StorageFileExtensions.DangerousGetFileFromPathAsync(value, _workingRoot, _currentStorageFolder).Wrap();`
	`133`	`+ return await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFileFromPathAsync(value, _workingRoot, _currentStorageFolder));`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`public async Task<FilesystemResult<StorageFolderWithPath>> GetFolderWithPathFromPathAsync(string value)`
`137`	`137`	`{`
`138`		`- return await StorageFileExtensions.DangerousGetFolderWithPathFromPathAsync(value, _workingRoot, _currentStorageFolder).Wrap();`
	`138`	`+ return await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFolderWithPathFromPathAsync(value, _workingRoot, _currentStorageFolder));`
`139`	`139`	`}`
`140`	`140`
`141`	`141`	`public async Task<FilesystemResult<StorageFileWithPath>> GetFileWithPathFromPathAsync(string value)`
`142`	`142`	`{`
`143`		`- return await StorageFileExtensions.DangerousGetFileWithPathFromPathAsync(value, _workingRoot, _currentStorageFolder).Wrap();`
	`143`	`+ return await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFileWithPathFromPathAsync(value, _workingRoot, _currentStorageFolder));`
`144`	`144`	`}`
`145`	`145`
`146`	`146`	`private bool _IsFolderEmptyTextDisplayed;`
`@@ -795,7 +795,7 @@ public async Task<bool> EnumerateItemsFromStandardFolderAsync(string path)`
`795`	`795`	`// Flag to use FindFirstFileExFromApp or StorageFolder enumeration`
`796`	`796`	`bool enumFromStorageFolder = false;`
`797`	`797`
`798`		`- var res = await StorageFolder.GetFolderFromPathAsync(path).AsTask().Wrap();`
	`798`	`+ var res = await FilesystemTasks.Wrap(() => StorageFolder.GetFolderFromPathAsync(path).AsTask());`
`799`	`799`	`if (res)`
`800`	`800`	`{`
`801`	`801`	`_rootFolder = res.Result;`
Original file line number	Diff line number	Diff line change
`@@ -422,7 +422,7 @@ private async Task SavePropertiesAsync(StorageFile file)`
`422`	`422`	`{`
`423`	`423`	`var newDict = new Dictionary<string, object>();`
`424`	`424`	`newDict.Add(valuePair.Key, valuePair.Value);`
`425`		`- var res = await file.Properties.SavePropertiesAsync(newDict).AsTask().Wrap();`
	`425`	`+ var res = await FilesystemTasks.Wrap(() => file.Properties.SavePropertiesAsync(newDict).AsTask());`
`426`	`426`	`if (!res)`
`427`	`427`	`{`
`428`	`428`	`Debug.WriteLine(string.Format("{0}\n{1}", valuePair.Key, res.ErrorCode.ToString()));`
`@@ -444,7 +444,7 @@ public async Task ClearPersonalInformationAsync()`
`444`	`444`	`foreach (string str in PersonalProperties)`
`445`	`445`	`dict.Add(str, null);`
`446`	`446`
`447`		`- await file.Properties.SavePropertiesAsync(dict).AsTask().Wrap();`
	`447`	`+ await FilesystemTasks.Wrap(() => file.Properties.SavePropertiesAsync(dict).AsTask());`
`448`	`448`
`449`	`449`	`GetSpecialProperties();`
`450`	`450`	`}`
Original file line number	Diff line number	Diff line change
`@@ -265,7 +265,7 @@ private async void DetectOneDrivePreference()`
`265`	`265`	`PinOneDriveToSideBar = false;`
`266`	`266`	`}`
`267`	`267`
`268`		`- if (!await StorageFolder.GetFolderFromPathAsync(OneDrivePath).AsTask().Wrap())`
	`268`	`+ if (!await FilesystemTasks.Wrap(() => StorageFolder.GetFolderFromPathAsync(OneDrivePath).AsTask()))`
`269`	`269`	`{`
`270`	`270`	`PinOneDriveToSideBar = false;`
`271`	`271`	`}`
Original file line number	Diff line number	Diff line change
`@@ -453,17 +453,17 @@ public async void CheckPathInput(ItemViewModel instance, string currentInput, st`
`453`	`453`
`454`	`454`	`currentInput = StorageFileExtensions.GetPathWithoutEnvironmentVariable(currentInput);`
`455`	`455`	`if (currentSelectedPath == currentInput) return;`
`456`		`- var item = await DrivesManager.GetRootFromPathAsync(currentInput).Wrap();`
	`456`	`+ var item = await FilesystemTasks.Wrap(() => DrivesManager.GetRootFromPathAsync(currentInput));`
`457`	`457`
`458`		`- var resFolder = await StorageFileExtensions.DangerousGetFolderWithPathFromPathAsync(currentInput, item).Wrap();`
	`458`	`+ var resFolder = await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFolderWithPathFromPathAsync(currentInput, item));`
`459`	`459`	`if (resFolder)`
`460`	`460`	`{`
`461`	`461`	`var pathToNavigate = resFolder.Result.Path;`
`462`	`462`	`ContentFrame.Navigate(AppSettings.GetLayoutType(), new NavigationArguments() { NavPathParam = pathToNavigate, AssociatedTabInstance = this }); // navigate to folder`
`463`	`463`	`}`
`464`	`464`	`else // Not a folder or inaccessible`
`465`	`465`	`{`
`466`		`- var resFile = await StorageFileExtensions.DangerousGetFileWithPathFromPathAsync(currentInput, item).Wrap();`
	`466`	`+ var resFile = await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFileWithPathFromPathAsync(currentInput, item));`
`467`	`467`	`if (resFile)`
`468`	`468`	`{`
`469`	`469`	`var pathToInvoke = resFile.Result.Path;`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ public Preferences()`
`23`	`23`
`24`	`24`	`private async void TryGetOneDriveFolder()`
`25`	`25`	`{`
`26`		`- if (!await StorageFolder.GetFolderFromPathAsync(AppSettings.OneDrivePath).AsTask().Wrap())`
	`26`	`+ if (!await FilesystemTasks.Wrap(() => StorageFolder.GetFolderFromPathAsync(AppSettings.OneDrivePath).AsTask()))`
`27`	`27`	`{`
`28`	`28`	`AppSettings.PinOneDriveToSideBar = false;`
`29`	`29`	`OneDrivePin.IsEnabled = false;`