implab/ImplabNet Commit - r196:40d7fed4a09e

fixed promise chaining behavior, the error handler doesn't handle result or cancellation handlers exceptions these exceptions are propagated to the next handlers.

cin -

r196:40d7fed4a09e default

parent child

Context file:

r196:40d7fed4a09e

Collapse all files

Implab.Test/RunnableComponentTests.cs +2 -2

             using System;
             using System.Reflection;
             using System.Threading;
             using Implab.Parallels;
             using Implab.Components;
             #if MONO
             using NUnit.Framework;
             using TestClassAttribute = NUnit.Framework.TestFixtureAttribute;
             using TestMethodAttribute = NUnit.Framework.TestAttribute;
             using AssertFailedException = NUnit.Framework.AssertionException;
             #else
             using Microsoft.VisualStudio.TestTools.UnitTesting;
             #endif
             namespace Implab.Test {
                 [TestClass]
                 public class RunnableComponentTests {
                     static void ShouldThrow(Action action) {
                         try {
                             action();
                             Assert.Fail();
                         } catch (AssertFailedException) {
                             throw;
                         } catch {
                         }
                     }
                     class Runnable : RunnableComponent {
                         public Runnable(bool initialized) : base(initialized) {
                         }
                         public Action MockInit {
                             get;
                             set;
                         }
                         public Func<IPromise> MockStart {
                             get;
                             set;
                         }
                         public Func<IPromise> MockStop {
                             get;
                             set;
                         }
                         protected override IPromise OnStart() {
                             return MockStart != null ? MockStart() : base.OnStart();
                         }
                         protected override IPromise OnStop() {
                             return MockStop != null ? MockStop() : base.OnStart();
                         }
                         protected override void OnInitialize() {
                             if (MockInit != null)
                                 MockInit();
                         }
                     }
                     [TestMethod]
                     public void NormalFlowTest() {
                         var comp = new Runnable(false);
                         Assert.AreEqual(ExecutionState.Created, comp.State);
                         comp.Init();
                         Assert.AreEqual(ExecutionState.Ready, comp.State);
                         comp.Start().Join(1000);
                         Assert.AreEqual(ExecutionState.Running, comp.State);
                         comp.Stop().Join(1000);
                         Assert.AreEqual(ExecutionState.Disposed, comp.State);
                     }
                     [TestMethod]
                     public void InitFailTest() {
                         var comp = new Runnable(false) {
                             MockInit = () => {
                                 throw new Exception("BAD");
                             }
                         };
                         ShouldThrow(() => comp.Start());
                         ShouldThrow(() => comp.Stop());
                         Assert.AreEqual(ExecutionState.Created, comp.State);
                         ShouldThrow(comp.Init);
                         Assert.AreEqual(ExecutionState.Failed, comp.State);
                         ShouldThrow(() => comp.Start());
                         ShouldThrow(() => comp.Stop());
                         Assert.AreEqual(ExecutionState.Failed, comp.State);
                         comp.Dispose();
                         Assert.AreEqual(ExecutionState.Disposed, comp.State);
                     }
                     [TestMethod]
                     public void DisposedTest() {
                         var comp = new Runnable(false);
                         comp.Dispose();
                         ShouldThrow(() => comp.Start());
                         ShouldThrow(() => comp.Stop());
                         ShouldThrow(comp.Init);
                         Assert.AreEqual(ExecutionState.Disposed, comp.State);
                     }
                     [TestMethod]
                     public void StartCancelTest() {
                         var comp = new Runnable(true) {
                             MockStart = () => PromiseHelper.Sleep(100000, 0)
                         };
                         var p = comp.Start();
                         Assert.AreEqual(ExecutionState.Starting, comp.State);
                         p.Cancel();
                         ShouldThrow(() => p.Join(1000));
                         Assert.AreEqual(ExecutionState.Failed, comp.State);
-                        Assert.IsInstanceOfType(comp.LastError, typeof(OperationCanceledException));
+                        Assert.IsTrue(comp.LastError is OperationCanceledException);
                         comp.Dispose();
                     }
                     [TestMethod]
                     public void StartStopTest() {
                         var stop = new Signal();
                         var comp = new Runnable(true) {
                             MockStart = () => PromiseHelper.Sleep(100000, 0),
                             MockStop = () => AsyncPool.RunThread(stop.Wait)
                         };
                         var p1 = comp.Start();
                         var p2 = comp.Stop();
                         // should enter stopping state
                         ShouldThrow(p1.Join);
                         Assert.IsTrue(p1.IsCancelled);
                         Assert.AreEqual(ExecutionState.Stopping, comp.State);
                         stop.Set();
                         p2.Join(1000);
                         Assert.AreEqual(ExecutionState.Disposed, comp.State);
                     }
                     [TestMethod]
                     public void StartStopFailTest() {
                         var comp = new Runnable(true) {
                             MockStart = () => PromiseHelper.Sleep(100000, 0).Then(null,null,x => { throw new Exception("I'm dead"); })
                         };
                         comp.Start();
                         var p = comp.Stop();
                         // if Start fails to cancel, should fail to stop
                         ShouldThrow(() => p.Join(1000));
                         Assert.AreEqual(ExecutionState.Failed, comp.State);
                         Assert.IsNotNull(comp.LastError);
                         Assert.AreEqual("I'm dead", comp.LastError.Message);
                     }
                     [TestMethod]
                     public void StopCancelTest() {
                         var comp = new Runnable(true) {
                             MockStop = () => PromiseHelper.Sleep(100000, 0)
                         };
                         comp.Start();
                         var p = comp.Stop();
                         Assert.AreEqual(ExecutionState.Stopping, comp.State);
                         p.Cancel();
                         ShouldThrow(() => p.Join(1000));
                         Assert.AreEqual(ExecutionState.Failed, comp.State);
-                        Assert.IsInstanceOfType(comp.LastError, typeof(OperationCanceledException));
+                        Assert.IsTrue(comp.LastError is OperationCanceledException);
                         comp.Dispose();
                     }
                 }
             }

