implab/ImplabNet Commit - r205:8200ab154c8a

Added ResetState to RunnableComponent to reset in case of failure...

cin -

r205:8200ab154c8a v2

parent child

Context file:

r205:8200ab154c8a

Collapse all files

Implab.Test/packages.config created 644 +4 0

@@ -0,0 +1,4
	1	<?xml version="1.0" encoding="utf-8"?>
	2	<packages>
	3	<package id="NUnit" version="2.6.4" targetFramework="net45" />
	4	</packages> No newline at end of file

Implab/Components/StateChangeEventArgs.cs created 644 +16 0

@@ -0,0 +1,16
	1	using System;
	2
	3	namespace Implab.Components
	4	{
	5	public class StateChangeEventArgs {
	6	/// <summary>
	7	/// The error information if any
	8	/// </summary>
	9	public Exception LastError { get; set; }
	10
	11	/// <summary>
	12	/// The state of the service corresponding to this event
	13	/// </summary>
	14	public ExecutionState State { get; set; }
	15	}
	16	}

Implab.Test/AsyncTests.cs +5 -5

             using System;
             using System.Reflection;
             using System.Threading;
             using Implab.Parallels;
             #if MONO
             using NUnit.Framework;
             using TestClassAttribute = NUnit.Framework.TestFixtureAttribute;
             using TestMethodAttribute = NUnit.Framework.TestAttribute;
             #else
             using Microsoft.VisualStudio.TestTools.UnitTesting;
             #endif
             namespace Implab.Test {
                 [TestClass]
                 public class AsyncTests {
                     [TestMethod]
                     public void ResolveTest() {
                         int res = -1;
                         var p = new Promise<int>();
                         p.Then(x => res = x);
                         p.Resolve(100);
                         Assert.AreEqual(100, res);
                     }
                     [TestMethod]
                     public void RejectTest() {
                         int res = -1;
                         Exception err = null;
                         var p = new Promise<int>();
                         p.Then(
                             x => res = x,
                             e => {
                                 err = e;
                                 return -2;
                             }
                         );
                         p.Reject(new ApplicationException("error"));
                         Assert.AreEqual(res, -1);
                         Assert.AreEqual(err.Message, "error");
                     }
                     [TestMethod]
                     public void CancelExceptionTest() {
                         var p = new Promise<bool>();
                         p.CancelOperation(null);
                         var p2 = p.Then(x => x, null, reason => {
                             throw new ApplicationException("CANCELLED");
                         });
                         try {
                             p2.Join();
                             Assert.Fail();
                         } catch (ApplicationException err) {
                             Assert.AreEqual("CANCELLED", err.InnerException.Message);
                         }
                     }
                     [TestMethod]
                     public void ContinueOnCancelTest() {
                         var p = new Promise<bool>();
                         p.CancelOperation(null);
                         var p2 = p
                             .Then(x => x, null, reason => {
                                 throw new ApplicationException("CANCELLED");
                             })
                             .Then(x => x, e => true);
                         Assert.AreEqual(true, p2.Join());
                     }
                     [TestMethod]
                     public void JoinSuccessTest() {
                         var p = new Promise<int>();
                         p.Resolve(100);
                         Assert.AreEqual(p.Join(), 100);
                     }
                     [TestMethod]
                     public void JoinFailTest() {
                         var p = new Promise<int>();
                         p.Reject(new ApplicationException("failed"));
                         try {
                             p.Join();
                             throw new ApplicationException("WRONG!");
                         } catch (TargetInvocationException err) {
                             Assert.AreEqual(err.InnerException.Message, "failed");
                         } catch {
                             Assert.Fail("Got wrong excaption");
                         }
                     }
                     [TestMethod]
                     public void MapTest() {
                         var p = new Promise<int>();
                         var p2 = p.Then(x => x.ToString());
                         p.Resolve(100);
                         Assert.AreEqual(p2.Join(), "100");
                     }
                     [TestMethod]
                     public void FixErrorTest() {
                         var p = new Promise<int>();
                         var p2 = p.Then(x => x, e => 101);
                         p.Reject(new Exception());
                         Assert.AreEqual(p2.Join(), 101);
                     }
                     [TestMethod]
                     public void ChainTest() {
                         var p1 = new Promise<int>();
                         var p3 = p1.Chain(x => {
                             var p2 = new Promise<string>();
                             p2.Resolve(x.ToString());
                             return p2;
                         });
                         p1.Resolve(100);
                         Assert.AreEqual(p3.Join(), "100");
                     }
                     [TestMethod]
                     public void ChainFailTest() {
                         var p1 = new Promise<int>();
                         var p3 = p1.Chain(x => {
                             var p2 = new Promise<string>();
                             p2.Reject(new Exception("DIE!!!"));
                             return p2;
                         });
                         p1.Resolve(100);
                         Assert.IsTrue(p3.IsResolved);
                     }
                     [TestMethod]
                     public void PoolTest() {
                         var pid = Thread.CurrentThread.ManagedThreadId;
                         var p = AsyncPool.Invoke(() => Thread.CurrentThread.ManagedThreadId);
                         Assert.AreNotEqual(pid, p.Join());
                     }
                     [TestMethod]
                     public void WorkerPoolSizeTest() {
                         var pool = new WorkerPool(5, 10, 1);
                         Assert.AreEqual(5, pool.PoolSize);
                         pool.Invoke(() => { Thread.Sleep(100000000); return 10; });
                         pool.Invoke(() => { Thread.Sleep(100000000); return 10; });
                         pool.Invoke(() => { Thread.Sleep(100000000); return 10; });
                         Assert.AreEqual(5, pool.PoolSize);
                         for (int i = 0; i < 100; i++)
                             pool.Invoke(() => { Thread.Sleep(100000000); return 10; });
                         Thread.Sleep(200);
                         Assert.AreEqual(10, pool.PoolSize);
                         pool.Dispose();
                     }
                     [TestMethod]
                     public void WorkerPoolCorrectTest() {
                         var pool = new WorkerPool(0,1000,100);
                         const int iterations = 1000;
                         int pending = iterations;
                         var stop = new ManualResetEvent(false);
                         var count = 0;
                         for (int i = 0; i < iterations; i++) {
                             pool
                                 .Invoke(() => 1)
                                 .Then(x => Interlocked.Add(ref count, x))
                                 .Then(x => Math.Log10(x))
                                 .On(() => {
                                     Interlocked.Decrement(ref pending);
                                     if (pending == 0)
                                         stop.Set();
                                 }, PromiseEventType.All);
                         }
                         stop.WaitOne();
                         Assert.AreEqual(iterations, count);
                         Console.WriteLine("Max threads: {0}", pool.MaxRunningThreads);
                         pool.Dispose();
                     }
                     [TestMethod]
                     public void WorkerPoolDisposeTest() {
                         var pool = new WorkerPool(5, 20);
                         Assert.AreEqual(5, pool.PoolSize);
                         pool.Dispose();
                         Thread.Sleep(500);
                         Assert.AreEqual(0, pool.PoolSize);
                         pool.Dispose();
                     }
                     [TestMethod]
                     public void MTQueueTest() {
                         var queue = new MTQueue<int>();
                         int res;
                         queue.Enqueue(10);
                         Assert.IsTrue(queue.TryDequeue(out res));
                         Assert.AreEqual(10, res);
                         Assert.IsFalse(queue.TryDequeue(out res));
                         for (int i = 0; i < 1000; i++)
                             queue.Enqueue(i);
                         for (int i = 0; i < 1000; i++) {
                             queue.TryDequeue(out res);
                             Assert.AreEqual(i, res);
                         }
                         int writers = 0;
                         int readers = 0;
                         var stop = new ManualResetEvent(false);
                         int total = 0;
                         const int itemsPerWriter = 10000;
                         const int writersCount = 10;
                         for (int i = 0; i < writersCount; i++) {
                             Interlocked.Increment(ref writers);
                             AsyncPool
                                 .RunThread(() => {
                                     for (int ii = 0; ii < itemsPerWriter; ii++) {
                                         queue.Enqueue(1);
                                     }
                                     return 1;
                                 })
                                 .On(() => Interlocked.Decrement(ref writers), PromiseEventType.All);
                         }
                         for (int i = 0; i < 10; i++) {
                             Interlocked.Increment(ref readers);
                             AsyncPool
                                 .RunThread(() => {
                                     int t;
                                     do {
                                         while (queue.TryDequeue(out t))
                                             Interlocked.Add(ref total, t);
                                     } while (writers > 0);
                                     return 1;
                                 })
                                 .On(() => {
                                     Interlocked.Decrement(ref readers);
                                     if (readers == 0)
                                         stop.Set();
                                 }, PromiseEventType.All);
                         }
                         stop.WaitOne();
                         Assert.AreEqual(100000, total);
                     }
                     [TestMethod]
                     public void AsyncQueueTest() {
                         var queue = new AsyncQueue<int>();
                         int res;
                         queue.Enqueue(10);
                         Assert.IsTrue(queue.TryDequeue(out res));
                         Assert.AreEqual(10, res);
                         Assert.IsFalse(queue.TryDequeue(out res));
                         for (int i = 0; i < 1000; i++)
                             queue.Enqueue(i);
                         for (int i = 0; i < 1000; i++) {
                             queue.TryDequeue(out res);
                             Assert.AreEqual(i, res);
                         }
                         const int count = 10000000;
                         int res1 = 0, res2 = 0;
                         var t1 = Environment.TickCount;
                         AsyncPool.RunThread(
                             () => {
                                 for (var i = 0; i < count; i++)
                                     queue.Enqueue(1);
                                 Console.WriteLine("done writer #1: {0} ms", Environment.TickCount - t1);
                             },
                             () => {
                                 for (var i = 0; i < count; i++)
                                     queue.Enqueue(2);
                                 Console.WriteLine("done writer #2: {0} ms", Environment.TickCount - t1);
                             },
                             () => {
                                 int temp;
                                 int i = 0;
                                 while (i < count)
                                     if (queue.TryDequeue(out temp)) {
                                         i++;
                                         res1 += temp;
                                     }
                                 Console.WriteLine("done reader #1: {0} ms", Environment.TickCount - t1);
                             },
                             () => {
                                 int temp;
                                 int i = 0;
                                 while (i < count)
                                     if (queue.TryDequeue(out temp)) {
                                         i++;
                                         res2 += temp;
                                     }
                                 Console.WriteLine("done reader #2: {0} ms", Environment.TickCount - t1);
                             }
                         )
-                            .Bundle()
+                            .PromiseAll()
                             .Join();
                         Assert.AreEqual(count * 3, res1 + res2);
                         Console.WriteLine(
                             "done: {0} ms, summ#1: {1}, summ#2: {2}, total: {3}, count: {4}",
                             Environment.TickCount - t1,
                             res1,
                             res2,
                             res1 + res2,
                             count
                         );
                     }
                     [TestMethod]
                     public void AsyncQueueBatchTest() {
                         var queue = new AsyncQueue<int>();
                         const int wBatch = 29;
                         const int wCount = 400000;
                         const int total = wBatch * wCount * 2;
                         const int summ = wBatch * wCount * 3;
                         int r1 = 0, r2 = 0;
                         const int rBatch = 111;
                         int read = 0;
                         var t1 = Environment.TickCount;
                         AsyncPool.RunThread(
                             () => {
                                 var buffer = new int[wBatch];
                                 for(int i = 0; i<wBatch; i++)
                                     buffer[i] = 1;
                                 for(int i =0; i < wCount; i++)
                                     queue.EnqueueRange(buffer,0,wBatch);
                                 Console.WriteLine("done writer #1: {0} ms", Environment.TickCount - t1);
                             },
                             () => {
                                 var buffer = new int[wBatch];
                                 for(int i = 0; i<wBatch; i++)
                                     buffer[i] = 2;
                                 for(int i =0; i < wCount; i++)
                                     queue.EnqueueRange(buffer,0,wBatch);
                                 Console.WriteLine("done writer #2: {0} ms", Environment.TickCount - t1);
                             },
                             () => {
                                 var buffer = new int[rBatch];
                                 while(read < total) {
                                     int actual;
                                     if (queue.TryDequeueRange(buffer,0,rBatch,out actual)) {
                                         for(int i=0; i< actual; i++)
                                             r1 += buffer[i];
                                         Interlocked.Add(ref read, actual);
                                     }
                                 }
                                 Console.WriteLine("done reader #1: {0} ms", Environment.TickCount - t1);
                             },
                             () => {
                                 var buffer = new int[rBatch];
                                 while(read < total) {
                                     int actual;
                                     if (queue.TryDequeueRange(buffer,0,rBatch,out actual)) {
                                         for(int i=0; i< actual; i++)
                                             r2 += buffer[i];
                                         Interlocked.Add(ref read, actual);
                                     }
                                 }
                                 Console.WriteLine("done reader #2: {0} ms", Environment.TickCount - t1);
                             }
                         )
-                            .Bundle()
+                            .PromiseAll()
                             .Join();
                         Assert.AreEqual(summ , r1 + r2);
                         Console.WriteLine(
                             "done: {0} ms, summ#1: {1}, summ#2: {2}, total: {3}, count: {4}",
                             Environment.TickCount - t1,
                             r1,
                             r2,
                             r1 + r2,
                             total
                         );
                     }
                     [TestMethod]
                     public void AsyncQueueChunkDequeueTest() {
                         var queue = new AsyncQueue<int>();
                         const int wBatch = 31;
                         const int wCount = 200000;
                         const int total = wBatch * wCount * 3;
                         const int summ = wBatch * wCount * 6;
                         int r1 = 0, r2 = 0;
                         const int rBatch = 1024;
                         int read = 0;
                         var t1 = Environment.TickCount;
                         AsyncPool.RunThread(
                             () => {
                                 var buffer = new int[wBatch];
                                 for(int i = 0; i<wBatch; i++)
                                     buffer[i] = 1;
                                 for(int i =0; i < wCount; i++)
                                     queue.EnqueueRange(buffer,0,wBatch);
                                 Console.WriteLine("done writer #1: {0} ms", Environment.TickCount - t1);
                             },
                             () => {
                                 var buffer = new int[wBatch];
                                 for(int i = 0; i<wBatch; i++)
                                     buffer[i] = 2;
                                 for(int i =0; i < wCount; i++)
                                     queue.EnqueueRange(buffer,0,wBatch);
                                 Console.WriteLine("done writer #2: {0} ms", Environment.TickCount - t1);
                             },
                             () => {
                                 var buffer = new int[wBatch];
                                 for(int i = 0; i<wBatch; i++)
                                     buffer[i] = 3;
                                 for(int i =0; i < wCount; i++)
                                     queue.EnqueueRange(buffer,0,wBatch);
                                 Console.WriteLine("done writer #3: {0} ms", Environment.TickCount - t1);
                             },
                             () => {
                                 var buffer = new int[rBatch];
                                 int count = 1;
                                 double avgchunk = 0;
                                 while(read < total) {
                                     int actual;
                                     if (queue.TryDequeueChunk(buffer,0,rBatch,out actual)) {
                                         for(int i=0; i< actual; i++)
                                             r2 += buffer[i];
                                         Interlocked.Add(ref read, actual);
                                         avgchunk = avgchunk*(count-1)/count + actual/(double)count;
                                         count ++;
                                     }
                                 }
                                 Console.WriteLine("done reader #2: {0} ms, avg chunk size: {1}", Environment.TickCount - t1, avgchunk);
                             }
                         )
-                            .Bundle()
+                            .PromiseAll()
                             .Join();
                         Assert.AreEqual(summ , r1 + r2);
                         Console.WriteLine(
                             "done: {0} ms, summ#1: {1}, summ#2: {2}, total: {3}, count: {4}",
                             Environment.TickCount - t1,
                             r1,
                             r2,
                             r1 + r2,
                             total
                         );
                     }
                     [TestMethod]
                     public void AsyncQueueDrainTest() {
                         var queue = new AsyncQueue<int>();
                         const int wBatch = 11;
                         const int wCount = 200000;
                         const int total = wBatch * wCount * 3;
                         const int summ = wBatch * wCount * 3;
                         int r1 = 0, r2 = 0;
                         const int rBatch = 11;
                         int read = 0;
                         var t1 = Environment.TickCount;
                         AsyncPool.RunThread(
                             () => {
                                 var buffer = new int[wBatch];
                                 for(int i = 0; i<wBatch; i++)
                                     buffer[i] = 1;
                                 for(int i =0; i < wCount; i++)
                                     queue.EnqueueRange(buffer,0,wBatch);
                                 Console.WriteLine("done writer #1: {0} ms", Environment.TickCount - t1);
                             },
                             () => {
                                 for(int i =0; i < wCount * wBatch; i++)
                                     queue.Enqueue(1);
                                 Console.WriteLine("done writer #2: {0} ms", Environment.TickCount - t1);
                             },
                             () => {
                                 var buffer = new int[wBatch];
                                 for(int i = 0; i<wBatch; i++)
                                     buffer[i] = 1;
                                 for(int i =0; i < wCount; i++)
                                     queue.EnqueueRange(buffer,0,wBatch);
                                 Console.WriteLine("done writer #3: {0} ms", Environment.TickCount - t1);
                             },
                             /*() => {
                                 int temp;
                                 int count = 0;
                                 while (read < total)
                                     if (queue.TryDequeue(out temp)) {
                                         count++;
                                         r1 += temp;
                                         Interlocked.Increment(ref read);
                                     }
                                 Console.WriteLine("done reader #1: {0} ms, {1} count", Environment.TickCount - t1, count);
                             },*/
                             /*() => {
                                 var buffer = new int[rBatch];
                                 var count = 0;
                                 while(read < total) {
                                     int actual;
                                     if (queue.TryDequeueRange(buffer,0,rBatch,out actual)) {
                                         for(int i=0; i< actual; i++)
                                             r1 += buffer[i];
                                         Interlocked.Add(ref read, actual);
                                         count += actual;
                                     }
                                 }
                                 Console.WriteLine("done reader #1: {0} ms, {1} items", Environment.TickCount - t1, count);
                             },*/
                             () => {
                                 var count = 0;
                                 while(read < total) {
                                     var buffer = queue.Drain();
                                     for(int i=0; i< buffer.Length; i++)
                                         r1 += buffer[i];
                                         Interlocked.Add(ref read, buffer.Length);
                                     count += buffer.Length;
                                 }
                                 Console.WriteLine("done reader #1: {0} ms, {1} items", Environment.TickCount - t1, count);
                             },
                             () => {
                                 var count = 0;
                                 while(read < total) {
                                     var buffer = queue.Drain();
                                     for(int i=0; i< buffer.Length; i++)
                                         r2 += buffer[i];
                                     Interlocked.Add(ref read, buffer.Length);
                                     count += buffer.Length;
                                 }
                                 Console.WriteLine("done reader #2: {0} ms, {1} items", Environment.TickCount - t1, count);
                             }
                         )
-                            .Bundle()
+                            .PromiseAll()
                             .Join();
                         Assert.AreEqual(summ , r1 + r2);
                         Console.WriteLine(
                             "done: {0} ms, summ#1: {1}, summ#2: {2}, total: {3}, count: {4}",
                             Environment.TickCount - t1,
                             r1,
                             r2,
                             r1 + r2,
                             total
                         );
                     }
                     [TestMethod]
                     public void ParallelMapTest() {
                         const int count = 100000;
                         var args = new double[count];
                         var rand = new Random();
                         for (int i = 0; i < count; i++)
                             args[i] = rand.NextDouble();
                         var t = Environment.TickCount;
                         var res = args.ParallelMap(x => Math.Sin(x*x), 4).Join();
                         Console.WriteLine("Map complete in {0} ms", Environment.TickCount - t);
                         t = Environment.TickCount;
                         for (int i = 0; i < count; i++)
                             Assert.AreEqual(Math.Sin(args[i] * args[i]), res[i]);
                         Console.WriteLine("Verified in {0} ms", Environment.TickCount - t);
                     }
                     [TestMethod]
                     public void ChainedMapTest() {
                         using (var pool = new WorkerPool()) {
                             const int count = 10000;
                             var args = new double[count];
                             var rand = new Random();
                             for (int i = 0; i < count; i++)
                                 args[i] = rand.NextDouble();
                             var t = Environment.TickCount;
                             var res = args
                                 .ChainedMap(
                                     // Analysis disable once AccessToDisposedClosure
                                     x => pool.Invoke(
                                         () => Math.Sin(x * x)
                                     ),
                                 )
                                 .Join();
                             Console.WriteLine("Map complete in {0} ms", Environment.TickCount - t);
                             t = Environment.TickCount;
                             for (int i = 0; i < count; i++)
                                 Assert.AreEqual(Math.Sin(args[i] * args[i]), res[i]);
                             Console.WriteLine("Verified in {0} ms", Environment.TickCount - t);
                             Console.WriteLine("Max workers: {0}", pool.MaxRunningThreads);
                         }
                     }
                     [TestMethod]
                     public void ParallelForEachTest() {
                         const int count = 100000;
                         var args = new int[count];
                         var rand = new Random();
                         for (int i = 0; i < count; i++)
                             args[i] = (int)(rand.NextDouble() * 100);
                         int result = 0;
                         var t = Environment.TickCount;
                         args.ParallelForEach(x => Interlocked.Add(ref result, x), 4).Join();
                         Console.WriteLine("Iteration complete in {0} ms, result: {1}", Environment.TickCount - t, result);
                         int result2 = 0;
                         t = Environment.TickCount;
                         for (int i = 0; i < count; i++)
                             result2 += args[i];
                         Assert.AreEqual(result2, result);
                         Console.WriteLine("Verified in {0} ms", Environment.TickCount - t);
                     }
                     [TestMethod]
                     public void ComplexCase1Test() {
                         var flags = new bool[3];
                         // op1 (aync 200ms) => op2 (async 200ms) => op3 (sync map)
                         var step1 = PromiseHelper
                             .Sleep(200, "Alan")
                             .On(() => flags[0] = true, PromiseEventType.Cancelled);
                         var p = step1
                             .Chain(x =>
                                 PromiseHelper
                                     .Sleep(200, "Hi, " + x)
                                     .Then(y => y)
                                     .On(() => flags[1] = true, PromiseEventType.Cancelled)
                             )
                             .On(() => flags[2] = true, PromiseEventType.Cancelled);
                         step1.Join();
                         p.Cancel();
                         try {
                             Assert.AreEqual(p.Join(), "Hi, Alan");
                             Assert.Fail("Shouldn't get here");
                         } catch (OperationCanceledException) {
                         }
                         Assert.IsFalse(flags[0]);
                         Assert.IsTrue(flags[1]);
                         Assert.IsTrue(flags[2]);
                     }
                     [TestMethod]
                     public void ChainedCancel1Test() {
                         // при отмене сцепленной асинхронной операции все обещание должно
                         // завершаться ошибкой OperationCanceledException
                         var p = PromiseHelper
                             .Sleep(1, "Hi, HAL!")
                             .Then(x => {
                                 // запускаем две асинхронные операции
                                 var result = PromiseHelper.Sleep(1000, "HEM ENABLED!!!");
                                 // вторая операция отменяет первую до завершения
                                 PromiseHelper
                                     .Sleep(100, "HAL, STOP!")
                                     .Then(result.Cancel);
                                 return result;
                             });
                         try {
                             p.Join();
                         } catch (TargetInvocationException err) {
                             Assert.IsTrue(err.InnerException is OperationCanceledException);
                         }
                     }
                     [TestMethod]
                     public void ChainedCancel2Test() {
                         // при отмене цепочки обещаний, вложенные операции также должны отменяться
                         var pSurvive = new Promise<bool>();
                         var hemStarted = new Signal();
                         var p = PromiseHelper
                             .Sleep(1, "Hi, HAL!")
                             .Chain(() => {
                                 hemStarted.Set();
                                 // запускаем две асинхронные операции
                                 var result = PromiseHelper
                                     .Sleep(2000, "HEM ENABLED!!!")
                                     .Then(() => pSurvive.Resolve(false));
                                 result
                                     .On(() => pSurvive.Resolve(true), PromiseEventType.Cancelled);
                                 return result;
                             });
                         hemStarted.Wait();
                         p.Cancel();
                         try {
                             p.Join();
                             Assert.Fail();
                         } catch (OperationCanceledException) {
                         }
                         Assert.IsTrue(pSurvive.Join());
                     }
                     [TestMethod]
                     public void SharedLockTest() {
                         var l = new SharedLock();
                         int shared = 0;
                         int exclusive = 0;
                         var s1 = new Signal();
                         var log = new AsyncQueue<string>();
                         try {
                             AsyncPool.RunThread(
                                 () => {
                                     log.Enqueue("Reader #1 started");
                                     try {
                                         l.LockShared();
                                         log.Enqueue("Reader #1 lock got");
                                         if (Interlocked.Increment(ref shared) == 2)
                                             s1.Set();
                                         s1.Wait();
                                         log.Enqueue("Reader #1 finished");
                                         Interlocked.Decrement(ref shared);
                                     } finally {
                                         l.Release();
                                         log.Enqueue("Reader #1 lock released");
                                     }
                                 },
                                 () => {
                                     log.Enqueue("Reader #2 started");
                                     try {
                                         l.LockShared();
                                         log.Enqueue("Reader #2 lock got");
                                         if (Interlocked.Increment(ref shared) == 2)
                                             s1.Set();
                                         s1.Wait();
                                         log.Enqueue("Reader #2 upgrading to writer");
                                         Interlocked.Decrement(ref shared);
                                         l.Upgrade();
                                         log.Enqueue("Reader #2 upgraded");
                                         Assert.AreEqual(1, Interlocked.Increment(ref exclusive));
                                         Assert.AreEqual(0, shared);
                                         log.Enqueue("Reader #2 finished");
                                         Interlocked.Decrement(ref exclusive);
                                     } finally {
                                         l.Release();
                                         log.Enqueue("Reader #2 lock released");
                                     }
                                 },
                                 () => {
                                     log.Enqueue("Writer #1 started");
                                     try {
                                         l.LockExclusive();
                                         log.Enqueue("Writer #1 got the lock");
                                         Assert.AreEqual(1, Interlocked.Increment(ref exclusive));
                                         Interlocked.Decrement(ref exclusive);
                                         log.Enqueue("Writer #1 is finished");
                                     } finally {
                                         l.Release();
                                         log.Enqueue("Writer #1 lock released");
                                     }
                                 }
-                            ).Bundle().Join(1000);
+                            ).PromiseAll().Join(1000);
                             log.Enqueue("Done");
                         } catch(Exception error) {
                             log.Enqueue(error.Message);
                             throw;
                         } finally {
                             foreach (var m in log)
                                 Console.WriteLine(m);
                         }
                     }
                     #if NET_4_5
                     [TestMethod]
                     public async void TaskInteropTest() {
                         var promise = new Promise<int>();
                         promise.Resolve(10);
                         var res = await promise;
                         Assert.AreEqual(10, res);
                     }
                     #endif
                 }
             }

