implab/ImplabNet Commit - r187:dd4a3590f9c6

Reworked cancelation handling, if the cancel handler isn't specified the OperationCanceledException will be handled by the error handler...

cin -

r187:dd4a3590f9c6 ref20160224

parent child

Context file:

r187:dd4a3590f9c6

Collapse all files

Implab/AbstractTask.cs created 644 +45 0

@@ -0,0 +1,45
	1	using System;
	2	using System.Threading;
	3
	4	namespace Implab {
	5	/// <summary>
	6	/// Базовый класс для реализации задачь. Задача представляет собой некторое
	7	/// действие, которое можно иницировать и обработать результат его выполнения
	8	/// в виде обещания, для этого оно реализует интерфейс <see cref="IPromise"/>.
	9	/// </summary>
	10	/// <remarks>
	11	/// Данный класс определяет стандартное поведение при обработки результатов, в частности
	12	/// обработку <see cref="System.OperationCanceledException"/> и <see cref="PromiseTransientException"/>
	13	/// </remarks>
	14	public abstract class AbstractTask : AbstractPromise {
	15	int m_cancelationLock;
	16
	17	/// <summary>
	18	/// Получает эксклюзивное право отмены задания, используется для отмены задания до начала его выполнения.
	19	/// </summary>
	20	/// <returns><c>true</c>, if cancelation was locked, <c>false</c> otherwise.</returns>
	21	protected bool LockCancelation() {
	22	return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
	23	}
	24
	25
	26
	27	protected void SetErrorInternal(Exception error) {
	28	// unwrap
	29	while (error is PromiseTransientException && error.InnerException != null)
	30	error = error.InnerException;
	31
	32	if (error is OperationCanceledException)
	33	SetCancelled(error);
	34	else
	35	SetError(error);
	36	}
	37
	38	protected void SetCancelledInternal(Exception reason) {
	39	SetCancelled(
	40	reason == null ? new OperationCanceledException() : reason is OperationCanceledException ? reason : new OperationCanceledException(null, reason)
	41	);
	42	}
	43	}
	44	}
	45

Implab/AbstractTaskT.cs created 644 +36 0

@@ -0,0 +1,36
	1	using System;
	2	using System.Threading;
	3
	4	namespace Implab {
	5	public abstract class AbstractTask<T> : AbstractPromise<T> {
	6	int m_cancelationLock;
	7
	8	/// <summary>
	9	/// Получает эксклюзивное право отмены задания, используется для отмены задания до начала его выполнения.
	10	/// </summary>
	11	/// <returns><c>true</c>, if cancelation was locked, <c>false</c> otherwise.</returns>
	12	protected bool LockCancelation() {
	13	return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
	14	}
	15
	16
	17
	18	protected void SetErrorInternal(Exception error) {
	19	// unwrap
	20	while (error is PromiseTransientException && error.InnerException != null)
	21	error = error.InnerException;
	22
	23	if (error is OperationCanceledException)
	24	SetCancelled(error);
	25	else
	26	SetError(error);
	27	}
	28
	29	protected void SetCancelledInternal(Exception reason) {
	30	SetCancelled(
	31	reason == null ? new OperationCanceledException() : reason is OperationCanceledException ? reason : new OperationCanceledException(null, reason)
	32	);
	33	}
	34	}
	35	}
	36

Implab/ActionChainTask.cs +3 -1

             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, SetCancelled);
+                                p.On(SetResult, HandleErrorInternal, HandleCancelInternal);
                                 CancellationRequested(p.Cancel);
+                            } catch (OperationCanceledException reason){
+                                HandleCancelInternal(reason);
                             } catch(Exception err) {
                                 HandleErrorInternal(err);
                             }
                         }
                     }
                 }
             }

Implab/ActionChainTaskBase.cs +18 -31

             using System;
             using System.Threading;
             namespace Implab {
-                public class ActionChainTaskBase : AbstractPromise {
+                public class ActionChainTaskBase : AbstractTask {
                     readonly Func<Exception, IPromise> m_error;
                     readonly Func<Exception, IPromise> m_cancel;
-                    int m_cancelationLock;
                     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()) {
+                        if (LockCancelation())
-                            if (!(reason is OperationCanceledException))
+                            // отмена вызвана до начала выполнения задачи
-                                reason = reason != null ? new OperationCanceledException(null, reason) : new OperationCanceledException();
+                            HandleCancelInternal(reason);
+                    }
+                    protected void HandleCancelInternal(Exception reason) {
                         if (m_cancel != null) {
                             try {
-                                    m_cancel(reason).On(SetResult, HandleErrorInternal, HandleCancelInternal);
+                                // вызываем обработчик отмены
+                                var p = m_cancel(reason);
+                                p.On(SetResult, HandleErrorInternal, SetCancelledInternal);
+                                // сообщаем асинхронной операции, что клиент уже не хочет получать результат
+                                // т.е. если он инициировал отмену, задача отменилась, вызвался обрабочик отмены
+                                // отбработчику сообщили, что результат уже не нужен и уже сам обработчик решает
+                                // отдавать ли результат или подтвердить отмену (или вернуть ошибку).
+                                CancellationRequested(p.Cancel);
                             } catch (Exception err) {
                                 HandleErrorInternal(err);
                             }
                         } else {
-                                HandleErrorInternal(reason);
+                            HandleErrorInternal(reason ?? new OperationCanceledException());
                         }
                     }
-                    void HandleCancelInternal(Exception reason) {
+                    protected void HandleErrorInternal(Exception error) {
-                        if (!(reason is OperationCanceledException))
-                            reason = reason != null ? new OperationCanceledException(null, reason) : new OperationCanceledException();
-                        HandleErrorInternal(reason);
-                    void HandleErrorInternal(Exception error) {
                         if (m_error != null) {
                             try {
                                 var p = m_error(error);
-                                p.On(SetResult, SetError, SetCancelled);
+                                p.On(SetResult, SetErrorInternal, SetCancelledInternal);
                                 CancellationRequested(p.Cancel);
                             } catch (Exception err) {
-                                error = err;
+                                SetErrorInternal(error);
                             }
                         } else {
                             SetErrorInternal(error);
                         }
                     }
-                    void SetErrorInternal(Exception error) {
-                        while (error is PromiseTransientException)
-                            error = error.InnerException;
-                        if (error is OperationCanceledException)
-                            SetCancelled(error);
-                        else
-                            SetError(error);
-                    protected bool LockCancelation() {
-                        return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
                 }
             }

Implab/ActionChainTaskT.cs +3 -1

             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, SetCancelled);
+                                p.On(SetResult, HandleErrorInternal, HandleCancelInternal);
                                 CancellationRequested(p.Cancel);
+                            } catch (OperationCanceledException reason) {
+                                HandleCancelInternal(reason);
                             } catch(Exception err) {
                                 HandleErrorInternal(err);
                             }
                         }
                     }
                 }
             }

Implab/ActionTask.cs +2 0

             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);
                             }
                         }
                     }
                 }
             }

Implab/ActionTaskBase.cs +12 -16

             using System;
-            using System.Threading;
             namespace Implab {
-                public class ActionTaskBase : AbstractPromise {
+                public class ActionTaskBase : AbstractTask {
                     readonly Action<Exception> m_cancel;
                     readonly Action<Exception> m_error;
-                    int m_cancelationLock;
                     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) {
-                                SetError(err);
+                                SetErrorInternal(err);
                             }
                         } else {
-                            SetError(error);
+                            SetErrorInternal(error);
                         }
                     }
-                    public override void CancelOperation(Exception reason) {
+                    protected void HandleCancelInternal(Exception error) {
-                        if (LockCancelation()) {
                         if (m_cancel != null) {
                             try {
-                                    m_cancel(reason);
+                                m_cancel(error);
                                 SetResult();
                             } catch(Exception err) {
                                 HandleErrorInternal(err);
                             }
                         } else {
-                                SetCancelled(reason);
+                            HandleErrorInternal(error ?? new OperationCanceledException());
+                        }
                     }
                 }
             }
-                    protected bool LockCancelation() {
-                        return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);

Implab/ActionTaskT.cs +2 0

             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);
                             }
                         }
                     }
                 }
             }

Implab/Components/RunnableComponent.cs +7 -5

             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;
                             promise = task.Then(
                                 () => {
                                     lock(m_stateMachine) {
                                         if (m_pending == promise) {
                                             Move(Commands.Ok);
                                             m_pending = null;
                                         }
                                     }
                                 }, e => {
                                     lock(m_stateMachine) {
                                         if (m_pending == promise) {
                                             Move(Commands.Fail);
                                             m_pending = null;
                                             m_lastError = e;
                                         }
                                     }
                                     throw new PromiseTransientException(e);
-                                },
-                                r => {
-                                    // handle cancellation as exception
-                                    throw new OperationCanceledException("The operation has been cancelled", r);
                                 }
                             );
                             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.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 +3 -1

             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, SetCancelled);