Implab/ActionChainTask.cs +1 -3

             using System;
             namespace Implab {
                 public class ActionChainTask : ActionChainTaskBase, IDeferred {
                     readonly Func<IPromise> m_task;
                     /// <summary>
                     /// Initializes a new instance of the <see cref="Implab.ActionChainTask"/> class.
                     /// </summary>
                     /// <param name="task">The operation which will be performed when the <see cref="Resolve()"/> is called.</param>
                     /// <param name="error">The error handler which will invoke when the <see cref="Reject(Exception)"/> is called or when the task fails with an error.</param>
                     /// <param name="cancel">The cancellation handler.</param>
                     /// <param name="autoCancellable">If set to <c>true</c> will automatically accept
                     ///  all cancel requests before the task is started with <see cref="Resolve()"/>,
                     /// after that all requests are directed to the task.</param>
                     public ActionChainTask(Func<IPromise> task, Func<Exception, IPromise> error, Func<Exception, IPromise> cancel, bool autoCancellable) : base(error,cancel, autoCancellable) {
                         m_task = task;
                     }
                     public void Resolve() {
                         if (m_task != null && LockCancelation()) {
                             try {
                                 var p = m_task();
                                 p.On(SetResult, HandleErrorInternal, HandleCancelInternal);
                                 CancellationRequested(p.Cancel);
-                            } catch (OperationCanceledException reason){
-                                HandleCancelInternal(reason);
                             } catch(Exception err) {
-                                HandleErrorInternal(err);
+                                SetErrorInternal(err);
                             }
                         }
                     }
                 }
             }