Implab.Test/Implab.Format.Test/Implab.Format.Test.csproj +4 -1

             <?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>
                 <ProductVersion>8.0.30703</ProductVersion>
                 <SchemaVersion>2.0</SchemaVersion>
                 <ProjectGuid>{4D364996-7ECD-4193-8F90-F223FFEA49DA}</ProjectGuid>
                 <OutputType>Library</OutputType>
                 <RootNamespace>Implab.Format.Test</RootNamespace>
                 <AssemblyName>Implab.Format.Test</AssemblyName>
                 <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
                 <ReleaseVersion>0.2</ReleaseVersion>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>DEBUG;</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </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>
               <ItemGroup>
                 <Reference Include="System" />
                 <Reference Include="nunit.framework">
                   <HintPath>..\..\packages\NUnit.2.6.4\lib\nunit.framework.dll</HintPath>
                 </Reference>
               </ItemGroup>
               <ItemGroup>
                 <Compile Include="JsonTests.cs" />
               </ItemGroup>
               <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
               <ItemGroup>
                 <ProjectReference Include="..\..\Implab\Implab.csproj">
                   <Project>{F550F1F8-8746-4AD0-9614-855F4C4B7F05}</Project>
                   <Name>Implab</Name>
                 </ProjectReference>
               </ItemGroup>
               <ItemGroup>
                 <None Include="packages.config" />
               </ItemGroup>