+                                operation.On(SetResult, HandleErrorInternal, HandleCancelInternal);
                                 CancellationRequested(operation.Cancel);
+                            } catch (OperationCanceledException reason) {
+                                HandleCancelInternal(reason);
                             } catch (Exception err) {
                                 HandleErrorInternal(err);
                             }
                         }
                     }
                 }
             }

Implab/FuncChainTaskBase.cs +20 -24

             using System;
-            using System.Threading;
             namespace Implab {
-                public class FuncChainTaskBase<TResult> : AbstractPromise<TResult> {
+                public class FuncChainTaskBase<TResult> : AbstractTask<TResult> {
                     readonly Func<Exception, IPromise<TResult>> m_error;
                     readonly Func<Exception, IPromise<TResult>> m_cancel;
-                    int m_cancelationLock;
                     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()) {
+                        if (LockCancelation())
-                            if (m_cancel != null) {
+                            HandleCancelInternal(reason);
-                                try {
-                                    m_cancel(reason).On(SetResult, HandleErrorInternal, SetCancelled);
-                                } catch (Exception err) {
-                                    HandleErrorInternal(err);
-                            } else {
-                                SetCancelled(reason);
                     }
                     protected void HandleErrorInternal(Exception error) {
                         if (m_error != null) {
                             try {
-                                var operation = m_error(error);
+                                var p = m_error(error);
+                                p.On(SetResult, SetErrorInternal, SetCancelledInternal);
-                                operation.On(SetResult, SetError, SetCancelled);
+                                CancellationRequested(p.Cancel);
-                                CancellationRequested(operation.Cancel);
                             } catch(Exception err) {
-                                SetError(err);
+                                SetErrorInternal(err);
                             }
                         } else {
-                            SetError(error);
+                            SetErrorInternal(error);
                         }
                     }
-                    protected bool LockCancelation() {
+                    protected void HandleCancelInternal(Exception reason) {
-                        return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
+                        if (m_cancel != null) {
+                            try {
+                                var p = m_cancel(reason);
+                                p.On(SetResult, HandleErrorInternal, SetCancelledInternal);
+                                CancellationRequested(p.Cancel);
+                            } catch (Exception err) {
+                                HandleErrorInternal(err);
+                            }
+                        } else {
+                            HandleErrorInternal(reason ?? new OperationCanceledException());
+                        }
                     }
                 }
             }

Implab/FuncChainTaskT.cs +2 0

             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);
                             }
                         }
                     }
                 }
             }

Implab/FuncTask.cs +2 0

             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);
                             }
                         }
                     }
                 }
             }

Implab/FuncTaskBase.cs +9 -12

             using System;
-            using System.Threading;
             namespace Implab {
-                public class FuncTaskBase<TResult> : AbstractPromise<TResult> {
+                public class FuncTaskBase<TResult> : AbstractTask<TResult> {
                     readonly Func<Exception, TResult> m_cancel;
                     readonly Func<Exception, TResult> m_error;
-                    int m_cancelationLock;
                     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) {
-                                SetError(err);
+                                SetErrorInternal(err);
                             }
                         } else {
-                            SetError(error);
+                            SetErrorInternal(error);
                         }
                     }
                     public override void CancelOperation(Exception reason) {
-                        if (LockCancelation()) {
+                        if (LockCancelation())
+                            HandleCancelInternal(reason);
+                    }
+                    protected void HandleCancelInternal(Exception reason) {
                         if (m_cancel != null) {
                             try {
                                 SetResult(m_cancel(reason));
                             } catch (Exception err) {
                                 HandleErrorInternal(err);
                             }
                         } else {
-                                SetCancelled(reason);
+                            HandleErrorInternal(reason ?? new OperationCanceledException());
                         }
                     }
-                    protected bool LockCancelation() {
-                        return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
                 }
             }

Implab/FuncTaskT.cs +2 0

             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);
                             }
                         }
                     }
                 }
             }

Implab/Implab.csproj +2 0

             <?xml version="1.0" encoding="utf-8"?>
             <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
               <PropertyGroup>
                 <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
                 <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
                 <ProjectGuid>{F550F1F8-8746-4AD0-9614-855F4C4B7F05}</ProjectGuid>
                 <OutputType>Library</OutputType>
                 <RootNamespace>Implab</RootNamespace>
                 <AssemblyName>Implab</AssemblyName>
                 <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
                 <ReleaseVersion>0.2</ReleaseVersion>
                 <ProductVersion>8.0.30703</ProductVersion>
                 <SchemaVersion>2.0</SchemaVersion>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>TRACE;DEBUG;</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
                 <RunCodeAnalysis>true</RunCodeAnalysis>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
                 <DebugType>full</DebugType>
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug 4.5|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>TRACE;DEBUG;NET_4_5</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <RunCodeAnalysis>true</RunCodeAnalysis>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release 4.5|AnyCPU' ">
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
                 <DefineConstants>NET_4_5</DefineConstants>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'DebugMono|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>TRACE;DEBUG;NET_4_5;MONO</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <RunCodeAnalysis>true</RunCodeAnalysis>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'ReleaseMono|AnyCPU' ">
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <DefineConstants>NET_4_5;MONO;</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <ItemGroup>
                 <Reference Include="System" />
                 <Reference Include="System.Xml" />
                 <Reference Include="mscorlib" />
               </ItemGroup>
               <ItemGroup>
                 <Compile Include="CustomEqualityComparer.cs" />
                 <Compile Include="Diagnostics\ConsoleTraceListener.cs" />
                 <Compile Include="Diagnostics\EventText.cs" />
                 <Compile Include="Diagnostics\LogChannel.cs" />
                 <Compile Include="Diagnostics\LogicalOperation.cs" />
                 <Compile Include="Diagnostics\TextFileListener.cs" />
                 <Compile Include="Diagnostics\TraceLog.cs" />
                 <Compile Include="Diagnostics\TraceEvent.cs" />
                 <Compile Include="Diagnostics\TraceEventType.cs" />
                 <Compile Include="ICancellable.cs" />
                 <Compile Include="IProgressHandler.cs" />
                 <Compile Include="IProgressNotifier.cs" />
                 <Compile Include="IPromiseT.cs" />
                 <Compile Include="IPromise.cs" />
                 <Compile Include="IServiceLocator.cs" />
                 <Compile Include="ITaskController.cs" />
                 <Compile Include="Parallels\DispatchPool.cs" />
                 <Compile Include="Parallels\ArrayTraits.cs" />
                 <Compile Include="Parallels\MTQueue.cs" />
                 <Compile Include="Parallels\WorkerPool.cs" />
                 <Compile Include="ProgressInitEventArgs.cs" />
                 <Compile Include="Properties\AssemblyInfo.cs" />
                 <Compile Include="Parallels\AsyncPool.cs" />
                 <Compile Include="Safe.cs" />
                 <Compile Include="ValueEventArgs.cs" />
                 <Compile Include="PromiseExtensions.cs" />
                 <Compile Include="SyncContextPromise.cs" />
                 <Compile Include="Diagnostics\OperationContext.cs" />
                 <Compile Include="Diagnostics\TraceContext.cs" />
                 <Compile Include="Diagnostics\LogEventArgs.cs" />
                 <Compile Include="Diagnostics\LogEventArgsT.cs" />
                 <Compile Include="Diagnostics\Extensions.cs" />
                 <Compile Include="PromiseEventType.cs" />
                 <Compile Include="Parallels\AsyncQueue.cs" />
                 <Compile Include="PromiseT.cs" />
                 <Compile Include="IDeferred.cs" />
                 <Compile Include="IDeferredT.cs" />
                 <Compile Include="Promise.cs" />
                 <Compile Include="PromiseTransientException.cs" />
                 <Compile Include="Parallels\Signal.cs" />
                 <Compile Include="Parallels\SharedLock.cs" />
                 <Compile Include="Diagnostics\ILogWriter.cs" />
                 <Compile Include="Diagnostics\ListenerBase.cs" />
                 <Compile Include="Parallels\BlockingQueue.cs" />
                 <Compile Include="AbstractEvent.cs" />
                 <Compile Include="AbstractPromise.cs" />
                 <Compile Include="AbstractPromiseT.cs" />
                 <Compile Include="FuncTask.cs" />
                 <Compile Include="FuncTaskBase.cs" />
                 <Compile Include="FuncTaskT.cs" />
                 <Compile Include="ActionChainTaskBase.cs" />
                 <Compile Include="ActionChainTask.cs" />
                 <Compile Include="ActionChainTaskT.cs" />
                 <Compile Include="FuncChainTaskBase.cs" />
                 <Compile Include="FuncChainTask.cs" />
                 <Compile Include="FuncChainTaskT.cs" />
                 <Compile Include="ActionTaskBase.cs" />
                 <Compile Include="ActionTask.cs" />
                 <Compile Include="ActionTaskT.cs" />
                 <Compile Include="ICancellationToken.cs" />
                 <Compile Include="SuccessPromise.cs" />
                 <Compile Include="SuccessPromiseT.cs" />
                 <Compile Include="PromiseAwaiterT.cs" />
                 <Compile Include="PromiseAwaiter.cs" />
                 <Compile Include="Components\ComponentContainer.cs" />
                 <Compile Include="Components\Disposable.cs" />
                 <Compile Include="Components\DisposablePool.cs" />
                 <Compile Include="Components\ObjectPool.cs" />
                 <Compile Include="Components\ServiceLocator.cs" />
                 <Compile Include="Components\IInitializable.cs" />
                 <Compile Include="TaskController.cs" />
                 <Compile Include="Components\App.cs" />
                 <Compile Include="Components\IRunnable.cs" />
                 <Compile Include="Components\ExecutionState.cs" />
                 <Compile Include="Components\RunnableComponent.cs" />
                 <Compile Include="Components\IFactory.cs" />
                 <Compile Include="Automaton\IAlphabet.cs" />
                 <Compile Include="Automaton\ParserException.cs" />
                 <Compile Include="Automaton\IndexedAlphabetBase.cs" />
                 <Compile Include="Automaton\IAlphabetBuilder.cs" />
                 <Compile Include="Automaton\RegularExpressions\AltToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\BinaryToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\CatToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\StarToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\SymbolToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\EmptyToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\Token.cs" />
                 <Compile Include="Automaton\RegularExpressions\IVisitor.cs" />
                 <Compile Include="Automaton\AutomatonTransition.cs" />
                 <Compile Include="Formats\JSON\JSONElementContext.cs" />
                 <Compile Include="Formats\JSON\JSONElementType.cs" />
                 <Compile Include="Formats\JSON\JSONGrammar.cs" />
                 <Compile Include="Formats\JSON\JSONParser.cs" />
                 <Compile Include="Formats\JSON\JSONScanner.cs" />
                 <Compile Include="Formats\JSON\JsonTokenType.cs" />
                 <Compile Include="Formats\JSON\JSONWriter.cs" />
                 <Compile Include="Formats\JSON\JSONXmlReader.cs" />
                 <Compile Include="Formats\JSON\JSONXmlReaderOptions.cs" />
                 <Compile Include="Formats\JSON\StringTranslator.cs" />
                 <Compile Include="Automaton\MapAlphabet.cs" />
                 <Compile Include="Formats\CharAlphabet.cs" />
                 <Compile Include="Formats\ByteAlphabet.cs" />
                 <Compile Include="Automaton\IDFATable.cs" />
                 <Compile Include="Automaton\IDFATableBuilder.cs" />
                 <Compile Include="Automaton\DFATable.cs" />
                 <Compile Include="Automaton\RegularExpressions\RegularExpressionVisitor.cs" />
                 <Compile Include="Automaton\RegularExpressions\ITaggedDFABuilder.cs" />
                 <Compile Include="Formats\TextScanner.cs" />
                 <Compile Include="Formats\StringScanner.cs" />
                 <Compile Include="Formats\ReaderScanner.cs" />
                 <Compile Include="Formats\ScannerContext.cs" />
                 <Compile Include="Formats\Grammar.cs" />
                 <Compile Include="Automaton\RegularExpressions\EndTokenT.cs" />
                 <Compile Include="Automaton\RegularExpressions\EndToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\RegularExpressionVisitorT.cs" />
                 <Compile Include="Automaton\AutomatonConst.cs" />
                 <Compile Include="Automaton\RegularExpressions\RegularDFA.cs" />
                 <Compile Include="Components\LazyAndWeak.cs" />
+                <Compile Include="AbstractTask.cs" />
+                <Compile Include="AbstractTaskT.cs" />
               </ItemGroup>
               <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
               <ItemGroup />
               <ProjectExtensions>
                 <MonoDevelop>
                   <Properties>
                     <Policies>
                       <CSharpFormattingPolicy IndentSwitchBody="True" NamespaceBraceStyle="EndOfLine" ClassBraceStyle="EndOfLine" InterfaceBraceStyle="EndOfLine" StructBraceStyle="EndOfLine" EnumBraceStyle="EndOfLine" MethodBraceStyle="EndOfLine" ConstructorBraceStyle="EndOfLine" DestructorBraceStyle="EndOfLine" BeforeMethodDeclarationParentheses="False" BeforeMethodCallParentheses="False" BeforeConstructorDeclarationParentheses="False" NewLineBeforeConstructorInitializerColon="NewLine" NewLineAfterConstructorInitializerColon="SameLine" BeforeIndexerDeclarationBracket="False" BeforeDelegateDeclarationParentheses="False" NewParentheses="False" SpacesBeforeBrackets="False" inheritsSet="Mono" inheritsScope="text/x-csharp" scope="text/x-csharp" />
                       <TextStylePolicy FileWidth="120" EolMarker="Unix" inheritsSet="VisualStudio" inheritsScope="text/plain" scope="text/x-csharp" />
                       <DotNetNamingPolicy DirectoryNamespaceAssociation="PrefixedHierarchical" ResourceNamePolicy="MSBuild" />
                       <TextStylePolicy FileWidth="120" TabsToSpaces="False" inheritsSet="VisualStudio" inheritsScope="text/plain" scope="application/xml" />
                       <XmlFormattingPolicy inheritsSet="Mono" inheritsScope="application/xml" scope="application/xml" />
                       <TextStylePolicy FileWidth="120" TabsToSpaces="False" inheritsSet="VisualStudio" inheritsScope="text/plain" scope="text/plain" />
                       <NameConventionPolicy>
                         <Rules>
                           <NamingRule Name="Namespaces" AffectedEntity="Namespace" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Types" AffectedEntity="Class, Struct, Enum, Delegate" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Interfaces" AffectedEntity="Interface" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredPrefixes>
                               <String>I</String>
                             </RequiredPrefixes>
                           </NamingRule>
                           <NamingRule Name="Attributes" AffectedEntity="CustomAttributes" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredSuffixes>
                               <String>Attribute</String>
                             </RequiredSuffixes>
                           </NamingRule>
                           <NamingRule Name="Event Arguments" AffectedEntity="CustomEventArgs" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredSuffixes>
                               <String>EventArgs</String>
                             </RequiredSuffixes>
                           </NamingRule>
                           <NamingRule Name="Exceptions" AffectedEntity="CustomExceptions" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredSuffixes>
                               <String>Exception</String>
                             </RequiredSuffixes>
                           </NamingRule>
                           <NamingRule Name="Methods" AffectedEntity="Methods" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Static Readonly Fields" AffectedEntity="ReadonlyField" VisibilityMask="Internal, Protected, Public" NamingStyle="CamelCase" IncludeInstanceMembers="False" IncludeStaticEntities="True" />
                           <NamingRule Name="Fields (Non Private)" AffectedEntity="Field" VisibilityMask="Internal, Public" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="ReadOnly Fields (Non Private)" AffectedEntity="ReadonlyField" VisibilityMask="Internal, Public" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="False" />
                           <NamingRule Name="Fields (Private)" AffectedEntity="Field, ReadonlyField" VisibilityMask="Private, Protected" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="False">
                             <RequiredPrefixes>
                               <String>m_</String>
                             </RequiredPrefixes>
                           </NamingRule>
                           <NamingRule Name="Static Fields (Private)" AffectedEntity="Field" VisibilityMask="Private" NamingStyle="CamelCase" IncludeInstanceMembers="False" IncludeStaticEntities="True">
                             <RequiredPrefixes>
                               <String>_</String>
                             </RequiredPrefixes>
                           </NamingRule>
                           <NamingRule Name="ReadOnly Fields (Private)" AffectedEntity="ReadonlyField" VisibilityMask="Private, Protected" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="False">
                             <RequiredPrefixes>
                               <String>m_</String>
                             </RequiredPrefixes>
                           </NamingRule>
                           <NamingRule Name="Constant Fields" AffectedEntity="ConstantField" VisibilityMask="VisibilityMask" NamingStyle="AllUpper" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Properties" AffectedEntity="Property" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Events" AffectedEntity="Event" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Enum Members" AffectedEntity="EnumMember" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Parameters" AffectedEntity="Parameter, LocalVariable" VisibilityMask="VisibilityMask" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Type Parameters" AffectedEntity="TypeParameter" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredPrefixes>
                               <String>T</String>
                             </RequiredPrefixes>
                           </NamingRule>
                         </Rules>
                       </NameConventionPolicy>
                     </Policies>
                   </Properties>
                 </MonoDevelop>
               </ProjectExtensions>
               <ItemGroup>
                 <Folder Include="Components\" />
                 <Folder Include="Automaton\RegularExpressions\" />
                 <Folder Include="Formats\" />
                 <Folder Include="Formats\JSON\" />
               </ItemGroup>
             </Project>

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