Improve UI responsiveness for file operations with many items

src/Files/DataModels/FilesystemItemsOperationDataModel.cs

@@ -58,7 +58,7 @@ public FilesystemItemsOperationDataModel(FilesystemOperationType operationType,
         public List<FilesystemOperationItemViewModel> ToItems(Action updatePrimaryButtonEnabled, Action optionGenerateNewName, Action optionReplaceExisting, Action optionSkip)
         {
             List<FilesystemOperationItemViewModel> items = new List<FilesystemOperationItemViewModel>();
-            List<FilesystemItemsOperationItemModel> nonConflictingItems = IncomingItems.Except(ConflictingItems).ToList();
+            IEnumerable<FilesystemItemsOperationItemModel> nonConflictingItems = IncomingItems.Except(ConflictingItems);
 
             // Add conflicting items first
             items.AddRange(ConflictingItems.Select((item, index) =>

src/Files/Extensions/EnumerableExtensions.cs

@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using System.Threading.Tasks.Dataflow;
 
@@ -19,6 +21,24 @@ internal static IEnumerable<T> CreateEnumerable<T>(this T item) =>
         internal static List<T> CreateList<T>(this T item) =>
             new List<T>() { item };
 
+        public static IList<T> AddIfNotPresent<T>(this IList<T> list, T element)
+        {
+            if (!list.Contains(element))
+            {
+                list.Add(element);
+            }
+            return list;
+        }
+
+        public static IDictionary<TKey, TValue> AddIfNotPresent<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, TValue value)
+        {
+            if (!dictionary.ContainsKey(key))
+            {
+                dictionary.Add(key, value);
+            }
+            return dictionary;
+        }
+
         /// <summary>
         /// Executes given lambda parallelly on given data set with max degree of parallelism set up
         /// </summary>
@@ -27,38 +47,45 @@ internal static List<T> CreateList<T>(this T item) =>
         /// <param name="body">Lambda to execute on all items</param>
         /// <param name="maxDegreeOfParallelism">Max degree of parallelism (-1 for unbounded execution)</param>
         /// <returns></returns>
-        internal static Task AsyncParallelForEach<T>(this IEnumerable<T> source, Func<T, Task> body, int maxDegreeOfParallelism)
+        /// <param name="cts">Cancellation token, stops all remaining operations</param>
+        /// <param name="scheduler">Task scheduler on which to execute `body`</param>
+        /// <returns></returns>
+        public static async Task ParallelForEach<T>(this IEnumerable<T> source, Func<T, Task> body, int maxDegreeOfParallelism = DataflowBlockOptions.Unbounded, CancellationToken cts = default, TaskScheduler scheduler = null)
         {
             var options = new ExecutionDataflowBlockOptions
             {
-                MaxDegreeOfParallelism = maxDegreeOfParallelism
+                MaxDegreeOfParallelism = maxDegreeOfParallelism,
+                CancellationToken = cts
             };
+            if (scheduler != null)
+                options.TaskScheduler = scheduler;
 
             var block = new ActionBlock<T>(body, options);
 
             foreach (var item in source)
                 block.Post(item);
 
             block.Complete();
-            return block.Completion;
+            await block.Completion;
         }
 
-        public static IList<T> AddIfNotPresent<T>(this IList<T> list, T element)
+        public static async Task<IList<T>> ToListAsync<T>(this IEnumerable<T> source)
         {
-            if (!list.Contains(element))
-            {
-                list.Add(element);
-            }
-            return list;
+            return await Task.Run(() => source.ToList());
         }
 
-        public static IDictionary<TKey, TValue> AddIfNotPresent<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, TValue value)
+        public static IEnumerable<TResult> Zip<T1, T2, TResult>(
+            this IEnumerable<T1> source,
+            IEnumerable<T2> second,
+            Func<T1, T2, int, TResult> func)
         {
-            if (!dictionary.ContainsKey(key))
+            using (var e1 = source.GetEnumerator())
+            using (var e2 = second.GetEnumerator())
             {
-                dictionary.Add(key, value);
+                var index = 0;
+                while (e1.MoveNext() && e2.MoveNext())
+                    yield return func(e1.Current, e2.Current, index++);
             }
-            return dictionary;
         }
     }
 }