+              <ItemGroup>
+                <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+              </ItemGroup>
             </Project>

Implab.Test/Implab.Test.mono.csproj +9 -3

             <?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>
                 <ProductVersion>8.0.30703</ProductVersion>
                 <SchemaVersion>2.0</SchemaVersion>
                 <ProjectGuid>{2BD05F84-E067-4B87-9477-FDC2676A21C6}</ProjectGuid>
                 <OutputType>Library</OutputType>
                 <RootNamespace>Implab.Test</RootNamespace>
                 <AssemblyName>Implab.Test</AssemblyName>
                 <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
                 <ReleaseVersion>0.2</ReleaseVersion>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>DEBUG;MONO</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
                 <DefineConstants>MONO</DefineConstants>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug 4.5|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>DEBUG;TRACE;NET_4_5;MONO</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release 4.5|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="nunit.framework, Version=2.6.4.14350, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+                  <HintPath>..\packages\NUnit.2.6.4\lib\nunit.framework.dll</HintPath>
+                  <Private>True</Private>
+                </Reference>
                 <Reference Include="System" />
-                <Reference Include="nunit.framework" />
               </ItemGroup>
               <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
               <ItemGroup>
                 <Compile Include="AsyncTests.cs" />
                 <Compile Include="PromiseHelper.cs" />
                 <Compile Include="Properties\AssemblyInfo.cs" />
                 <Compile Include="CancelationTests.cs" />
                 <Compile Include="RunnableComponentTests.cs" />
                 <Compile Include="PollingComponentTests.cs" />
                 <Compile Include="Mock\MockRunnableComponent.cs" />
                 <Compile Include="Mock\MockPollingComponent.cs" />
               </ItemGroup>
               <ItemGroup>
                 <ProjectReference Include="..\Implab\Implab.csproj">
                   <Project>{F550F1F8-8746-4AD0-9614-855F4C4B7F05}</Project>
                   <Name>Implab</Name>
                 </ProjectReference>
               </ItemGroup>
               <ItemGroup>
-                <Folder Include="Mock\" />
+                <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+              </ItemGroup>
+              <ItemGroup>
+                <None Include="packages.config" />
               </ItemGroup>
             </Project>

Implab.Test/Mock/MockPollingComponent.cs +1 -1

             using System;
             using Implab.Components;
             namespace Implab.Test.Mock {
                 class MockPollingComponent : PollingComponent {
                     public MockPollingComponent(TimeSpan interval, Func<Func<ICancellationToken, IPromise>, IPromise> dispatcher, bool initialized) : base(interval, dispatcher, initialized)  {
                     }
                     public Action MockInit {
                         get;
                         set;
                     }
                     public Action<Exception> MockOnError {
                         get;
                         set;
                     }
                     public Action<Exception> MockOnCancel {
                         get;
                         set;
                     }
                     public Func<IPromise> MockStart {
                         get;
                         set;
                     }
                     public Func<IPromise> MockStop {
                         get;
                         set;
                     }
                     public Func<ICancellationToken, IPromise> MockTick {
                         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 IPromise OnTick(ICancellationToken cancellationToken) {
-                        return MockTick != null ? Safe.Run(() => MockTick(cancellationToken)) : Promise.SUCCESS;
+                        return MockTick != null ? Safe.Run(() => MockTick(cancellationToken)) : Promise.Success;
                     }
                     protected override void OnTickCancel(Exception error) {
                         if (MockOnCancel != null)
                             MockOnCancel(error);
                     }
                     protected override void OnTickError(Exception error) {
                         if (MockOnError != null)
                             MockOnError(error);
                     }
                     public void CallComponentFail(Exception error) {
                         Fail(error);
                     }
                 }
             }

Implab.Test/Mock/MockRunnableComponent.cs +14 0

             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 {
+                        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) {
+                        if (MockDispose != null)
+                            MockDispose(disposing, lastError);
+                        base.Dispose(disposing, lastError);
+                    }
                 }
             }

Implab.Test/PollingComponentTests.cs +2 -2

             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 PollingComponentTests {
                     static void ShouldThrow(Action action) {
                         try {
                             action();
                             Assert.Fail();
                         } catch (AssertFailedException) {
                             throw;
                         } catch {
                         }
                     }
                     [TestMethod]
                     public void NormalFlowTest() {
                         var comp = new MockPollingComponent(TimeSpan.FromMilliseconds(1), null, false);
                         Assert.AreEqual(ExecutionState.Created, comp.State);
-                        comp.Init();
+                        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 ShouldStartTicks() {
                         var signal = new Signal();
                         var comp = new MockPollingComponent(TimeSpan.FromMilliseconds(1), null, true);
                         comp.MockTick = ct => {
                             signal.Set();
-                            return Promise.SUCCESS;
+                            return Promise.Success;
                         };
                         comp.Start().Join(1000);
                         signal.Wait(1000);
                         comp.Stop().Join(1000);
                     }
                     [TestMethod]
                     public void StopShouldWaitForTickToComplete() {
                         var comp = new MockPollingComponent(TimeSpan.FromMilliseconds(1), null, true);
                         var signal = new Signal();
                         var promise = new Promise();
                         // timer should tick once
                         comp.MockTick = ct => {
                             signal.Set();
                             return promise;
                         };
                         // start timer
                         comp.Start().Join(1000);
                         signal.Wait(); // wait for tick
                         // try to stop component
                         var stopping = comp.Stop();
                         Assert.AreEqual(ExecutionState.Stopping, comp.State);
                         ShouldThrow(() => stopping.Join(100));
                         Assert.AreEqual(ExecutionState.Stopping, comp.State);
                         // complete operation
                         promise.Resolve();
                         // the component should stop normally
                         stopping.Join(1000);
                         Assert.AreEqual(ExecutionState.Disposed, comp.State);
                     }
                     [TestMethod]
                     public void ShouldRecoverAfterTickError() {
                         var ticks = 0;
                         var comp = new MockPollingComponent(TimeSpan.FromMilliseconds(1), null, true);
                         var signal = new Signal(); // will signal when timer fires 10 times
                         comp.MockTick = ct => {
                             ticks++;
                             if (ticks == 10)
                                 signal.Set();
                             // each time handler dies
                             throw new Exception("tainted handler");
                         };
                         comp.Start();
                         signal.Wait(1000);
                         comp.Stop().Join(1000);
                         Assert.AreEqual(ExecutionState.Disposed, comp.State);
                     }
                     [TestMethod]
                     public void StopCancelHandlerOnStop() {
                         var comp = new MockPollingComponent(TimeSpan.FromMilliseconds(1), null, true);
                         var started = new Signal();
                         bool cancelled = false;
                         // timer should tick once
                         comp.MockTick = ct => {
                             started.Set();
                             while(!ct.IsCancellationRequested) {
                                 Thread.Sleep(1);
                             }
                             cancelled = true;
                             throw new OperationCanceledException();
                         };
                         // start timer
                         comp.Start().Join(1000);
                         started.Wait(); // wait for tick
                         // try to stop component
                         comp.Stop().Join(1000);
                         Assert.AreEqual(true, cancelled);
                         Assert.AreEqual(ExecutionState.Disposed, comp.State);
                     }
                     [TestMethod]
                     public void FailTickOnStopShouldBeIgnored() {
                         var comp = new MockPollingComponent(TimeSpan.FromMilliseconds(1), null, true);
                         var started = new Signal();
                         var finish = new Signal();
                         // timer should tick once
                         comp.MockTick = ct => {
                             started.Set();
                             finish.Wait();
                             // component is in stopping state here
                             throw new Exception("Die, die, die!!!");
                         };
                         comp.MockOnError = comp.CallComponentFail;
                         // start timer
                         comp.Start().Join(1000);
                         started.Wait(); // wait for tick
                         // try to stop component
                         var stopping = comp.Stop();
                         // the component is in stopping state but it is waiting for the tick handler to complete
                         finish.Set(); // signal the tick handler to finish
                         // tick handler should stop rather soon
                         stopping.Join(1000);
                         // validate the component is disposed
                         Assert.AreEqual(ExecutionState.Disposed, comp.State);
                     }
                     [TestMethod]
                     public void FailTickShouldFailComponent() {
                         var comp = new MockPollingComponent(TimeSpan.FromMilliseconds(1), null, true);
                         var started = new Signal();
                         var finish = new Signal();
                         // timer should tick once
                         comp.MockTick = ct => {
                             started.Set();
                             throw new Exception("Die, die, die!!!");
                         };
                         comp.MockOnError = err => {
                             comp.CallComponentFail(err);
                             finish.Set();
                         };
                         // start timer
                         comp.Start().Join(1000);
                         started.Wait(); // wait for tick
                         finish.Wait();
                         // try to stop component
                         ShouldThrow(() => comp.Stop());
                         Assert.AreEqual(ExecutionState.Failed, comp.State);
                         Assert.IsNotNull(comp.LastError);
                         Assert.AreEqual("Die, die, die!!!", comp.LastError.Message);
                         comp.Dispose();
                         Assert.AreEqual(ExecutionState.Disposed, comp.State);
                     }
                 }
             }

Implab.Test/RunnableComponentTests.cs +68 -3

             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.Init();
+                        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.Init);
+                        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.Init);
+                        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) => {
+                            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) => {
+                            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, 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/Automaton/AutomatonTransition.cs +8 0

             using System;
             namespace Implab.Automaton {
                 public struct AutomatonTransition : IEquatable<AutomatonTransition> {
                     public readonly int s1;
                     public readonly int s2;
                     public readonly int edge;
                     public AutomatonTransition(int s1, int s2, int edge) {
                         this.s1 = s1;
                         this.s2 = s2;
                         this.edge = edge;
                     }
                     #region IEquatable implementation
                     public bool Equals(AutomatonTransition other) {
                         return other.s1 == s1 && other.s2 == s2 && other.edge == edge ;
                     }
                     #endregion
                     public override bool Equals(object obj) {
                         if (obj is AutomatonTransition)
                             return Equals((AutomatonTransition)obj);
                         return base.Equals(obj);
                     }
                     public override int GetHashCode() {
                         return s1 + s2 + edge;
                     }
+                    public static bool operator == (AutomatonTransition rv, AutomatonTransition lv) {
+                        return rv.Equals(lv);
+                    }
+                    public static bool operator !=(AutomatonTransition rv, AutomatonTransition lv) {
+                        return rv.Equals(lv);
+                    }
                 }
             }

Implab/Components/IInitializable.cs +4 -4

             using System;
             namespace Implab.Components {
                 /// <summary>
                 /// Initializable components are created and initialized in two steps, first we have create the component,
-                /// then we have to complete it's creation by calling an <see cref="Init()"/> method. All parameters needed
+                /// then we have to complete it's creation by calling an <see cref="Initialize()"/> method. All parameters needed
-                /// to complete the initialization must be passed before the calling <see cref="Init()"/>
+                /// to complete the initialization must be passed before the calling <see cref="Initialize()"/>
                 /// </summary>
                 public interface IInitializable {
                     /// <summary>
                     /// Completes initialization.
                     /// </summary>
                     /// <remarks>
                     /// Normally virtual methods shouldn't be called from the constructor, due to the incomplete object state, but
-                    /// they can be called from this method. This method is also usefull when we constructing a complex grpah
+                    /// they can be called from this method. This method is aьуерщlso usefull when we constructing a complex grpah
                     /// of components where cyclic references may take place.
                     /// </remarks>
-                    void Init();
+                    void Initialize();
                 }
             }

Implab/Components/IRunnable.cs +2 0

             using System;
             namespace Implab.Components {
                 public interface IRunnable {
                     /// <summary>
                     /// 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.
                     /// </summary>
                     IPromise Stop();
                     ExecutionState State { get; }
+                    event EventHandler<StateChangeEventArgs> StateChanged;
                     Exception LastError { get; }
                 }
             }

Implab/Components/PollingComponent.cs +1 -1

             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;
+                        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) {
                         if (disposing)
                             Safe.Dispose(m_timer);
                         base.Dispose(disposing, lastError);
                     }
                 }
             }

Implab/Components/RunnableComponent.cs +140 -61

             using System;
             namespace Implab.Components {
                 public abstract class RunnableComponent : IDisposable, IRunnable, IInitializable {
                     enum Commands {
                         Ok = 0,
                         Fail,
                         Init,
                         Start,
                         Stop,
                         Dispose,
-                        Last = 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.Disposed, Commands.Ok);
+                            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;
-                    protected RunnableComponent(bool initialized) {
+                    /// <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("Commnd {0} is not allowed in the state {1}", cmd, m_stateMachine.State));
+                        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;
                     }
-                    void Move(Commands cmd) {
+                    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>
-                    /// <returns>Returns true if the component is set to the failed state, false - otherwise.
-                    /// This method works only for the running state, in any other state it will return false.</returns>
                     protected bool Fail(Exception error) {
-                        lock (m_stateMachine) {
+                        return MoveIfInState(Commands.Fail, null, error, ExecutionState.Running);
-                            if(m_stateMachine.State == ExecutionState.Running) {
-                                m_stateMachine.Move(Commands.Fail);
-                                m_lastError = error;
-                                return true;
-                        return false;
                     }
-                    void Invoke(Commands cmd, Action action) {
+                    /// <summary>
-                        lock (m_stateMachine)
+                    /// Tries to reset <see cref="ExecutionState.Failed"/> state to <see cref="ExecutionState.Ready"/>.
-                            Move(cmd);
+                    /// </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 {
-                            action();
+                            OnResetState();
-                            lock(m_stateMachine)
+                            Move(Commands.Ok, null, null);
-                                Move(Commands.Ok);
+                            return true;
                         } catch (Exception err) {
-                            lock (m_stateMachine) {
+                            Move(Commands.Fail, null, err);
-                                Move(Commands.Fail);
-                                m_lastError = 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);
-                        lock (m_stateMachine) {
-                            Move(cmd);
-                            prev = m_pending;
                         Action<Exception> errorOrCancel = e => {
                             if (e == null)
                                 e = new OperationCanceledException();
+                            MoveIfPending(Commands.Fail, null, e, promise);
-                                lock (m_stateMachine) {
-                                    if (m_pending == promise) {
-                                        Move(Commands.Fail);
-                                        m_pending = null;
-                                        m_lastError = e;
                             throw new PromiseTransientException(e);
                         };
                         promise = task.Then(
-                                () => {
+                            () => MoveIfPending(Commands.Ok, null, null, promise),
-                                    lock(m_stateMachine) {
-                                        if (m_pending == promise) {
-                                            Move(Commands.Ok);
-                                            m_pending = null;
-                                },
                             errorOrCancel,
                             errorOrCancel
                         );
-                            m_pending = promise;
+                        prev = Move(cmd, promise, null);
                         if (prev == null)
                             task.Resolve();
                         else
                             chain(prev, task);
                         return promise;
                     }
                     #region IInitializable implementation
-                    public void Init() {
+                    public void Initialize() {
-                        Invoke(Commands.Init, OnInitialize);
+                        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;
+                        return Promise.Success;
                     }
                     public IPromise Stop() {
-                        return InvokeAsync(Commands.Stop, OnStop, StopPending).Then(Dispose);
+                        var pending = InvokeAsync(Commands.Stop, OnStop, StopPending);
+                        return m_reusable ? pending : pending.Then(Dispose);
                     }
                     protected virtual IPromise OnStop() {
-                        return Promise.SUCCESS;
+                        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>
                     public void Dispose() {
                         IPromise pending;
                         lock (m_stateMachine) {
                             if (m_stateMachine.State == ExecutionState.Disposed)
                                 return;
+                            pending = Move(Commands.Dispose, null, null);
-                            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);
+                            Dispose(true, null);
                         }
                     }
                     ~RunnableComponent() {
                         Dispose(false, null);
                     }
                     #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>
                     protected virtual void Dispose(bool disposing, Exception lastError) {
                     }
                 }
             }

Implab/Diagnostics/TextFileListener.cs +3 -2

             using System;
             using System.IO;
             using System.Text;
             namespace Implab.Diagnostics {
                 public class TextFileListener: ListenerBase {
                     readonly TextWriter m_textWriter;
+                    readonly object m_lock = new object();
                     public TextFileListener(string fileName) {
                         m_textWriter = File.CreateText(fileName);
                         m_textWriter.WriteLine("LOG {0}", DateTime.Now);
                     }
                     #region implemented abstract members of ListenerBase
                     public override void Write(LogEventArgs args, object entry) {
                         var msg = new StringBuilder();
                         for (int i = 0; i < args.Operation.Level; i++)
                             msg.Append("  ");
                         msg.AppendFormat("[{0}]:{1}: {2}", args.ThreadId, args.Channel, entry);
-                        lock (m_textWriter) {
+                        lock (m_lock) {
                             if (!IsDisposed) {
                                 // тут гарантировано еще не освобожден m_textWriter
                                 m_textWriter.WriteLine(msg);
                                 m_textWriter.Flush();
                             }
                         }
                     }
                     #endregion
                     protected override void Dispose(bool disposing) {
                         base.Dispose(disposing);
                         if (disposing) {
                             // IsDisposed = true
-                            lock (m_textWriter) {
+                            lock (m_lock) {
                                 Safe.Dispose(m_textWriter);
                             }
                         }
                     }
                 }
             }

Implab/Implab.csproj +2 -6

             <?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="Components\StateChangeEventArgs.cs" />
                 <Compile Include="CustomEqualityComparer.cs" />
                 <Compile Include="Diagnostics\ConsoleTraceListener.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" />
                 <Compile Include="FailedPromise.cs" />
                 <Compile Include="FailedPromiseT.cs" />
                 <Compile Include="Components\PollingComponent.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>
+              <ItemGroup />
-                <Folder Include="Components\" />
-                <Folder Include="Automaton\RegularExpressions\" />
-                <Folder Include="Formats\" />
-                <Folder Include="Formats\JSON\" />
-              </ItemGroup>
             </Project>

Implab/Promise.cs +6 -3

             using System;
             using Implab.Parallels;
             namespace Implab {
                 public class Promise : AbstractPromise, IDeferred {
-                    public static readonly Promise SUCCESS;
+                    public static readonly IPromise Success;
                     static Promise() {
-                        SUCCESS = new Promise();
+                        Success = new SuccessPromise();
-                        SUCCESS.Resolve();
                     }
                     public void Resolve() {
                         SetResult();
                     }
                     public void Reject(Exception error) {
                         SetError(error);
                     }
+                    public static IPromise FromException(Exception exception) {
+                        return new FailedPromise(exception);
+                    }
                 }
             }

Implab/PromiseExtensions.cs +13 -2

             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;
                     }
                     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 Bundle(this ICollection<IPromise> 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) {
+                        Safe.ArgumentNotNull(that, "that");
+                        return PromiseAll(that.ToList());
+                    }
+                    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[]> Bundle<T>(this ICollection<IPromise<T>> that) {
+                    public static IPromise<T[]> PromiseAll<T>(this ICollection<IPromise<T>> that) {
                         Safe.ArgumentNotNull(that, "that");
                         int count = that.Count;
                         int errors = 0;
                         var medium = new Promise<T[]>();
                         var results = new T[that.Count];
                         medium.On(() => {
                             foreach(var p2 in that)
                                 p2.Cancel();
                         }, 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<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);
                     }
                     #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);
                     }
                     #endif
                 }
             }

Implab/Safe.cs +1 -1

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Text.RegularExpressions;
             using System.Diagnostics;
             namespace Implab
             {
                 public static class Safe
                 {
                     public static void ArgumentAssert(bool condition, string paramName) {
                         if (!condition)
                             throw new ArgumentException("The parameter is invalid", paramName);
                     }
                     public static void ArgumentMatch(string value, string paramName, Regex rx) {
                         if (rx == null)
                             throw new ArgumentNullException("rx");
                         if (!rx.IsMatch(value))
                             throw new ArgumentException(String.Format("The prameter value must match {0}", rx), paramName);
                     }
                     public static void ArgumentNotEmpty(string value, string paramName) {
                         if (String.IsNullOrEmpty(value))
                             throw new ArgumentException("The parameter can't be empty", paramName);
                     }
                     public static void ArgumentNotEmpty<T>(T[] value, string paramName) {
                         if (value == null || value.Length == 0)
                             throw new ArgumentException("The array must be not emty", paramName);
                     }
                     public static void ArgumentNotNull(object value, string paramName) {
                         if (value == null)
                             throw new ArgumentNullException(paramName);
                     }
                     public static void ArgumentInRange(int value, int min, int max, string paramName) {
                         if (value < min || value > max)
                             throw new ArgumentOutOfRangeException(paramName);
                     }
                     public static void ArgumentOfType(object value, Type type, string paramName) {
                         if (!type.IsInstanceOfType(value))
                             throw new ArgumentException(String.Format("The parameter must be of type {0}", type), paramName);
                     }
                     public static void Dispose(params IDisposable[] objects) {
                         foreach (var d in objects)
                             if (d != null)
                                 d.Dispose();
                     }
                     public static void Dispose(params object[] objects) {
                         foreach (var obj in objects) {
                             var d = obj as IDisposable;
                             if (d != null)
                                 d.Dispose();
                         }
                     }
                     public static void Dispose(object obj) {
                         var d = obj as IDisposable;
                         if (d != null)
                             d.Dispose();
                     }
                     [DebuggerStepThrough]
                     public static IPromise<T> Run<T>(Func<T> action) {
                         ArgumentNotNull(action, "action");
                         try {
                             return Promise<T>.FromResult(action());
                         } catch (Exception err) {
                             return Promise<T>.FromException(err);
                         }
                     }
                     [DebuggerStepThrough]
                     public static IPromise Run(Action action) {
                         ArgumentNotNull(action, "action");
                         try {
                             action();
-                            return Promise.SUCCESS;
+                            return Promise.Success;
                         } catch (Exception err) {
                             return new FailedPromise(err);
                         }
                     }
                     [DebuggerStepThrough]
                     public static IPromise Run(Func<IPromise> action) {
                         ArgumentNotNull(action, "action");
                         try {
                             return action() ?? new FailedPromise(new Exception("The action returned null"));
                         } catch (Exception err) {
                             return new FailedPromise(err);
                         }
                     }
                     [DebuggerStepThrough]
                     public static IPromise<T> Run<T>(Func<IPromise<T>> action) {
                         ArgumentNotNull(action, "action");
                         try {
                             return action() ?? Promise<T>.FromException(new Exception("The action returned null"));
                         } catch (Exception err) {
                             return Promise<T>.FromException(err);
                         }
                     }
                 }
             }

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