Support dynamic UI updates while counting

Author: luanshixia

SharpDiskSweeper/DiskSweeper/DiskItem.cs

@@ -28,11 +28,11 @@ public class DiskItem : INotifyPropertyChanged
 
         public string SizeString => this.IsCalculationDone
             ? DiskItem.FormatSize(this.Size)
-            : "(...)";
+            : "..." + DiskItem.FormatSize(this.Size);
 
         public string SizeOnDiskString => this.IsCalculationDone
             ? DiskItem.FormatSize(this.SizeOnDisk)
-            : "(...)";
+            : "..." + DiskItem.FormatSize(this.SizeOnDisk);
 
         public event PropertyChangedEventHandler PropertyChanged;
 
@@ -74,10 +74,20 @@ public async Task Start(CancellationToken cancellationToken)
                 return;
             }
 
-            (this.Size, this.SizeOnDisk, this.FilesCount, this.FoldersCount) = await Task.Run(() => SweepEngine
-                .CalculateDirectorySizeRecursivelyAsync(this.DirInfo, cancellationToken));
+            var engine = new SweepEngine(this.DirInfo);
+            engine.ReportProgress += (sender, e) => this.ReportChanges(engine);
+
+            await Task.Run(() => engine
+                .CalculateDirectorySizeRecursivelyWithUpdateAsync(this.DirInfo, cancellationToken));
 
             this.IsCalculationDone = true;
+            this.ReportChanges(engine);
+        }
+
+        private void ReportChanges(SweepEngine engine)
+        {
+            (this.Size, this.SizeOnDisk, this.FilesCount, this.FoldersCount) = engine.Result;
+
             this.NotifyPropertyChanged(nameof(this.Size));
             this.NotifyPropertyChanged(nameof(this.SizeString));
             this.NotifyPropertyChanged(nameof(this.SizeOnDisk));

SharpDiskSweeper/DiskSweeper/SweepEngine.cs

@@ -13,6 +13,18 @@ namespace DiskSweeper
     public class SweepEngine
     {
         private readonly DirectoryInfo Directory;
+        private const int ProgressReportInterval = 200;
+
+        private long TotalSize;
+        private long TotalSizeOnDisk;
+        private long TotalFilesCount;
+        private long TotalFoldersCount;
+
+        private long ChangesCount;
+
+        public event EventHandler ReportProgress;
+
+        public (long, long, long, long) Result => (this.TotalSize, this.TotalSizeOnDisk, this.TotalFilesCount, this.TotalFoldersCount);
 
         public static long P0SizeFloor => ConfigurationHelper.GetConfigurationInt64(
             settingName: "DiskSweeper.Highlights.P0.SizeFloor",
@@ -27,6 +39,11 @@ public SweepEngine(string path)
             this.Directory = new DirectoryInfo(path);
         }
 
+        public SweepEngine(DirectoryInfo dir)
+        {
+            this.Directory = dir;
+        }
+
         public ObservableCollection<DiskItem> GetDiskItems()
         {
             return new ObservableCollection<DiskItem>(
@@ -35,33 +52,27 @@ public ObservableCollection<DiskItem> GetDiskItems()
                     .Select(info => new DiskItem(info)));
         }
 
-        public static async Task<(long, long, long, long)> CalculateDirectorySizeRecursivelyAsync(DirectoryInfo directory, CancellationToken cancellationToken)
+        public async Task CalculateDirectorySizeRecursivelyWithUpdateAsync(DirectoryInfo directory, CancellationToken cancellationToken)
         {
-            var totalSize = 0L;
-            var totalSizeOnDisk = 0L;
-            var totalFilesCount = 0L;
-            var totalFoldersCount = 0L;
-
             try
             {
                 foreach (var childDirectory in directory.GetDirectories())
                 {
-                    var (size, sizeOnDisk, filesCount, foldersCount) = await SweepEngine.CalculateDirectorySizeRecursivelyAsync(childDirectory, cancellationToken);
-                    totalSize += size;
-                    totalSizeOnDisk += sizeOnDisk;
-                    totalFilesCount += filesCount;
-                    totalFoldersCount += foldersCount;
+                    await this.CalculateDirectorySizeRecursivelyWithUpdateAsync(childDirectory, cancellationToken);
 
                     if (cancellationToken.IsCancellationRequested)
                     {
                         break;
                     }
                 }
 
-                totalSize += directory.GetFiles().Sum(file => file.Length);
-                //totalSizeOnDisk += directory.GetFiles().Sum(file => file.GetSizeOnDisk());
-                totalFilesCount += directory.GetFiles().Count();
-                totalFoldersCount += 1;
+                var files = directory.GetFiles();
+                this.TotalSize += files.Sum(file => file.Length);
+                //this.TotalSizeOnDisk += files.Sum(file => file.GetSizeOnDisk());
+                this.TotalFilesCount += files.Count();
+                this.TotalFoldersCount += 1;
+
+                this.CountChanges();
             }
             catch (UnauthorizedAccessException ex)
             {
@@ -71,8 +82,15 @@ public ObservableCollection<DiskItem> GetDiskItems()
             {
                 Trace.WriteLine(ex.Message);
             }
+        }
 
-            return (totalSize, totalSizeOnDisk, totalFilesCount, totalFoldersCount);
+        private void CountChanges()
+        {
+            this.ChangesCount++;
+            if (this.ChangesCount % SweepEngine.ProgressReportInterval == 0)
+            {
+                this.ReportProgress?.Invoke(this, null);
+            }
         }
     }
 }