src/Files/Filesystem/FilesystemOperations/Helpers/IFilesystemHelpers.cs

@@ -62,14 +62,45 @@ public interface IFilesystemHelpers : IDisposable
 
         #endregion Delete
 
+        #region Restore
+
+        /// <summary>
+        /// Restores <paramref name="source"/> from the RecycleBin to <paramref name="destination"/> fullPath
+        /// </summary>
+        /// <param name="source">The source Recycle Bin item path</param>
+        /// <param name="destination">The destination fullPath to restore to</param>
+        /// <param name="registerHistory">Determines whether <see cref="IStorageHistory"/> is saved</param>
+        /// <returns><see cref="ReturnResult"/> of performed operation</returns>
+        Task<ReturnResult> RestoreItemFromTrashAsync(IStorageItem source, string destination, bool registerHistory);
+
+        /// <summary>
+        /// Restores <paramref name="source"/> from the RecycleBin to <paramref name="destination"/> fullPath
+        /// </summary>
+        /// <param name="source">The source Recycle Bin item path</param>
+        /// <param name="destination">The destination fullPath to restore to</param>
+        /// <param name="registerHistory">Determines whether <see cref="IStorageHistory"/> is saved</param>
+        /// <returns><see cref="ReturnResult"/> of performed operation</returns>
+        Task<ReturnResult> RestoreItemsFromTrashAsync(IEnumerable<IStorageItem> source, IEnumerable<string> destination, bool registerHistory);
+
         /// <summary>
         /// Restores <paramref name="source"/> from the RecycleBin to <paramref name="destination"/> fullPath
         /// </summary>
         /// <param name="source">The source Recycle Bin item path</param>
         /// <param name="destination">The destination fullPath to restore to</param>
         /// <param name="registerHistory">Determines whether <see cref="IStorageHistory"/> is saved</param>
         /// <returns><see cref="ReturnResult"/> of performed operation</returns>
-        Task<ReturnResult> RestoreFromTrashAsync(IStorageItemWithPath source, string destination, bool registerHistory);
+        Task<ReturnResult> RestoreItemFromTrashAsync(IStorageItemWithPath source, string destination, bool registerHistory);
+
+        /// <summary>
+        /// Restores <paramref name="source"/> from the RecycleBin to <paramref name="destination"/> fullPath
+        /// </summary>
+        /// <param name="source">The source Recycle Bin item path</param>
+        /// <param name="destination">The destination fullPath to restore to</param>
+        /// <param name="registerHistory">Determines whether <see cref="IStorageHistory"/> is saved</param>
+        /// <returns><see cref="ReturnResult"/> of performed operation</returns>
+        Task<ReturnResult> RestoreItemsFromTrashAsync(IEnumerable<IStorageItemWithPath> source, IEnumerable<string> destination, bool registerHistory);
+
+        #endregion Restore
 
         /// <summary>
         /// Performs relevant operation based on <paramref name="operation"/>

src/Files/Filesystem/FilesystemOperations/IFilesystemOperations.cs

@@ -32,7 +32,7 @@ public interface IFilesystemOperations : IDisposable
         /// </returns>
         Task<(IStorageHistory, IStorageItem)> CreateAsync(IStorageItemWithPath source, IProgress<FileSystemStatusCode> errorCode, CancellationToken cancellationToken);
 
-        Task<IStorageHistory> CreateShortcutItemsAsync(IEnumerable<IStorageItemWithPath> source, IEnumerable<string> destination, IProgress<float> progress, IProgress<FileSystemStatusCode> errorCode, CancellationToken cancellationToken);
+        Task<IStorageHistory> CreateShortcutItemsAsync(IList<IStorageItemWithPath> source, IList<string> destination, IProgress<float> progress, IProgress<FileSystemStatusCode> errorCode, CancellationToken cancellationToken);
 
         /// <summary>
         /// Copies <paramref name="source"/> to <paramref name="destination"/> fullPath
@@ -81,19 +81,19 @@ Task<IStorageHistory> CopyAsync(IStorageItemWithPath source,
         /// <summary>
         /// Copies <paramref name="source"/> to <paramref name="destination"/> fullPath
         /// </summary>
-        Task<IStorageHistory> CopyItemsAsync(IEnumerable<IStorageItem> source,
-                                            IEnumerable<string> destination,
-                                            IEnumerable<FileNameConflictResolveOptionType> collisions,
+        Task<IStorageHistory> CopyItemsAsync(IList<IStorageItem> source,
+                                            IList<string> destination,
+                                            IList<FileNameConflictResolveOptionType> collisions,
                                             IProgress<float> progress,
                                             IProgress<FileSystemStatusCode> errorCode,
                                             CancellationToken cancellationToken);
 
         /// <summary>
         /// Copies <paramref name="source"/> to <paramref name="destination"/> fullPath
         /// </summary>
-        Task<IStorageHistory> CopyItemsAsync(IEnumerable<IStorageItemWithPath> source,
-                                            IEnumerable<string> destination,
-                                            IEnumerable<FileNameConflictResolveOptionType> collisions,
+        Task<IStorageHistory> CopyItemsAsync(IList<IStorageItemWithPath> source,
+                                            IList<string> destination,
+                                            IList<FileNameConflictResolveOptionType> collisions,
                                             IProgress<float> progress,
                                             IProgress<FileSystemStatusCode> errorCode,
                                             CancellationToken cancellationToken);
@@ -145,19 +145,19 @@ Task<IStorageHistory> MoveAsync(IStorageItemWithPath source,
         /// <summary>
         /// Moves <paramref name="source"/> to <paramref name="destination"/> fullPath
         /// </summary>
-        Task<IStorageHistory> MoveItemsAsync(IEnumerable<IStorageItem> source,
-                                            IEnumerable<string> destination,
-                                            IEnumerable<FileNameConflictResolveOptionType> collisions,
+        Task<IStorageHistory> MoveItemsAsync(IList<IStorageItem> source,
+                                            IList<string> destination,
+                                            IList<FileNameConflictResolveOptionType> collisions,
                                             IProgress<float> progress,
                                             IProgress<FileSystemStatusCode> errorCode,
                                             CancellationToken cancellationToken);
 
         /// <summary>
         /// Moves <paramref name="source"/> to <paramref name="destination"/> fullPath
         /// </summary>
-        Task<IStorageHistory> MoveItemsAsync(IEnumerable<IStorageItemWithPath> source,
-                                            IEnumerable<string> destination,
-                                            IEnumerable<FileNameConflictResolveOptionType> collisions,
+        Task<IStorageHistory> MoveItemsAsync(IList<IStorageItemWithPath> source,
+                                            IList<string> destination,
+                                            IList<FileNameConflictResolveOptionType> collisions,
                                             IProgress<float> progress,
                                             IProgress<FileSystemStatusCode> errorCode,
                                             CancellationToken cancellationToken);
@@ -214,7 +214,7 @@ Task<IStorageHistory> DeleteAsync(IStorageItemWithPath source,
         /// <summary>
         /// Deletes provided <paramref name="source"/>
         /// </summary>
-        Task<IStorageHistory> DeleteItemsAsync(IEnumerable<IStorageItem> source,
+        Task<IStorageHistory> DeleteItemsAsync(IList<IStorageItem> source,
                                             IProgress<float> progress,
                                             IProgress<FileSystemStatusCode> errorCode,
                                             bool permanently,
@@ -223,7 +223,7 @@ Task<IStorageHistory> DeleteItemsAsync(IEnumerable<IStorageItem> source,
         /// <summary>
         /// Deletes provided <paramref name="source"/>
         /// </summary>
-        Task<IStorageHistory> DeleteItemsAsync(IEnumerable<IStorageItemWithPath> source,
+        Task<IStorageHistory> DeleteItemsAsync(IList<IStorageItemWithPath> source,
                                             IProgress<float> progress,
                                             IProgress<FileSystemStatusCode> errorCode,
                                             bool permanently,
@@ -269,6 +269,66 @@ Task<IStorageHistory> RenameAsync(IStorageItemWithPath source,
                                           IProgress<FileSystemStatusCode> errorCode,
                                           CancellationToken cancellationToken);
 
+        /// <summary>
+        /// Restores <paramref name="source"/> from the RecycleBin to <paramref name="destination"/> fullPath
+        /// </summary>
+        /// <param name="source">The source Recycle Bin item path</param>
+        /// <param name="destination">The destination fullPath to restore to</param>
+        /// <param name="progress">Progress of the operation</param>
+        /// <param name="errorCode">Status of the operation</param>
+        /// <param name="cancellationToken">Can be cancelled with <see cref="CancellationToken"/></param>
+        /// <returns><see cref="IStorageHistory"/> where:
+        /// <br/>
+        /// Source: The trash item fullPath
+        /// <br/>
+        /// Destination: The <paramref name="destination"/> item fullPath (as <see cref="PathWithType"/>) the <paramref name="source"/> has been restored
+        /// </returns>
+        Task<IStorageHistory> RestoreItemsFromTrashAsync(IList<IStorageItem> source,
+                                                         IList<string> destination,
+                                                         IProgress<float> progress,
+                                                         IProgress<FileSystemStatusCode> errorCode,
+                                                         CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Restores <paramref name="source"/> from the RecycleBin to <paramref name="destination"/> fullPath
+        /// </summary>
+        /// <param name="source">The source Recycle Bin item path</param>
+        /// <param name="destination">The destination fullPath to restore to</param>
+        /// <param name="progress">Progress of the operation</param>
+        /// <param name="errorCode">Status of the operation</param>
+        /// <param name="cancellationToken">Can be cancelled with <see cref="CancellationToken"/></param>
+        /// <returns><see cref="IStorageHistory"/> where:
+        /// <br/>
+        /// Source: The trash item fullPath
+        /// <br/>
+        /// Destination: The <paramref name="destination"/> item fullPath (as <see cref="PathWithType"/>) the <paramref name="source"/> has been restored
+        /// </returns>
+        Task<IStorageHistory> RestoreFromTrashAsync(IStorageItem source,
+                                                    string destination,
+                                                    IProgress<float> progress,
+                                                    IProgress<FileSystemStatusCode> errorCode,
+                                                    CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Restores <paramref name="source"/> from the RecycleBin to <paramref name="destination"/> fullPath
+        /// </summary>
+        /// <param name="source">The source Recycle Bin item path</param>
+        /// <param name="destination">The destination fullPath to restore to</param>
+        /// <param name="progress">Progress of the operation</param>
+        /// <param name="errorCode">Status of the operation</param>
+        /// <param name="cancellationToken">Can be cancelled with <see cref="CancellationToken"/></param>
+        /// <returns><see cref="IStorageHistory"/> where:
+        /// <br/>
+        /// Source: The trash item fullPath
+        /// <br/>
+        /// Destination: The <paramref name="destination"/> item fullPath (as <see cref="PathWithType"/>) the <paramref name="source"/> has been restored
+        /// </returns>
+        Task<IStorageHistory> RestoreItemsFromTrashAsync(IList<IStorageItemWithPath> source,
+                                                         IList<string> destination,
+                                                         IProgress<float> progress,
+                                                         IProgress<FileSystemStatusCode> errorCode,
+                                                         CancellationToken cancellationToken);
+
         /// <summary>
         /// Restores <paramref name="source"/> from the RecycleBin to <paramref name="destination"/> fullPath
         /// </summary>