Implab/ActionChainTaskBase.cs +2 -2

             using System;
             using System.Threading;
             namespace Implab {
                 public class ActionChainTaskBase : AbstractTask {
                     readonly Func<Exception, IPromise> m_error;
                     readonly Func<Exception, IPromise> m_cancel;
                     protected ActionChainTaskBase(Func<Exception, IPromise> error, Func<Exception, IPromise> cancel, bool autoCancellable) {
                         m_error = error;
                         m_cancel = cancel;
                         if (autoCancellable)
                             CancellationRequested(CancelOperation);
                     }
                     public void Reject(Exception error) {
                         if (LockCancelation())
                             HandleErrorInternal(error);
                     }
                     public override void CancelOperation(Exception reason) {
                         if (LockCancelation())
                             // отмена вызвана до начала выполнения задачи
                             HandleCancelInternal(reason);
                     }
                     protected void HandleCancelInternal(Exception reason) {
                         if (m_cancel != null) {
                             try {
                                 // вызываем обработчик отмены
                                 var p = m_cancel(reason);
                                 p.On(SetResult, HandleErrorInternal, SetCancelledInternal);
                                 // сообщаем асинхронной операции, что клиент уже не хочет получать результат
                                 // т.е. если он инициировал отмену, задача отменилась, вызвался обрабочик отмены
                                 // отбработчику сообщили, что результат уже не нужен и уже сам обработчик решает
                                 // отдавать ли результат или подтвердить отмену (или вернуть ошибку).
                                 CancellationRequested(p.Cancel);
                             } catch (Exception err) {
-                                HandleErrorInternal(err);
+                                SetErrorInternal(err);
                             }
                         } else {
-                            HandleErrorInternal(reason ?? new OperationCanceledException());
+                            SetCancelledInternal(reason);
                         }
                     }
                     protected void HandleErrorInternal(Exception error) {
                         if (m_error != null) {
                             try {
                                 var p = m_error(error);
                                 p.On(SetResult, SetErrorInternal, SetCancelledInternal);
                                 CancellationRequested(p.Cancel);
                             } catch (Exception err) {
                                 SetErrorInternal(error);
                             }
                         } else {
                             SetErrorInternal(error);
                         }
                     }
                 }
             }

Implab/ActionChainTaskT.cs +1 -3

             using System;
             namespace Implab {
                 public class ActionChainTask<T> : ActionChainTaskBase, IDeferred<T> {
                     readonly Func<T, IPromise> m_task;
                     public ActionChainTask(Func<T, IPromise> task, Func<Exception, IPromise> error, Func<Exception, IPromise> cancel, bool autoCancellable) : base(error,cancel, autoCancellable) {
                         m_task = task;
                     }
                     public void Resolve(T value) {
                         if (m_task != null && LockCancelation()) {
                             try {
                                 var p = m_task(value);
                                 p.On(SetResult, HandleErrorInternal, HandleCancelInternal);
                                 CancellationRequested(p.Cancel);
-                            } catch (OperationCanceledException reason) {
-                                HandleCancelInternal(reason);
                             } catch(Exception err) {
-                                HandleErrorInternal(err);
+                                SetErrorInternal(err);
                             }
                         }
                     }
                 }
             }

Implab/ActionTask.cs +1 -3

             using System;
             namespace Implab {
                 public class ActionTask : ActionTaskBase, IDeferred {
                     readonly Action m_task;
                     public ActionTask(Action task, Action<Exception> error, Action<Exception> cancel, bool autoCancellable) : base(error,cancel, autoCancellable) {
                         m_task = task;
                     }
                     public void Resolve() {
                         if (m_task != null && LockCancelation()) {
                             try {
                                 m_task();
                                 SetResult();
-                            } catch(OperationCanceledException reason) {
-                                HandleCancelInternal(reason);
                             } catch(Exception err) {
-                                HandleErrorInternal(err);
+                                SetErrorInternal(err);
                             }
                         }
                     }
                 }
             }

Implab/ActionTaskBase.cs +2 -2

             using System;
             namespace Implab {
                 public class ActionTaskBase : AbstractTask {
                     readonly Action<Exception> m_cancel;
                     readonly Action<Exception> m_error;
                     protected ActionTaskBase( Action<Exception> error, Action<Exception> cancel, bool autoCancellable) {
                         m_error = error;
                         m_cancel = cancel;
                         if (autoCancellable)
                             CancellationRequested(CancelOperation);
                     }
                     public void Reject(Exception error) {
                         Safe.ArgumentNotNull(error, "error");
                         if (LockCancelation())
                             HandleErrorInternal(error);
                     }
                     public override void CancelOperation(Exception reason) {
                         if (LockCancelation())
                             HandleCancelInternal(reason);
                     }
                     protected void HandleErrorInternal(Exception error) {
                         if (m_error != null) {
                             try {
                                 m_error(error);
                                 SetResult();
                             } catch(Exception err) {
                                 SetErrorInternal(err);
                             }
                         } else {
                             SetErrorInternal(error);
                         }
                     }
                     protected void HandleCancelInternal(Exception error) {
                         if (m_cancel != null) {
                             try {
                                 m_cancel(error);
                                 SetResult();
                             } catch(Exception err) {
-                                HandleErrorInternal(err);
+                                SetErrorInternal(err);
                             }
                         } else {
-                            HandleErrorInternal(error ?? new OperationCanceledException());
+                            SetCancelledInternal(error);
                         }
                     }
                 }
             }

