implab/ImplabNet Commit - r208:7d07503621fe

RunnableComponent.Dispose(bool,Exception) changed to standart Dispose(bool)...

cin -

r208:7d07503621fe v2

parent child

Context file:

r208:7d07503621fe

Collapse all files

Implab.Test/Mock/MockRunnableComponent.cs +4 -4

             using System;
             using Implab.Components;
             namespace Implab.Test.Mock {
                 class MockRunnableComponent : RunnableComponent {
                     public MockRunnableComponent(bool initialized) : base(initialized) {
                     }
                     public MockRunnableComponent(bool initialized, bool reusable) : base(initialized, reusable) {
                     }
                     public Action MockInit {
                         get;
                         set;
                     }
                     public Func<IPromise> MockStart {
                         get;
                         set;
                     }
                     public Func<IPromise> MockStop {
                         get;
                         set;
                     }
-                    public Action<bool, Exception> MockDispose {
+                    public Action<bool> MockDispose {
                         get;
                         set;
                     }
                     protected override IPromise OnStart() {
                         return MockStart != null ? Safe.Run(MockStart).Chain(base.OnStart) : Safe.Run(base.OnStart);
                     }
                     protected override IPromise OnStop() {
                         return MockStop != null ? Safe.Run(MockStop).Chain(base.OnStop) : Safe.Run(base.OnStop);
                     }
                     protected override void OnInitialize() {
                         if (MockInit != null)
                             MockInit();
                     }
-                    protected override void Dispose(bool disposing, Exception lastError) {
+                    protected override void Dispose(bool disposing) {
                         if (MockDispose != null)
-                            MockDispose(disposing, lastError);
+                            MockDispose(disposing);
-                        base.Dispose(disposing, lastError);
+                        base.Dispose(disposing);
                     }
                 }
             }

Implab.Test/RunnableComponentTests.cs +3 -5

             using System;
             using System.Reflection;
             using System.Threading;
             using Implab.Parallels;
             using Implab.Components;
             using Implab.Test.Mock;
             #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 {
                         }
                     }
                     [TestMethod]
                     public void NormalFlowTest() {
                         var comp = new MockRunnableComponent(false);
                         Assert.AreEqual(ExecutionState.Created, comp.State);
                         comp.Initialize();
                         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 MockRunnableComponent(false) {
                             MockInit = () => {
                                 throw new Exception("BAD");
                             }
                         };
                         ShouldThrow(() => comp.Start());
                         ShouldThrow(() => comp.Stop());
                         Assert.AreEqual(ExecutionState.Created, comp.State);
                         ShouldThrow(comp.Initialize);
                         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 MockRunnableComponent(false);
                         comp.Dispose();
                         ShouldThrow(() => comp.Start());
                         ShouldThrow(() => comp.Stop());
                         ShouldThrow(comp.Initialize);
                         Assert.AreEqual(ExecutionState.Disposed, comp.State);
                     }
                     [TestMethod]
                     public void ShouldCallDisposeOnStop() {
                         var comp = new MockRunnableComponent(true);
                         bool disposed = false;
-                        comp.MockDispose = (disposing, error) => {
+                        comp.MockDispose = (disposing) => {
                             disposed = true;
                         };
                         comp.Start().Join(1000);
                         comp.Stop().Join(1000);
                         ShouldThrow(() => comp.Start());
                         ShouldThrow(() => comp.Stop());
                         ShouldThrow(comp.Initialize);
                         Assert.AreEqual(ExecutionState.Disposed, comp.State);
                         Assert.IsTrue(disposed);
                     }
                     [TestMethod]
                     public void ShouldNotCallDisposeOnStop() {
                         var comp = new MockRunnableComponent(true, true);
                         bool disposed = false;
-                        comp.MockDispose = (disposing, error) => {
+                        comp.MockDispose = (disposing) => {
                             disposed = true;
                         };
                         comp.Start().Join(1000);
                         comp.Stop().Join(1000);
                         Assert.AreEqual(ExecutionState.Ready, comp.State);
                         Assert.IsFalse(disposed);
                     }
                     [TestMethod]
                     public void SelfDisposeOnStop() {
                         var comp = new MockRunnableComponent(true, true);
                         bool disposed = false;
-                        Exception lastError = null;
+                        comp.MockDispose = (disposing) => {
-                        comp.MockDispose = (disposing, error) => {
                             disposed = true;
-                            lastError = error;
                         };
                         comp.Start().Join(1000);
                         comp.Stop().Join(1000);
                         Assert.AreEqual(ExecutionState.Ready, comp.State);
                         Assert.IsFalse(disposed);
                         comp.MockStop = () => {
                             comp.Dispose();
                             return Promise.Success;
                         };
                         comp.Start().Join(1000);
                         comp.Stop().Join(1000);
                         Assert.AreEqual(ExecutionState.Disposed, comp.State);
                         Assert.IsTrue(disposed);
                     }
                     [TestMethod]
                     public void StartCancelTest() {
                         var comp = new MockRunnableComponent(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.IsTrue(comp.LastError is OperationCanceledException);
                         comp.Dispose();
                     }
                     [TestMethod]
                     public void StartStopTest() {
                         var stop = new Signal();
                         var comp = new MockRunnableComponent(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 MockRunnableComponent(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 MockRunnableComponent(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.IsTrue(comp.LastError is OperationCanceledException);
                         comp.Dispose();
                     }
                 }
             }

Implab/Components/Disposable.cs +2 0

             using Implab.Diagnostics;
             using System;
+            using System.Diagnostics.CodeAnalysis;
             using System.Threading;
             namespace Implab.Components {
                 /// <summary>
                 /// Base class the objects which support disposing.
                 /// </summary>
                 public class Disposable : IDisposable {
                     int m_disposed;
                     public event EventHandler Disposed;
                     public bool IsDisposed {
                         get {
                             Thread.MemoryBarrier();
                             return m_disposed != 0;
                         }
                     }
                     /// <summary>
                     /// Asserts the object is not disposed.
                     /// </summary>
                     /// <exception cref="ObjectDisposedException">The object is disposed</exception>
                     /// <remarks>
                     /// Успешная проверка того, что объект не освобожден еще не гарантирует, что он не
                     /// будет освобожден сразу после нее, поэтому методы использующие проверку должны
                     /// учитывать, что объект может быть освобожден из параллельного потока.
                     /// Данны метод служит для упрощения отладки ошибок при использовании объекта после его
                     /// освобождения.
                     /// </remarks>
                     /// <example>
                     /// // пример синхронизированного освобождения ресурсов
                     /// class FileStore : Disposable {
                     ///     readonly TextWriter m_file;
                     ///     readonly obejct m_sync = new object();
                     ///
                     ///     public FileStore(string file) {
                     ///         m_file = new TextWriter(File.OpenWrite(file));
                     ///     }
                     ///
                     ///     public void Write(string text) {
                     ///         lock(m_sync) {
                     ///             AssertNotDisposed();
                     ///             m_file.Write(text);
                     ///         }
                     ///     }
                     ///
                     ///     protected override void Dispose(bool disposing) {
                     ///         if (disposing)
                     ///             lock(m_sync) {
                     ///                 m_file.Dipose();
                     ///                 base.Dispose(true);
                     ///             }
                     ///         else
                     ///             base.Dispose(false);
                     ///     }
                     /// }
                     /// <example>
                     protected void AssertNotDisposed() {
                         Thread.MemoryBarrier();
                         if (m_disposed != 0)
                             throw new ObjectDisposedException(ToString());
                     }
                     /// <summary>
                     /// Вызывает событие <see cref="Disposed"/>
                     /// </summary>
                     /// <param name="disposing">Признак того, что нужно освободить ресурсы, иначе данный метод
                     /// вызван сборщиком мусора и нужно освобождать ТОЛЬКО неуправляемые ресурсы ТОЛЬКО этого
                     /// объекта.</param>
                     /// <remarks>
                     /// Данный метод вызывается гарантированно один раз даже при одновременном вызове <see cref="Dispose()"/>
                     /// из нескольких потоков.
                     /// </remarks>
                     protected virtual void Dispose(bool disposing) {
                         if (disposing) {
                             EventHandler temp = Disposed;
                             if (temp != null)
                                 temp(this, EventArgs.Empty);
                         }
                     }
+                    [SuppressMessage("Microsoft.Design", "CA1063:ImplementIDisposableCorrectly", Justification = "Dipose(bool) and GC.SuppessFinalize are called")]
                     public void Dispose() {
                         if (Interlocked.Increment(ref m_disposed) == 1) {
                             Dispose(true);
                             GC.SuppressFinalize(this);
                         }
                     }
                     /// <summary>
                     /// Записывает сообщение об утечке объекта.
                     /// </summary>
                     protected virtual void ReportObjectLeaks() {
                         TraceLog.TraceWarning("The object is marked as disposable but isn't disposed properly: {0}", this);
                     }
                     ~Disposable() {
                         Dispose(false);
                         ReportObjectLeaks();
                     }
                 }
             }

Implab/Components/IRunnable.cs +11 -3

             using System;
             namespace Implab.Components {
-                public interface IRunnable {
+                /// <summary>
+                /// Interface for the component which performs a long running task.
+                /// </summary>
+                /// <remarks>
+                /// <para>The component also should implement <see cref="IDisposable"/> interface to be able to release used resources.</para>
+                /// <para>All methods of this interface must be a thread safe. If the operation is not applicable in the current state the
+                /// method should throw an exception and keep the current state unchanged.</para>
+                /// </remarks>
+                public interface IRunnable : IDisposable {
                     /// <summary>
-                    /// Starts this instance.
+                    /// Starts this instance
                     /// </summary>
                     IPromise Start();
                     /// <summary>
-                    /// Stops this instance. After the instance is stopped it can't be started again, stopping should be treated as gracefull and async dispose.
+                    /// Stops this instance, after the instance is stopped it can move to Failed, Ready or Disposed state, in case with the last it can't be reused.
                     /// </summary>
                     IPromise Stop();
                     ExecutionState State { get; }
                     event EventHandler<StateChangeEventArgs> StateChanged;
                     Exception LastError { get; }
                 }
             }

Implab/Components/PollingComponent.cs +3 -3

             using System;
             using System.Threading;
             using Implab.Diagnostics;
             namespace Implab.Components {
                 public class PollingComponent : RunnableComponent {
                     readonly Timer m_timer;
                     readonly Func<Func<ICancellationToken, IPromise>, IPromise> m_dispatcher;
                     readonly TimeSpan m_interval;
                     readonly object m_lock = new object();
                     ActionTask m_pending;
                     protected PollingComponent(TimeSpan interval, Func<Func<ICancellationToken, IPromise>, IPromise> dispatcher, bool initialized) : base(initialized) {
                         m_timer = new Timer(OnInternalTick);
                         m_interval = interval;
                         m_dispatcher = dispatcher;
                     }
                     protected override IPromise OnStart() {
                         m_timer.Change(TimeSpan.Zero, m_interval);
                         return base.OnStart();
                     }
                     void OnInternalTick(object state) {
                         if (StartTick()) {
                             try {
                                 if (m_dispatcher != null) {
                                     var result = m_dispatcher(OnTick);
                                     m_pending.CancellationRequested(result.Cancel);
                                     AwaitTick(result);
                                 } else {
                                     AwaitTick(OnTick(m_pending));
                                 }
                             } catch (Exception error) {
                                 HandleTickError(error);
                             }
                         }
                     }
                     /// <summary>
                     /// Checks wheather there is no running handler in the component and marks that the handler is starting.
                     /// </summary>
                     /// <returns>boolean value, true - the new tick handler may be invoked, false - a tick handler is already running or a component isn't running.</returns>
                     /// <remarks>
                     /// If the component is stopping no new handlers can be run. Every successful call to this method must be completed with either AwaitTick or HandleTickError handlers.
                     /// </remarks>
                     protected virtual bool StartTick() {
                         lock (m_lock) {
                             if (State != ExecutionState.Running || m_pending != null)
                                 return false;
                             // actually the component may be in a not running state here (stopping, disposed or what ever),
                             // but OnStop method also locks on the same object and will handle operation in m_pending
                             m_pending = new ActionTask(
                                 () => {
                                     // only one operation is running, it's safe to assing m_pending from it
                                     m_pending = null;
                                 },
                                 ex => {
                                     try {
                                         OnTickError(ex);
                                         // Analysis disable once EmptyGeneralCatchClause
                                     } catch {
                                     } finally {
                                         m_pending = null;
                                     }
                                     // suppress error
                                 },
                                 ex => {
                                     try {
                                         OnTickCancel(ex);
                                         // Analysis disable once EmptyGeneralCatchClause
                                     } catch {
                                     } finally {
                                         m_pending = null;
                                     }
                                     // supress cancellation
                                 },
                                 false
                             );
                             return true;
                         }
                     }
                     /// <summary>
                     /// Awaits the tick.
                     /// </summary>
                     /// <param name="tick">Tick.</param>
                     /// <remarks>
                     /// This method is called only after StartTick method and m_pending will hold the promise which should be fulfilled.
                     /// </remarks>
                     void AwaitTick(IPromise tick) {
                         if (tick == null) {
                             m_pending.Resolve();
                         } else {
                             tick.On(
                                 m_pending.Resolve,
                                 m_pending.Reject,
                                 m_pending.CancelOperation
                             );
                         }
                     }
                     /// <summary>
                     /// Handles the tick error.
                     /// </summary>
                     /// <remarks>
                     /// This method is called only after StartTick method and m_pending will hold the promise which should be fulfilled.
                     /// </remarks>
                     void HandleTickError(Exception error) {
                         m_pending.Reject(error);
                     }
                     protected virtual void OnTickError(Exception error) {
                     }
                     protected virtual void OnTickCancel(Exception error) {
                     }
                     /// <summary>
                     /// Invoked when the timer ticks, use this method to implement your logic
                     /// </summary>
                     protected virtual IPromise OnTick(ICancellationToken cancellationToken) {
                         return Promise.Success;
                     }
                     protected override IPromise OnStop() {
                         m_timer.Change(-1, -1);
                         // the component is in the stopping state
                         lock (m_lock) {
                             // after this lock no more pending operations could be created
                             var pending = m_pending;
                             // m_pending could be fulfilled and set to null already
                             if (pending != null) {
                                 pending.Cancel();
                                 return pending.Then(base.OnStop);
                             }
                         }
                         return base.OnStop();
                     }
-                    protected override void Dispose(bool disposing, Exception lastError) {
+                    protected override void Dispose(bool disposing) {
                         if (disposing)
-                            Safe.Dispose(m_timer);
+                            m_timer.Dispose();
-                        base.Dispose(disposing, lastError);
+                        base.Dispose(disposing);
                     }
                 }
             }

Implab/Components/RunnableComponent.cs +8 -15

             using System;
+            using System.Diagnostics.CodeAnalysis;
             namespace Implab.Components {
                 public abstract class RunnableComponent : IDisposable, IRunnable, IInitializable {
                     enum Commands {
                         Ok = 0,
                         Fail,
                         Init,
                         Start,
                         Stop,
                         Dispose,
                         Reset,
                         Last = Reset
                     }
                     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.Ready, Commands.Ok);
                             Edge(ExecutionState.Stopping, ExecutionState.Disposed, Commands.Dispose);
                             Edge(ExecutionState.Failed, ExecutionState.Disposed, Commands.Dispose);
                             Edge(ExecutionState.Failed, ExecutionState.Initializing, Commands.Reset);
                         }
                         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;
                     readonly bool m_reusable;
                     public event EventHandler<StateChangeEventArgs> StateChanged;
                     /// <summary>
                     /// Initializes component state.
                     /// </summary>
                     /// <param name="initialized">If set, the component initial state is <see cref="ExecutionState.Ready"/> and the component is ready to start, otherwise initialization is required.</param>
                     /// <param name="reusable">If set, the component may start after it has been stopped, otherwise the component is disposed after being stopped.</param>
                     protected RunnableComponent(bool initialized, bool reusable) {
                         m_stateMachine = new StateMachine(initialized ? ExecutionState.Ready : ExecutionState.Created);
                         m_reusable = reusable;
                         DisposeTimeout = 10000;
                     }
                     /// <summary>
                     /// Initializes component state. The component created with this constructor is not reusable, i.e. it will be disposed after stop.
                     /// </summary>
                     /// <param name="initialized">If set, the component initial state is <see cref="ExecutionState.Ready"/> and the component is ready to start, otherwise initialization is required.</param>
                     protected RunnableComponent(bool initialized) : this(initialized, false) {
                     }
                     /// <summary>
                     /// Gets or sets the timeout to wait for the pending operation to complete. If the pending operation doesn't finish than the component will be disposed anyway.
                     /// </summary>
                     protected int DisposeTimeout {
                         get;
                         set;
                     }
                     void ThrowInvalidCommand(Commands cmd) {
                         if (m_stateMachine.State == ExecutionState.Disposed)
                             throw new ObjectDisposedException(ToString());
                         throw new InvalidOperationException(String.Format("Command {0} is not allowed in the state {1}", cmd, m_stateMachine.State));
                     }
                     bool MoveIfInState(Commands cmd, IPromise pending, Exception error, ExecutionState state) {
                         ExecutionState prev, current;
                         lock (m_stateMachine) {
                             if (m_stateMachine.State != state)
                                 return false;
                             prev = m_stateMachine.State;
                             if (!m_stateMachine.Move(cmd))
                                 ThrowInvalidCommand(cmd);
                             current = m_stateMachine.State;
                             m_pending = pending;
                             m_lastError = error;
                         }
                         if (prev != current)
                             OnStateChanged(prev, current, error);
                         return true;
                     }
                     bool MoveIfPending(Commands cmd, IPromise pending, Exception error, IPromise expected) {
                         ExecutionState prev, current;
                         lock (m_stateMachine) {
                             if (m_pending != expected)
                                 return false;
                             prev = m_stateMachine.State;
                             if (!m_stateMachine.Move(cmd))
                                 ThrowInvalidCommand(cmd);
                             current = m_stateMachine.State;
                             m_pending = pending;
                             m_lastError = error;
                         }
                         if (prev != current)
                             OnStateChanged(prev, current, error);
                         return true;
                     }
                     IPromise Move(Commands cmd, IPromise pending, Exception error) {
                         ExecutionState prev, current;
                         IPromise ret;
                         lock (m_stateMachine) {
                             prev = m_stateMachine.State;
                             if (!m_stateMachine.Move(cmd))
                                 ThrowInvalidCommand(cmd);
                             current = m_stateMachine.State;
                             ret = m_pending;
                             m_pending = pending;
                             m_lastError = error;
                         }
                         if(prev != current)
                             OnStateChanged(prev, current, error);
                         return ret;
                     }
                     protected virtual void OnStateChanged(ExecutionState previous, ExecutionState current, Exception error) {
                         var h = StateChanged;
                         if (h != null)
                             h(this, new StateChangeEventArgs {
                                 State = current,
                                 LastError = error
                             });
                     }
                     /// <summary>
                     /// Moves the component from running to failed state.
                     /// </summary>
                     /// <param name="error">The exception which is describing the error.</param>
                     protected bool Fail(Exception error) {
                         return MoveIfInState(Commands.Fail, null, error, ExecutionState.Running);
                     }
                     /// <summary>
                     /// Tries to reset <see cref="ExecutionState.Failed"/> state to <see cref="ExecutionState.Ready"/>.
                     /// </summary>
                     /// <returns>True if component is reset to <see cref="ExecutionState.Ready"/>, false if the componet wasn't
                     /// in <see cref="ExecutionState.Failed"/> state.</returns>
                     /// <remarks>
                     /// This method checks the current state of the component and if it's in <see cref="ExecutionState.Failed"/>
                     /// moves component to <see cref="ExecutionState.Initializing"/>.
                     /// The <see cref="OnResetState()"/> is called and if this method completes succesfully the component moved
                     /// to <see cref="ExecutionState.Ready"/> state, otherwise the component is moved to <see cref="ExecutionState.Failed"/>
                     /// state. If <see cref="OnResetState()"/> throws an exception it will be propagated by this method to the caller.
                     /// </remarks>
                     protected bool ResetState() {
                         if (!MoveIfInState(Commands.Reset, null, null, ExecutionState.Failed))
                             return false;
                         try {
                             OnResetState();
                             Move(Commands.Ok, null, null);
                             return true;
                         } catch (Exception err) {
                             Move(Commands.Fail, null, err);
                             throw;
                         }
                     }
                     /// <summary>
                     /// This method is called by <see cref="ResetState"/> to reinitialize component in the failed state.
                     /// </summary>
                     /// <remarks>
                     /// Default implementation throws <see cref="NotImplementedException"/> which will cause the component
                     /// fail to reset it's state and it left in <see cref="ExecutionState.Failed"/> state.
                     /// If this method doesn't throw exceptions the component is moved to <see cref="ExecutionState.Ready"/> state.
                     /// </remarks>
                     protected virtual void OnResetState() {
                         throw new NotImplementedException();
                     }
                     IPromise InvokeAsync(Commands cmd, Func<IPromise> action, Action<IPromise, IDeferred> chain) {
                         IPromise promise = null;
                         IPromise prev;
                         var task = new ActionChainTask(action, null, null, true);
                         Action<Exception> errorOrCancel = e => {
                             if (e == null)
                                 e = new OperationCanceledException();
                             MoveIfPending(Commands.Fail, null, e, promise);
                             throw new PromiseTransientException(e);
                         };
                         promise = task.Then(
                             () => MoveIfPending(Commands.Ok, null, null, promise),
                             errorOrCancel,
                             errorOrCancel
                         );
                         prev = Move(cmd, promise, null);
                         if (prev == null)
                             task.Resolve();
                         else
                             chain(prev, task);
                         return promise;
                     }
                     #region IInitializable implementation
                     public void Initialize() {
                         Move(Commands.Init, null, null);
                         try {
                             OnInitialize();
                             Move(Commands.Ok, null, null);
                         } catch (Exception err) {
                             Move(Commands.Fail, null, err);
                             throw;
                         }
                     }
                     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() {
                         var pending = InvokeAsync(Commands.Stop, OnStop, StopPending);
                         return m_reusable ? pending : pending.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
                     /// <summary>
                     /// Releases all resource used by the <see cref="Implab.Components.RunnableComponent"/> object.
                     /// </summary>
                     /// <remarks>
                     /// <para>Will not try to stop the component, it will just release all resources.
                     /// To cleanup the component gracefully use <see cref="Stop()"/> method.</para>
                     /// <para>
                     /// In normal cases the <see cref="Dispose()"/> method shouldn't be called, the call to the <see cref="Stop()"/>
                     /// method is sufficient to cleanup the component. Call <see cref="Dispose()"/> only to cleanup after errors,
                     /// especially if <see cref="Stop"/> method is failed. Using this method insted of <see cref="Stop()"/> may
                     /// lead to the data loss by the component.
                     /// </para></remarks>
+                    [SuppressMessage("Microsoft.Design", "CA1063:ImplementIDisposableCorrectly", Justification = "Dipose(bool) and GC.SuppessFinalize are called")]
                     public void Dispose() {
                         IPromise pending;
                         lock (m_stateMachine) {
                             if (m_stateMachine.State == ExecutionState.Disposed)
                                 return;
-                            pending = Move(Commands.Dispose, null, null);
+                            Move(Commands.Dispose, null, null);
                         }
                         GC.SuppressFinalize(this);
-                        if (pending != null) {
+                        Dispose(true);
-                            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, null);
                     }
                     ~RunnableComponent() {
-                        Dispose(false, null);
+                        Dispose(false);
                     }
                     #endregion
                     /// <summary>
                     /// Releases all resources used by the component, called automatically, override this method to implement your cleanup.
                     /// </summary>
                     /// <param name="disposing">true if this method is called during normal dispose process.</param>
-                    /// <param name="lastError">The last error which occured during the component stop.</param>
+                    /// <param name="pending">The operation which is currenty pending</param>
-                    protected virtual void Dispose(bool disposing, Exception lastError) {
+                    protected virtual void Dispose(bool disposing) {
                     }
                 }
             }

Implab/Formats/JSON/JSONParser.cs +1 -1

             using System;
             using System.Diagnostics;
             using System.IO;
             using Implab.Automaton;
             using Implab.Automaton.RegularExpressions;
             using System.Linq;
             using Implab.Components;
             using System.Collections.Generic;
             namespace Implab.Formats.JSON {
                 /// <summary>
                 /// Pull парсер JSON данных.
                 /// </summary>
                 /// <remarks>
                 /// Следует отметить отдельную интерпретацию свойства <see cref="Level"/>,
                 /// оно означает текущий уровень вложенности объектов, однако закрывающий
                 /// элемент объекта и массива имеет уровень меньше, чем сам объект.
                 /// <code>
                 /// { // Level = 1
                 ///     "name" : "Peter", // Level = 1
                 ///     "address" : { // Level = 2
                 ///         city : "Stern" // Level = 2
                 ///     } // Level = 1
                 /// } // Level = 0
                 /// </code>
                 /// </remarks>
                 public class JSONParser : Disposable {
                     enum MemberContext {
                         MemberName,
                         MemberValue
                     }
                     #region Parser rules
                     struct ParserContext {
                         readonly int[,] m_dfa;
                         int m_state;
                         readonly JSONElementContext m_elementContext;
                         public ParserContext(int[,] dfa, int state, JSONElementContext context) {
                             m_dfa = dfa;
                             m_state = state;
                             m_elementContext = context;
                         }
                         public bool Move(JsonTokenType token) {
                             var next = m_dfa[m_state, (int)token];
                             if (next == AutomatonConst.UNREACHABLE_STATE)
                                 return false;
                             m_state = next;
                             return true;
                         }
                         public JSONElementContext ElementContext {
                             get { return m_elementContext; }
                         }
                     }
                     static readonly ParserContext _jsonContext;
                     static readonly ParserContext _objectContext;
                     static readonly ParserContext _arrayContext;
                     static JSONParser() {
                         var valueExpression = MakeToken(JsonTokenType.BeginArray, JsonTokenType.BeginObject, JsonTokenType.Literal, JsonTokenType.Number, JsonTokenType.String);
                         var memberExpression = MakeToken(JsonTokenType.String).Cat(MakeToken(JsonTokenType.NameSeparator)).Cat(valueExpression);
                         var objectExpression = memberExpression
                             .Cat(
                                 MakeToken(JsonTokenType.ValueSeparator)
                                 .Cat(memberExpression)
                                 .EClosure()
                             )
                             .Optional()
                             .Cat(MakeToken(JsonTokenType.EndObject))
                             .End();
                         var arrayExpression = valueExpression
                             .Cat(
                                 MakeToken(JsonTokenType.ValueSeparator)
                                 .Cat(valueExpression)
                                 .EClosure()
                             )
                             .Optional()
                             .Cat(MakeToken(JsonTokenType.EndArray))
                             .End();
                         var jsonExpression = valueExpression.End();
                         _jsonContext = CreateParserContext(jsonExpression, JSONElementContext.None);
                         _objectContext = CreateParserContext(objectExpression, JSONElementContext.Object);
                         _arrayContext = CreateParserContext(arrayExpression, JSONElementContext.Array);
                     }
                     static Token MakeToken(params JsonTokenType[] input) {
                         return Token.New( input.Select(t => (int)t).ToArray() );
                     }
                     static ParserContext CreateParserContext(Token expr, JSONElementContext context) {
                         var dfa = new DFATable();
                         var builder = new RegularExpressionVisitor(dfa);
                         expr.Accept(builder);
                         builder.BuildDFA();
                         return new ParserContext(dfa.CreateTransitionTable(), dfa.InitialState, context);
                     }
                     #endregion
                     readonly JSONScanner m_scanner;
                     MemberContext m_memberContext;
                     JSONElementType m_elementType;
                     object m_elementValue;
                     string m_memberName = String.Empty;
                     Stack<ParserContext> m_stack = new Stack<ParserContext>();
                     ParserContext m_context = _jsonContext;
                     /// <summary>
                     /// Создает новый парсер на основе строки, содержащей JSON
                     /// </summary>
                     /// <param name="text"></param>
                     public JSONParser(string text) {
                         Safe.ArgumentNotEmpty(text, "text");
                         m_scanner = new JSONScanner(text);
                     }
                     /// <summary>
                     /// Создает новый экземпляр парсера, на основе текстового потока.
                     /// </summary>
                     /// <param name="reader">Текстовый поток.</param>
                     public JSONParser(TextReader reader) {
                         Safe.ArgumentNotNull(reader, "reader");
                         m_scanner = new JSONScanner(reader);
                     }
                     public int Level {
                         get { return m_stack.Count; }
                     }
                     /// <summary>
                     /// Тип текущего элемента на котором стоит парсер.
                     /// </summary>
                     public JSONElementType ElementType {
                         get { return m_elementType; }
                     }
                     /// <summary>
                     /// Имя элемента - имя свойства родительского контейнера. Для элементов массивов и корневого всегда
                     /// пустая строка.
                     /// </summary>
                     public string ElementName {
                         get { return m_memberName; }
                     }
                     /// <summary>
                     /// Значение элемента. Только для элементов типа <see cref="JSONElementType.Value"/>, для остальных <c>null</c>
                     /// </summary>
                     public object ElementValue {
                         get { return m_elementValue; }
                     }
                     /// <summary>
                     /// Читает слеюудущий объект из потока
                     /// </summary>
                     /// <returns><c>true</c> - операция чтения прошла успешно, <c>false</c> - конец данных</returns>
                     public bool Read() {
                         object tokenValue;
                         JsonTokenType tokenType;
                         m_memberName = String.Empty;
                         while (m_scanner.ReadToken(out tokenValue, out tokenType)) {
                             if(!m_context.Move(tokenType))
                                 UnexpectedToken(tokenValue, tokenType);
                             switch (tokenType) {
                                 case JsonTokenType.BeginObject:
                                     m_stack.Push(m_context);
                                     m_context = _objectContext;
                                     m_elementValue = null;
                                     m_memberContext = MemberContext.MemberName;
                                     m_elementType = JSONElementType.BeginObject;
                                     return true;
                                 case JsonTokenType.EndObject:
                                     if (m_stack.Count == 0)
                                         UnexpectedToken(tokenValue, tokenType);
                                     m_context = m_stack.Pop();
                                     m_elementValue = null;
                                     m_elementType = JSONElementType.EndObject;
                                     return true;
                                 case JsonTokenType.BeginArray:
                                     m_stack.Push(m_context);
                                     m_context = _arrayContext;
                                     m_elementValue = null;
                                     m_memberContext = MemberContext.MemberValue;
                                     m_elementType = JSONElementType.BeginArray;
                                     return true;
                                 case JsonTokenType.EndArray:
                                     if (m_stack.Count == 0)
                                         UnexpectedToken(tokenValue, tokenType);
                                     m_context = m_stack.Pop();
                                     m_elementValue = null;
                                     m_elementType = JSONElementType.EndArray;
                                     return true;
                                 case JsonTokenType.String:
                                     if (m_memberContext == MemberContext.MemberName) {
                                         m_memberName = (string)tokenValue;
                                         break;
                                     }
                                     m_elementType = JSONElementType.Value;
                                     m_elementValue = tokenValue;
                                     return true;
                                 case JsonTokenType.Number:
                                     m_elementType = JSONElementType.Value;
                                     m_elementValue = tokenValue;
                                     return true;
                                 case JsonTokenType.Literal:
                                     m_elementType = JSONElementType.Value;
                                     m_elementValue = ParseLiteral((string)tokenValue);
                                     return true;
                                 case JsonTokenType.NameSeparator:
                                     m_memberContext = MemberContext.MemberValue;
                                     break;
                                 case JsonTokenType.ValueSeparator:
                                     m_memberContext = m_context.ElementContext == JSONElementContext.Object ? MemberContext.MemberName : MemberContext.MemberValue;
                                     break;
                                 default:
                                     UnexpectedToken(tokenValue, tokenType);
                                     break;
                             }
                         }
                         if (m_context.ElementContext != JSONElementContext.None)
                             throw new ParserException("Unexpedted end of data");
                         EOF = true;
                         return false;
                     }
                     object ParseLiteral(string literal) {
                         switch (literal) {
                             case "null":
                                 return null;
                             case "false":
                                 return false;
                             case "true":
                                 return true;
                             default:
                                 UnexpectedToken(literal, JsonTokenType.Literal);
                                 return null; // avoid compliler error
                         }
                     }
                     void UnexpectedToken(object value, JsonTokenType tokenType) {
                         throw new ParserException(String.Format("Unexpected token {0}: '{1}'", tokenType, value));
                     }
                     /// <summary>
                     /// Признак конца потока
                     /// </summary>
                     public bool EOF {
                         get;
                         private set;
                     }
                     protected override void Dispose(bool disposing) {
                         if (disposing)
-                            Safe.Dispose(m_scanner);
+                            m_scanner.Dispose();
                     }
                     /// <summary>
                     /// Переходит в конец текущего объекта.
                     /// </summary>
                     public void SeekElementEnd() {
                         var level = Level - 1;
                         Debug.Assert(level >= 0);
                         while (Level != level)
                             Read();
                     }
                 }
             }

Implab/Formats/JSON/JSONScanner.cs +1 -1

             using System;
             using System.Globalization;
             using Implab.Automaton;
             using System.Text;
             using Implab.Components;
             using System.IO;
             namespace Implab.Formats.JSON {
                 /// <summary>
                 /// Сканнер (лексер), разбивающий поток символов на токены JSON.
                 /// </summary>
                 public class JSONScanner : Disposable {
                     readonly StringBuilder m_builder = new StringBuilder();
                     readonly ScannerContext<JSONGrammar.TokenType> m_jsonContext = JSONGrammar.Instance.JsonExpression;
                     readonly ScannerContext<JSONGrammar.TokenType> m_stringContext = JSONGrammar.Instance.JsonStringExpression;
                     readonly TextScanner m_scanner;
                     /// <summary>
                     /// Создает новый экземпляр сканнера
                     /// </summary>
                     public JSONScanner(string text) {
                         Safe.ArgumentNotEmpty(text, "text");
                         m_scanner = new StringScanner(text);
                     }
                     public JSONScanner(TextReader reader, int bufferMax, int chunkSize) {
                         Safe.ArgumentNotNull(reader, "reader");
                         m_scanner = new ReaderScanner(reader, bufferMax, chunkSize);
                     }
                     public JSONScanner(TextReader reader) : this(reader, 1024*1024, 1024){
                     }
                     /// <summary>
                     /// Читает следующий лексический элемент из входных данных.
                     /// </summary>
                     /// <param name="tokenValue">Возвращает значение прочитанного токена.</param>
                     /// <param name="tokenType">Возвращает тип прочитанного токена.</param>
                     /// <returns><c>true</c> - чтение произведено успешно. <c>false</c> - достигнут конец входных данных</returns>
                     /// <remarks>В случе если токен не распознается, возникает исключение. Значения токенов обрабатываются, т.е.
                     /// в строках обрабатываются экранированные символы, числа становтся типа double.</remarks>
                     public bool ReadToken(out object tokenValue, out JsonTokenType tokenType) {
                         JSONGrammar.TokenType[] tag;
                         while (m_jsonContext.Execute(m_scanner, out tag)) {
                             switch (tag[0]) {
                                 case JSONGrammar.TokenType.StringBound:
                                     tokenValue = ReadString();
                                     tokenType = JsonTokenType.String;
                                     break;
                                 case JSONGrammar.TokenType.Number:
                                     tokenValue = Double.Parse(m_scanner.GetTokenValue(), CultureInfo.InvariantCulture);
                                     tokenType = JsonTokenType.Number;
                                     break;
                                 case JSONGrammar.TokenType.Whitespace:
                                     continue;
                                 default:
                                     tokenType = (JsonTokenType)tag[0];
                                     tokenValue = m_scanner.GetTokenValue();
                                     break;
                             }
                             return true;
                         }
                         tokenValue = null;
                         tokenType = JsonTokenType.None;
                         return false;
                     }
                     string ReadString() {
                         int pos = 0;
                         var buf = new char[6]; // the buffer for unescaping chars
                         JSONGrammar.TokenType[] tag;
                         m_builder.Clear();
                         while (m_stringContext.Execute(m_scanner, out tag)) {
                             switch (tag[0]) {
                                 case JSONGrammar.TokenType.StringBound:
                                     return m_builder.ToString();
                                 case JSONGrammar.TokenType.UnescapedChar:
                                     m_scanner.CopyTokenTo(m_builder);
                                     break;
                                 case JSONGrammar.TokenType.EscapedUnicode: // \xXXXX - unicode escape sequence
                                     m_scanner.CopyTokenTo(buf, 0);
                                     m_builder.Append(StringTranslator.TranslateHexUnicode(buf, 2));
                                     pos++;
                                     break;
                                 case JSONGrammar.TokenType.EscapedChar:  // \t - escape sequence
                                     m_scanner.CopyTokenTo(buf, 0);
                                     m_builder.Append(StringTranslator.TranslateEscapedChar(buf[1]));
                                     break;
                             }
                         }
                         throw new ParserException("Unexpected end of data");
                     }
                     protected override void Dispose(bool disposing) {
                         if (disposing)
-                            Safe.Dispose(m_scanner);
+                            m_scanner.Dispose();
                         base.Dispose(disposing);
                     }
                 }
             }

Implab/PromiseExtensions.cs +33 -5

             using System.Threading;
             using System;
             using Implab.Diagnostics;
             using System.Collections.Generic;
             using System.Linq;
             namespace Implab {
                 public static class PromiseExtensions {
                     public static IPromise<T> DispatchToCurrentContext<T>(this IPromise<T> that) {
                         Safe.ArgumentNotNull(that, "that");
                         var context = SynchronizationContext.Current;
                         if (context == null)
                             return that;
                         var p = new SyncContextPromise<T>(context);
                         p.CancellationRequested(that.Cancel);
                         that.On(
                             p.Resolve,
                             p.Reject,
                             p.CancelOperation
                         );
                         return p;
                     }
                     public static IPromise<T> DispatchToContext<T>(this IPromise<T> that, SynchronizationContext context) {
                         Safe.ArgumentNotNull(that, "that");
                         Safe.ArgumentNotNull(context, "context");
                         var p = new SyncContextPromise<T>(context);
                         p.CancellationRequested(that.Cancel);
                         that.On(
                             p.Resolve,
                             p.Reject,
                             p.CancelOperation
                         );
                         return p;
                     }
                     /// <summary>
                     /// Ensures the dispatched.
                     /// </summary>
                     /// <returns>The dispatched.</returns>
                     /// <param name="that">That.</param>
                     /// <param name="head">Head.</param>
                     /// <param name="cleanup">Cleanup.</param>
                     /// <typeparam name="TPromise">The 1st type parameter.</typeparam>
                     /// <typeparam name="T">The 2nd type parameter.</typeparam>
                     public static TPromise EnsureDispatched<TPromise, T>(this TPromise that, IPromise<T> head, Action<T> cleanup) where TPromise : IPromise {
                         Safe.ArgumentNotNull(that, "that");
                         Safe.ArgumentNotNull(head, "head");
                         that.On(() => head.On(cleanup), PromiseEventType.Cancelled);
                         return that;
                     }
                     /// <summary>
                     /// Adds a cancellation point to the chain of promises. When a cancellation request reaches the cancellation point the operation is
                     /// cancelled immediatelly, and the request is passed towards. If the operation at the higher level can not be cancelled is't result
                     /// will be collected with <paramref name="cleanup"/> callback.
                     /// </summary>
                     /// <typeparam name="T">The type of the promise result.</typeparam>
                     /// <param name="that">The promise to which the cancellation point should be attached.</param>
                     /// <param name="cleanup">The callback which is used to cleanup the result of the operation if the cancellation point is cancelled already.</param>
                     /// <returns>The promise</returns>
                     public static IPromise<T> CancellationPoint<T>(this IPromise<T> that, Action<T> cleanup) {
                         var meduim = new Promise<T>();
                         that.On(meduim.Resolve, meduim.Reject, meduim.CancelOperation);
                         meduim.CancellationRequested(that.Cancel);
                         meduim.CancellationRequested(meduim.CancelOperation);
                         if (cleanup != null)
                             meduim.On((Action<T>)null, null, (e) => {
                                 that.On(cleanup);
                             });
                         return meduim;
                     }
                     public static AsyncCallback AsyncCallback<T>(this Promise<T> that, Func<IAsyncResult, T> callback) {
                         Safe.ArgumentNotNull(that, "that");
                         Safe.ArgumentNotNull(callback, "callback");
                         var op = TraceContext.Instance.CurrentOperation;
                         return ar => {
                             TraceContext.Instance.EnterLogicalOperation(op, false);
                             try {
                                 that.Resolve(callback(ar));
                             } catch (Exception err) {
                                 that.Reject(err);
                             } finally {
                                 TraceContext.Instance.Leave();
                             }
                         };
                     }
                     static void CancelByTimeoutCallback(object cookie) {
                         ((ICancellable)cookie).Cancel(new TimeoutException());
                     }
                     /// <summary>
                     /// Cancells promise after the specified timeout is elapsed.
                     /// </summary>
                     /// <param name="that">The promise to cancel on timeout.</param>
                     /// <param name="milliseconds">The timeout in milliseconds.</param>
                     /// <typeparam name="TPromise">The 1st type parameter.</typeparam>
                     public static TPromise Timeout<TPromise>(this TPromise that, int milliseconds) where TPromise : IPromise {
                         Safe.ArgumentNotNull(that, "that");
                         var timer = new Timer(CancelByTimeoutCallback, that, milliseconds, -1);
                         that.On(timer.Dispose, PromiseEventType.All);
                         return that;
                     }
                     public static IPromise PromiseAll(this IEnumerable<IPromise> that) {
                         Safe.ArgumentNotNull(that, "that");
                         return PromiseAll(that.ToList());
                     }
                     public static IPromise<T[]> PromiseAll<T>(this IEnumerable<IPromise<T>> that) {
+                        return PromiseAll(that, null);
+                    }
+                    public static IPromise<T[]> PromiseAll<T>(this IEnumerable<IPromise<T>> that, Action<T> cleanup) {
                         Safe.ArgumentNotNull(that, "that");
-                        return PromiseAll(that.ToList());
+                        return PromiseAll(that.ToList(), cleanup);
                     }
                     public static IPromise PromiseAll(this ICollection<IPromise> that) {
                         Safe.ArgumentNotNull(that, "that");
                         int count = that.Count;
                         int errors = 0;
                         var medium = new Promise();
                         if (count == 0) {
                             medium.Resolve();
                             return medium;
                         }
                         medium.On(() => {
                             foreach (var p2 in that)
                                 p2.Cancel();
                         }, PromiseEventType.ErrorOrCancel);
                         foreach (var p in that)
                             p.On(
                                 () => {
                                     if (Interlocked.Decrement(ref count) == 0)
                                         medium.Resolve();
                                 },
                                 error => {
                                     if (Interlocked.Increment(ref errors) == 1)
                                         medium.Reject(
                                             new Exception("The dependency promise is failed", error)
                                         );
                                 },
                                 reason => {
                                     if (Interlocked.Increment(ref errors) == 1)
                                         medium.Cancel(
                                             new Exception("The dependency promise is cancelled")
                                         );
                                 }
                             );
                         return medium;
                     }
                     public static IPromise<T[]> PromiseAll<T>(this ICollection<IPromise<T>> that) {
+                        return PromiseAll(that, null);
+                    }
+                    /// <summary>
+                    /// Creates a new promise which will be satisfied when all promises are satisfied.
+                    /// </summary>
+                    /// <typeparam name="T"></typeparam>
+                    /// <param name="that"></param>
+                    /// <param name="cleanup">A callback used to cleanup already resolved promises in case of an error</param>
+                    /// <returns></returns>
+                    public static IPromise<T[]> PromiseAll<T>(this ICollection<IPromise<T>> that, Action<T> cleanup) {
                         Safe.ArgumentNotNull(that, "that");
+                        int count = that.Count;
-                        int count = that.Count;
+                        if (count == 0)
+                            return Promise<T[]>.FromResult(new T[0]);
                         int errors = 0;
                         var medium = new Promise<T[]>();
                         var results = new T[that.Count];
                         medium.On(() => {
-                            foreach (var p2 in that)
+                            foreach (var p2 in that) {
                                 p2.Cancel();
+                                if (cleanup != null)
+                                    p2.On(cleanup);
+                            }
                         }, PromiseEventType.ErrorOrCancel);
                         int i = 0;
                         foreach (var p in that) {
                             var idx = i;
                             p.On(
                                 x => {
                                     results[idx] = x;
                                     if (Interlocked.Decrement(ref count) == 0)
                                         medium.Resolve(results);
                                 },
                                 error => {
                                     if (Interlocked.Increment(ref errors) == 1)
                                         medium.Reject(
                                             new Exception("The dependency promise is failed", error)
                                         );
                                 },
                                 reason => {
                                     if (Interlocked.Increment(ref errors) == 1)
                                         medium.Cancel(
                                             new Exception("The dependency promise is cancelled", reason)
                                         );
                                 }
                             );
                             i++;
                         }
                         return medium;
                     }
                     public static IPromise Then(this IPromise that, Action success, Action<Exception> error, Action<Exception> cancel) {
                         Safe.ArgumentNotNull(that, "that");
                         var d = new ActionTask(success, error, cancel, false);
                         that.On(d.Resolve, d.Reject, d.CancelOperation);
                         d.CancellationRequested(that.Cancel);
                         return d;
                     }
                     public static IPromise Then(this IPromise that, Action success, Action<Exception> error) {
                         return Then(that, success, error, null);
                     }
                     public static IPromise Then(this IPromise that, Action success) {
                         return Then(that, success, null, null);
                     }
                     public static IPromise<T> Then<T>(this IPromise that, Func<T> success, Func<Exception, T> error, Func<Exception, T> cancel) {
                         Safe.ArgumentNotNull(that, "that");
                         var d = new FuncTask<T>(success, error, cancel, false);
                         that.On(d.Resolve, d.Reject, d.CancelOperation);
                         d.CancellationRequested(that.Cancel);
                         return d;
                     }
                     public static IPromise<T> Then<T>(this IPromise that, Func<T> success, Func<Exception, T> error) {
                         return Then(that, success, error, null);
                     }
                     public static IPromise<T> Then<T>(this IPromise that, Func<T> success) {
                         return Then(that, success, null, null);
                     }
                     public static IPromise<T2> Then<T, T2>(this IPromise<T> that, Func<T, T2> success, Func<Exception, T2> error, Func<Exception, T2> cancel) {
                         Safe.ArgumentNotNull(that, "that");
                         var d = new FuncTask<T, T2>(success, error, cancel, false);
                         that.On(d.Resolve, d.Reject, d.CancelOperation);
                         d.CancellationRequested(that.Cancel);
                         return d;
                     }
                     public static IPromise<T> Then<T>(this IPromise<T> that, Action<T> success, Func<Exception, T> error, Func<Exception, T> cancel) {
                         Safe.ArgumentNotNull(that, "that");
                         var d = new FuncTask<T, T>(
                             x => {
                                 success(x);
                                 return x;
                             },
                             error,
                             cancel,
                             false
                         );
                         that.On(d.Resolve, d.Reject, d.CancelOperation);
                         d.CancellationRequested(that.Cancel);
                         return d;
                     }
                     public static IPromise<T> Then<T>(this IPromise<T> that, Action<T> success, Func<Exception, T> error) {
                         return Then(that, success, error, null);
                     }
                     public static IPromise<T> Then<T>(this IPromise<T> that, Action<T> success) {
                         return Then(that, success, null, null);
                     }
                     public static IPromise<T2> Then<T, T2>(this IPromise<T> that, Func<T, T2> success, Func<Exception, T2> error) {
                         return Then(that, success, error, null);
                     }
                     public static IPromise<T2> Then<T, T2>(this IPromise<T> that, Func<T, T2> success) {
                         return Then(that, success, null, null);
                     }
                     public static IPromise<T> Always<T>(this IPromise<T> that, Action handler) {
                         Func<Exception, T> errorOrCancel;
                         if (handler != null)
                             errorOrCancel = e => {
                                 handler();
                                 throw new PromiseTransientException(e);
                             };
                         else
                             errorOrCancel = null;
                         return Then(
                             that,
                             x => {
                                 handler();
                                 return x;
                             },
                             errorOrCancel,
                             errorOrCancel);
                     }
                     public static IPromise Always(this IPromise that, Action handler) {
                         Action<Exception> errorOrCancel;
                         if (handler != null)
                             errorOrCancel = e => {
                                 handler();
                                 throw new PromiseTransientException(e);
                             };
                         else
                             errorOrCancel = null;
                         return Then(
                             that,
                             handler,
                             errorOrCancel,
                             errorOrCancel);
                     }
                     public static IPromise Error(this IPromise that, Action<Exception> handler, bool handleCancellation) {
                         Action<Exception> errorOrCancel;
                         if (handler != null)
                             errorOrCancel = e => {
                                 handler(e);
                                 throw new PromiseTransientException(e);
                             };
                         else
                             errorOrCancel = null;
                         return Then(that, null, errorOrCancel, handleCancellation ? errorOrCancel : null);
                     }
                     public static IPromise Error(this IPromise that, Action<Exception> handler) {
                         return Error(that, handler, false);
                     }
                     public static IPromise<T> Error<T>(this IPromise<T> that, Action<Exception> handler, bool handleCancellation) {
                         Func<Exception, T> errorOrCancel;
                         if (handler != null)
                             errorOrCancel = e => {
                                 handler(e);
                                 throw new PromiseTransientException(e);
                             };
                         else
                             errorOrCancel = null;
                         return Then(that, null, errorOrCancel, handleCancellation ? errorOrCancel : null);
                     }
                     public static IPromise<T> Error<T>(this IPromise<T> that, Action<Exception> handler) {
                         return Error(that, handler, false);
                     }
                     #region chain traits
                     public static IPromise Chain(this IPromise that, Func<IPromise> success, Func<Exception, IPromise> error, Func<Exception, IPromise> cancel) {
                         Safe.ArgumentNotNull(that, "that");
                         var d = new ActionChainTask(success, error, cancel, false);
                         that.On(d.Resolve, d.Reject, d.CancelOperation);
                         d.CancellationRequested(that.Cancel);
                         return d;
                     }
                     public static IPromise Chain(this IPromise that, Func<IPromise> success, Func<Exception, IPromise> error) {
                         return Chain(that, success, error, null);
                     }
                     public static IPromise Chain(this IPromise that, Func<IPromise> success) {
                         return Chain(that, success, null, null);
                     }
                     public static IPromise<T> Chain<T>(this IPromise that, Func<IPromise<T>> success, Func<Exception, IPromise<T>> error, Func<Exception, IPromise<T>> cancel) {
                         Safe.ArgumentNotNull(that, "that");
                         var d = new FuncChainTask<T>(success, error, cancel, false);
                         that.On(d.Resolve, d.Reject, d.CancelOperation);
                         if (success != null)
                             d.CancellationRequested(that.Cancel);
                         return d;
                     }
                     public static IPromise<T> Chain<T>(this IPromise that, Func<IPromise<T>> success, Func<Exception, IPromise<T>> error) {
                         return Chain(that, success, error, null);
                     }
                     public static IPromise<T> Chain<T>(this IPromise that, Func<IPromise<T>> success) {
                         return Chain(that, success, null, null);
                     }
                     public static IPromise<T2> Chain<T, T2>(this IPromise<T> that, Func<T, IPromise<T2>> success, Func<Exception, IPromise<T2>> error, Func<Exception, IPromise<T2>> cancel) {
                         Safe.ArgumentNotNull(that, "that");
                         var d = new FuncChainTask<T, T2>(success, error, cancel, false);
                         that.On(d.Resolve, d.Reject, d.CancelOperation);
                         if (success != null)
                             d.CancellationRequested(that.Cancel);
                         return d;
                     }
                     public static IPromise<T2> Chain<T, T2>(this IPromise<T> that, Func<T, IPromise<T2>> success, Func<Exception, IPromise<T2>> error) {
                         return Chain(that, success, error, null);
                     }
                     public static IPromise<T2> Chain<T, T2>(this IPromise<T> that, Func<T, IPromise<T2>> success) {
                         return Chain(that, success, null, null);
                     }
                     #endregion
             #if NET_4_5
                     public static PromiseAwaiter<T> GetAwaiter<T>(this IPromise<T> that) {
                         Safe.ArgumentNotNull(that, "that");
                         return new PromiseAwaiter<T>(that);
                     }
+                    public static PromiseAwaiter GetAwaiter(this IPromise that) {
+                        Safe.ArgumentNotNull(that, "that");
+                        return new PromiseAwaiter(that);
+                    }
             #endif
                 }
             }

General Comments 3

sergey

|

Auto status change to "Under Review"

sergey

|

ok, latest stable version should be in default

Write
Preview

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

	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