Changeset 2410 for trunk/sources/HeuristicLab.BackgroundProcessing

Timestamp:

10/05/09 17:24:38 (15 years ago)

Author:

epitzer

Message:

make CancelAll asynchronous, add support for several worker monitors. (#769)

Location:

trunk/sources/HeuristicLab.BackgroundProcessing/3.2

Files:

• ObservableBackgroundWorker.cs (modified) (1 diff)
• ObservableEnumerable.cs (modified) (1 diff)
• WorkerMonitor.cs (modified) (3 diffs)

trunk/sources/HeuristicLab.BackgroundProcessing/3.2/ObservableBackgroundWorker.cs

@@ -37 +37 @@
     public event PropertyChangedEventHandler PropertyChanged;
 
-    public ObservableBackgroundWorker(string name) {
+    public ObservableBackgroundWorker(string name, WorkerMonitor monitor) {
       Name = name;
-      WorkerMonitor.Default.RegisterWorker(this);
+      monitor.RegisterWorker(this);
       IsRunning = false;
     }
+
+    public ObservableBackgroundWorker(string name) : this(name, WorkerMonitor.Default) { }
 
     protected override void OnProgressChanged(ProgressChangedEventArgs e) {

trunk/sources/HeuristicLab.BackgroundProcessing/3.2/ObservableEnumerable.cs

@@ -10 +10 @@
   /// </summary>
   /// <typeparam name="T"></typeparam>
-  public interface ObservableEnumerable<T> : IEnumerable<T>, INotifyCollectionChanged where T : class { }
+  public interface IObservableEnumerable<T> : IEnumerable<T>, INotifyCollectionChanged { }
 }

trunk/sources/HeuristicLab.BackgroundProcessing/3.2/WorkerMonitor.cs

@@ -13 +13 @@
   /// Provides a list of all currently running or pending ObservableBackgroundWorkers.
   /// </summary>
-  public class WorkerMonitor : ObservableEnumerable<ObservableBackgroundWorker> {
+  public class WorkerMonitor : IObservableEnumerable<ObservableBackgroundWorker> {
+
     public static WorkerMonitor Default = new WorkerMonitor();
 
-    public event ThreadExceptionEventHandler ThreadException;
+    /// <summary>
+    /// Report all unhandled exceptions during background worker execution.
+    /// These exceptions are the same as reported by the RunWorkerCompleted but wrapped
+    /// in an additional exception containing the worker name as message and the original
+    /// exception as inner exception.
+    /// </summary>
+    public event ThreadExceptionEventHandler BackgroundWorkerException;
     public event NotifyCollectionChangedEventHandler CollectionChanged;
 
@@ -72 +79 @@
 
     protected void OnThreadException(Exception x) {
-      if (ThreadException != null)
-        ThreadException(this, new ThreadExceptionEventArgs(x));
+      if (BackgroundWorkerException != null)
+        BackgroundWorkerException(this, new ThreadExceptionEventArgs(x));
     }
 
@@ -95 +102 @@
     }
 
-    public void CancelAll() {
-      List<ObservableBackgroundWorker> cancelableWorkers = GetCancelableWorkers();
-      lock (cancelableWorkers) {
-        foreach (var worker in cancelableWorkers.ToList()) {
-          worker.WorkerStopped += (sender, args) => {
-            lock (cancelableWorkers) {
-              cancelableWorkers.Remove((ObservableBackgroundWorker)sender);
-              Monitor.Pulse(cancelableWorkers);
-            }
-          };
-          worker.CancelAsync();
-          if (!worker.IsRunning)
-            cancelableWorkers.Remove(worker);
+    public void CancelAllAsync() {
+      CancelAllAsync(null, null);
+    }
+
+    public void CancelAllAsync(WaitCallback callback, object state) {
+      ThreadPool.QueueUserWorkItem(_ => {
+        List<ObservableBackgroundWorker> cancelableWorkers = GetCancelableWorkers();
+        lock (cancelableWorkers) {
+          foreach (var worker in cancelableWorkers.ToList()) {
+            worker.WorkerStopped += (sender, args) => {
+              lock (cancelableWorkers) {
+                cancelableWorkers.Remove((ObservableBackgroundWorker)sender);
+                Monitor.Pulse(cancelableWorkers);
+              }
+            };
+            worker.CancelAsync();
+            if (!worker.IsRunning)
+              cancelableWorkers.Remove(worker);
+          }
+          while (cancelableWorkers.Count > 0)
+            Monitor.Wait(cancelableWorkers);
         }
-        while (cancelableWorkers.Count > 0)
-          Monitor.Wait(cancelableWorkers);
-      }
+        if (callback != null)
+          callback(state);
+      });
     }