Implab/ActionTaskT.cs +1 -3

             using System;
             namespace Implab {
                 public class ActionTask<T> : ActionTaskBase, IDeferred<T> {
                     readonly Action<T> m_task;
                     public ActionTask(Action<T> task, Action<Exception> error, Action<Exception> cancel, bool autoCancellable) : base(error,cancel, autoCancellable) {
                         m_task = task;
                     }
                     public void Resolve(T value) {
                         if (m_task != null && LockCancelation()) {
                             try {
                                 m_task(value);
                                 SetResult();
-                            } catch(OperationCanceledException reason) {
-                                HandleCancelInternal(reason);
                             } catch(Exception err) {
-                                HandleErrorInternal(err);
+                                SetErrorInternal(err);
                             }
                         }
                     }
                 }
             }

Implab/Components/RunnableComponent.cs +17 -10

             using System;
             namespace Implab.Components {
                 public abstract class RunnableComponent : IDisposable, IRunnable, IInitializable {
                     enum Commands {
                         Ok = 0,
                         Fail,
                         Init,
                         Start,
                         Stop,
                         Dispose,
                         Last = Dispose
                     }
                     class StateMachine {
                         static readonly ExecutionState[,] _transitions;
                         static StateMachine() {
                             _transitions = new ExecutionState[(int)ExecutionState.Last + 1, (int)Commands.Last + 1];
                             Edge(ExecutionState.Created, ExecutionState.Initializing, Commands.Init);
                             Edge(ExecutionState.Created, ExecutionState.Disposed, Commands.Dispose);
                             Edge(ExecutionState.Initializing, ExecutionState.Ready, Commands.Ok);
                             Edge(ExecutionState.Initializing, ExecutionState.Failed, Commands.Fail);
                             Edge(ExecutionState.Ready, ExecutionState.Starting, Commands.Start);
                             Edge(ExecutionState.Ready, ExecutionState.Disposed, Commands.Dispose);
                             Edge(ExecutionState.Starting, ExecutionState.Running, Commands.Ok);
                             Edge(ExecutionState.Starting, ExecutionState.Failed, Commands.Fail);
                             Edge(ExecutionState.Starting, ExecutionState.Stopping, Commands.Stop);
                             Edge(ExecutionState.Starting, ExecutionState.Disposed, Commands.Dispose);
                             Edge(ExecutionState.Running, ExecutionState.Failed, Commands.Fail);
                             Edge(ExecutionState.Running, ExecutionState.Stopping, Commands.Stop);
                             Edge(ExecutionState.Running, ExecutionState.Disposed, Commands.Dispose);
                             Edge(ExecutionState.Stopping, ExecutionState.Failed, Commands.Fail);
                             Edge(ExecutionState.Stopping, ExecutionState.Disposed, Commands.Ok);
                             Edge(ExecutionState.Failed, ExecutionState.Disposed, Commands.Dispose);
                         }
                         static void Edge(ExecutionState s1, ExecutionState s2, Commands cmd) {
                             _transitions[(int)s1, (int)cmd] = s2;
                         }
                         public ExecutionState State {
                             get;
                             private set;
                         }
                         public StateMachine(ExecutionState initial) {
                             State = initial;
                         }
                         public bool Move(Commands cmd) {
                             var next = _transitions[(int)State, (int)cmd];
                             if (next == ExecutionState.Undefined)
                                 return false;
                             State = next;
                             return true;
                         }
                     }
                     IPromise m_pending;
                     Exception m_lastError;
                     readonly StateMachine m_stateMachine;
                     protected RunnableComponent(bool initialized) {
                         m_stateMachine = new StateMachine(initialized ? ExecutionState.Ready : ExecutionState.Created);
                     }
                     protected virtual int DisposeTimeout {
                         get {
                             return 10000;
                         }
                     }
                     void ThrowInvalidCommand(Commands cmd) {
                         if (m_stateMachine.State == ExecutionState.Disposed)
                             throw new ObjectDisposedException(ToString());
                         throw new InvalidOperationException(String.Format("Commnd {0} is not allowed in the state {1}", cmd, m_stateMachine.State));
                     }
                     void Move(Commands cmd) {
                         if (!m_stateMachine.Move(cmd))
                             ThrowInvalidCommand(cmd);
                     }
                     void Invoke(Commands cmd, Action action) {
                         lock (m_stateMachine)
                             Move(cmd);
                         try {
                             action();
                             lock(m_stateMachine)
                                 Move(Commands.Ok);
                         } catch (Exception err) {
                             lock (m_stateMachine) {
                                 Move(Commands.Fail);
                                 m_lastError = err;
                             }
                             throw;
                         }
                     }
                     IPromise InvokeAsync(Commands cmd, Func<IPromise> action, Action<IPromise, IDeferred> chain) {
                         IPromise promise = null;
                         IPromise prev;
                         var task = new ActionChainTask(action, null, null, true);
                         lock (m_stateMachine) {
                             Move(cmd);
                             prev = m_pending;
+                            Action<Exception> errorOrCancel = e => {
+                                if (e == null)
+                                    e = new OperationCanceledException();
+                                lock (m_stateMachine) {
+                                    if (m_pending == promise) {
+                                        Move(Commands.Fail);
+                                        m_pending = null;
+                                        m_lastError = e;
+                                    }
+                                }
+                                throw new PromiseTransientException(e);
+                            };
                             promise = task.Then(
                                 () => {
                                     lock(m_stateMachine) {
                                         if (m_pending == promise) {
                                             Move(Commands.Ok);
                                             m_pending = null;
                                         }
                                     }
-                                }, e => {
+                                },
-                                    lock(m_stateMachine) {
+                                errorOrCancel,
-                                        if (m_pending == promise) {
+                                errorOrCancel
-                                            Move(Commands.Fail);
-                                            m_pending = null;
-                                            m_lastError = e;
-                                    throw new PromiseTransientException(e);
                             );
                             m_pending = promise;
                         }
                         if (prev == null)
                             task.Resolve();
                         else
                             chain(prev, task);
                         return promise;
                     }
                     #region IInitializable implementation
                     public void Init() {
                         Invoke(Commands.Init, OnInitialize);
                     }
                     protected virtual void OnInitialize() {
                     }
                     #endregion
                     #region IRunnable implementation
                     public IPromise Start() {
                         return InvokeAsync(Commands.Start, OnStart, null);
                     }
                     protected virtual IPromise OnStart() {
                         return Promise.SUCCESS;
                     }
                     public IPromise Stop() {
                         return InvokeAsync(Commands.Stop, OnStop, StopPending).Then(Dispose);
                     }
                     protected virtual IPromise OnStop() {
                         return Promise.SUCCESS;
                     }
                     /// <summary>
                     /// Stops the current operation if one exists.
                     /// </summary>
                     /// <param name="current">Current.</param>
                     /// <param name="stop">Stop.</param>
                     protected virtual void StopPending(IPromise current, IDeferred stop) {
                         if (current == null) {
                             stop.Resolve();
                         } else {
                             // связваем текущую операцию с операцией остановки
                             current.On(
                                 stop.Resolve, // если текущая операция заверщилась, то можно начинать остановку
                                 stop.Reject, // если текущая операция дала ошибку - то все плохо, нельзя продолжать
                                 e => stop.Resolve() // если текущая отменилась, то можно начинать остановку
                             );
                             // посылаем текущей операции сигнал остановки
                             current.Cancel();
                         }
                     }
                     public ExecutionState State {
                         get {
                             return m_stateMachine.State;
                         }
                     }
                     public Exception LastError {
                         get {
                             return m_lastError;
                         }
                     }
                     #endregion
                     #region IDisposable implementation
                     public void Dispose() {
                         IPromise pending;
                         lock (m_stateMachine) {
                             if (m_stateMachine.State == ExecutionState.Disposed)
                                 return;
                             Move(Commands.Dispose);
                             GC.SuppressFinalize(this);
                             pending = m_pending;
                             m_pending = null;
                         }
                         if (pending != null) {
                             pending.Cancel();
                             pending.Timeout(DisposeTimeout).On(
                                 () => Dispose(true, null),
                                 err => Dispose(true, err),
                                 reason => Dispose(true, new OperationCanceledException("The operation is cancelled", reason))
                             );
                         } else {
                             Dispose(true, m_lastError);
                         }
                     }
                     ~RunnableComponent() {
                         Dispose(false, null);
                     }
                     #endregion
                     protected virtual void Dispose(bool disposing, Exception lastError) {
                     }
                 }
             }

Implab/FuncChainTask.cs +1 -3

             using System;
             namespace Implab {
                 public class FuncChainTask<TResult> : FuncChainTaskBase<TResult>, IDeferred {
                     readonly Func<IPromise<TResult>> m_task;
                     public FuncChainTask(Func<IPromise<TResult>> task, Func<Exception, IPromise<TResult>> error, Func<Exception, IPromise<TResult>> cancel, bool autoCancellable)
                         : base(error, cancel, autoCancellable) {
                         m_task = task;
                     }
                     public void Resolve() {
                         if (m_task != null && LockCancelation()) {
                             try {
                                 var operation = m_task();
                                 operation.On(SetResult, HandleErrorInternal, HandleCancelInternal);
                                 CancellationRequested(operation.Cancel);
-                            } catch (OperationCanceledException reason) {
-                                HandleCancelInternal(reason);
                             } catch (Exception err) {
-                                HandleErrorInternal(err);
+                                SetErrorInternal(err);
                             }
                         }
                     }
                 }
             }

Implab/FuncChainTaskBase.cs +2 -2

             using System;
             namespace Implab {
                 public class FuncChainTaskBase<TResult> : AbstractTask<TResult> {
                     readonly Func<Exception, IPromise<TResult>> m_error;
                     readonly Func<Exception, IPromise<TResult>> m_cancel;
                     protected FuncChainTaskBase( Func<Exception, IPromise<TResult>> error, Func<Exception, IPromise<TResult>> cancel, bool autoCancellable) {
                         m_error = error;
                         m_cancel = cancel;
                         if (autoCancellable)
                             CancellationRequested(CancelOperation);
                     }
                     public void Reject(Exception error) {
                         if (LockCancelation())
                             HandleErrorInternal(error);
                     }
                     public override void CancelOperation(Exception reason) {
                         if (LockCancelation())
                             HandleCancelInternal(reason);
                     }
                     protected void HandleErrorInternal(Exception error) {
                         if (m_error != null) {
                             try {
                                 var p = m_error(error);
                                 p.On(SetResult, SetErrorInternal, SetCancelledInternal);
                                 CancellationRequested(p.Cancel);
                             } catch(Exception err) {
                                 SetErrorInternal(err);
                             }
                         } else {
                             SetErrorInternal(error);
                         }
                     }
                     protected void HandleCancelInternal(Exception reason) {
                         if (m_cancel != null) {
                             try {
                                 var p = m_cancel(reason);
                                 p.On(SetResult, HandleErrorInternal, SetCancelledInternal);
                                 CancellationRequested(p.Cancel);
                             } catch (Exception err) {
-                                HandleErrorInternal(err);
+                                SetErrorInternal(err);
                             }
                         } else {
-                            HandleErrorInternal(reason ?? new OperationCanceledException());
+                            SetCancelledInternal(reason);
                         }
                     }
                 }
             }

Implab/FuncChainTaskT.cs +1 -3

             using System;
             namespace Implab {
                 public class FuncChainTask<TArg,TResult> : FuncChainTaskBase<TResult>, IDeferred<TArg> {
                     readonly Func<TArg, IPromise<TResult>> m_task;
                     public FuncChainTask(Func<TArg, IPromise<TResult>> task, Func<Exception, IPromise<TResult>> error, Func<Exception, IPromise<TResult>> cancel, bool autoCancellable) : base(error, cancel, autoCancellable){
                         m_task = task;
                     }
                     public void Resolve(TArg value) {
                         if (m_task != null && LockCancelation()) {
                             try {
                                 var operation = m_task(value);
                                 operation.On(SetResult, HandleErrorInternal, SetCancelled);
                                 CancellationRequested(operation.Cancel);
-                            } catch (OperationCanceledException reason) {
-                                HandleCancelInternal(reason);
                             } catch (Exception err) {
-                                HandleErrorInternal(err);
+                                SetErrorInternal(err);
                             }
                         }
                     }
                 }
             }

Implab/FuncTask.cs +1 -3

             using System;
             using System.Threading;
             namespace Implab {
                 public class FuncTask<T> : FuncTaskBase<T>, IDeferred {
                     readonly Func<T> m_task;
                     public FuncTask(Func<T> task, Func<Exception, T> error, Func<Exception, T> cancel, bool autoCancellable) : base(error, cancel, autoCancellable) {
                         m_task = task;
                     }
                     public void Resolve() {
                         if (m_task != null && LockCancelation()) {
                             try {
                                 SetResult(m_task());
-                            } catch(OperationCanceledException reason)  {
-                                HandleCancelInternal(reason);
                             } catch(Exception err) {
-                                HandleErrorInternal(err);
+                                SetErrorInternal(err);
                             }
                         }
                     }
                 }
             }

Implab/FuncTaskBase.cs +2 -2

             using System;
             namespace Implab {
                 public class FuncTaskBase<TResult> : AbstractTask<TResult> {
                     readonly Func<Exception, TResult> m_cancel;
                     readonly Func<Exception, TResult> m_error;
                     protected FuncTaskBase( Func<Exception, TResult> error, Func<Exception, TResult> cancel, bool autoCancellable) {
                         m_error = error;
                         m_cancel = cancel;
                         if (autoCancellable)
                             CancellationRequested(CancelOperation);
                     }
                     public void Reject(Exception error) {
                         Safe.ArgumentNotNull(error, "error");
                         if (LockCancelation())
                             HandleErrorInternal(error);
                     }
                     protected void HandleErrorInternal(Exception error) {
                         if (m_error != null) {
                             try {
                                 SetResult(m_error(error));
                             } catch(Exception err) {
                                 SetErrorInternal(err);
                             }
                         } else {
                             SetErrorInternal(error);
                         }
                     }
                     public override void CancelOperation(Exception reason) {
                         if (LockCancelation())
                             HandleCancelInternal(reason);
                     }
                     protected void HandleCancelInternal(Exception reason) {
                         if (m_cancel != null) {
                             try {
                                 SetResult(m_cancel(reason));
                             } catch (Exception err) {
-                                HandleErrorInternal(err);
+                                SetErrorInternal(err);
                             }
                         } else {
-                            HandleErrorInternal(reason ?? new OperationCanceledException());
+                            SetCancelledInternal(reason);
                         }
                     }
                 }
             }

Implab/FuncTaskT.cs +1 -3

             using System;
             namespace Implab {
                 public class FuncTask<TArg, TResult> : FuncTaskBase<TResult>, IDeferred<TArg> {
                     readonly Func<TArg, TResult> m_task;
                     public FuncTask(Func<TArg, TResult> task, Func<Exception, TResult> error,Func<Exception, TResult> cancel, bool autoCancellable) :  base(error,cancel, autoCancellable) {
                         m_task = task;
                     }
                     public void Resolve(TArg value) {
                         if (m_task != null && LockCancelation()) {
                             try {
                                 SetResult(m_task(value));
-                            } catch(OperationCanceledException reason)  {
-                                HandleCancelInternal(reason);
                             } catch(Exception err) {
-                                HandleErrorInternal(err);
+                                SetErrorInternal(err);
                             }
                         }
                     }
                 }
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages