implab/ImplabNet Commit - r138:f75cfa58e3d4

added ICancellable.Cancel(Exception) to allow specify the reason of cancellation

cin -

r138:f75cfa58e3d4 v2

parent child

Context file:

r138:f75cfa58e3d4

Collapse all files

Implab.Fx/ControlBoundPromise.cs +3 -3

             using System.Windows.Forms;
             using System;
             namespace Implab.Fx {
                 public class ControlBoundPromise<T> : Promise<T> {
                     readonly Control m_target;
                     public ControlBoundPromise(Control target) {
                         Safe.ArgumentNotNull(target, "target");
                         m_target = target;
                     }
                     protected override void SignalSuccess(IDeferred<T> handler) {
                         if (m_target.InvokeRequired)
                             m_target.BeginInvoke(new Action<IDeferred<T>>(base.SignalSuccess), handler);
                         else
                             base.SignalSuccess(handler);
                     }
-                    protected override void SignalCancelled(IDeferred<T> handler) {
+                    protected override void SignalCancelled(IDeferred<T> handler, Exception reason) {
                         if (m_target.InvokeRequired)
-                            m_target.BeginInvoke(new Action<IDeferred<T>>(base.SignalCancelled), handler);
+                            m_target.BeginInvoke(new Action<IDeferred<T>,Exception>(base.SignalCancelled), handler, reason);
                         else
-                            base.SignalCancelled(handler);
+                            base.SignalCancelled(handler, reason);
                     }
                     protected override void SignalError(IDeferred<T> handler, Exception error) {
                         if (m_target.InvokeRequired)
                             m_target.BeginInvoke(new Action<IDeferred<T>,Exception>(base.SignalError), handler, error);
                         else
                             base.SignalError(handler, error);
                     }
                 }
             }

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 TestMethod = 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.Cancel();
-                        var p2 = p.Cancelled(() => {
+                        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.Cancel();
                         var p2 = p
-                            .Cancelled<bool>(() => {
+                            .Then<bool>(x => x, null, reason => {
                                 throw new ApplicationException("CANCELLED");
                             })
-                            .Error(e => true);
+                            .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.Error(e => 101);
+                        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()
                             .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()
                             .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()
                             .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()
                             .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 ManualResetEvent(false);
                         var p = PromiseHelper
                             .Sleep(1, "Hi, HAL!")
                             .Chain(x => {
                                 hemStarted.Set();
                                 // запускаем две асинхронные операции
                                 var result = PromiseHelper
                                     .Sleep(100000000, "HEM ENABLED!!!")
                                     .Then(s => {
                                         pSurvive.Resolve(false);
                                         return s;
                                     });
                                 result
-                                    .Cancelled(() => pSurvive.Resolve(true));
+                                    .On(() => pSurvive.Resolve(true), PromiseEventType.Cancelled);
                                 return result;
                             });
                         hemStarted.WaitOne();
                         p.Cancel();
                         try {
                             p.Join();
                         } 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);
                             log.Enqueue("Done");
                         } catch(Exception error) {
                             log.Enqueue(error.Message);
                             throw;
                         } finally {
                             foreach (var m in log)
                                 Console.WriteLine(m);
                         }
                     }
                 }
             }

Implab/AbstractPromise.cs +26 -9

             using System;
             using Implab.Parallels;
             using System.Threading;
             using System.Reflection;
             namespace Implab {
                 public abstract class AbstractPromise<THandler> {
                     const int UNRESOLVED_SATE = 0;
                     const int TRANSITIONAL_STATE = 1;
                     const int SUCCEEDED_STATE = 2;
                     const int REJECTED_STATE = 3;
                     const int CANCELLED_STATE = 4;
                     const int RESERVED_HANDLERS_COUNT = 4;
                     int m_state;
                     Exception m_error;
                     int m_handlersCount;
                     readonly THandler[] m_handlers = new THandler[RESERVED_HANDLERS_COUNT];
                     MTQueue<THandler> m_extraHandlers;
                     int m_handlerPointer = -1;
                     int m_handlersCommited;
                     #region state managment
                     bool BeginTransit() {
                         return UNRESOLVED_SATE == Interlocked.CompareExchange(ref m_state, TRANSITIONAL_STATE, UNRESOLVED_SATE);
                     }
                     void CompleteTransit(int state) {
                         if (TRANSITIONAL_STATE != Interlocked.CompareExchange(ref m_state, state, TRANSITIONAL_STATE))
                             throw new InvalidOperationException("Can't complete transition when the object isn't in the transitional state");
                     }
                     void WaitTransition() {
                         while (m_state == TRANSITIONAL_STATE) {
                             Thread.MemoryBarrier();
                         }
                     }
                     protected bool BeginSetResult() {
                         if (!BeginTransit()) {
                             WaitTransition();
                             if (m_state != CANCELLED_STATE)
                                 throw new InvalidOperationException("The promise is already resolved");
                             return false;
                         }
                         return true;
                     }
                     protected void EndSetResult() {
                         CompleteTransit(SUCCEEDED_STATE);
                         OnSuccess();
                     }
                     /// <summary>
                     /// Выполняет обещание, сообщая об ошибке
                     /// </summary>
                     /// <remarks>
                     /// Поскольку обещание должно работать в многопточной среде, при его выполнении сразу несколько потоков
                     /// могу вернуть ошибку, при этом только первая будет использована в качестве результата, остальные
                     /// будут проигнорированы.
                     /// </remarks>
                     /// <param name="error">Исключение возникшее при выполнении операции</param>
                     /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
                     protected void SetError(Exception error) {
                         if (BeginTransit()) {
-                            m_error = error is PromiseTransientException ? error.InnerException : error;
+                            if (error is OperationCanceledException) {
-                            CompleteTransit(REJECTED_STATE);
+                                CompleteTransit(CANCELLED_STATE);
-                            OnError();
+                                m_error = error.InnerException;
+                                OnCancelled();
+                            } else {
+                                m_error = error is PromiseTransientException ? error.InnerException : error;
+                                CompleteTransit(REJECTED_STATE);
+                                OnError();
+                            }
                         } else {
                             WaitTransition();
                             if (m_state == SUCCEEDED_STATE)
                                 throw new InvalidOperationException("The promise is already resolved");
                         }
                     }
                     /// <summary>
                     /// Отменяет операцию, если это возможно.
                     /// </summary>
                     /// <remarks>Для определения была ли операция отменена следует использовать свойство <see cref="IsCancelled"/>.</remarks>
-                    protected void SetCancelled() {
+                    protected void SetCancelled(Exception reason) {
                         if (BeginTransit()) {
+                            m_error = reason;
                             CompleteTransit(CANCELLED_STATE);
                             OnCancelled();
                         }
                     }
                     protected abstract void SignalSuccess(THandler handler);
                     protected abstract void SignalError(THandler handler, Exception error);
-                    protected abstract void SignalCancelled(THandler handler);
+                    protected abstract void SignalCancelled(THandler handler, Exception reason);
                     void OnSuccess() {
                         var hp = m_handlerPointer;
                         var slot = hp +1 ;
                         while (slot < m_handlersCommited) {
                             if (Interlocked.CompareExchange(ref m_handlerPointer, slot, hp) == hp) {
                                 SignalSuccess(m_handlers[slot]);
                             }
                             hp = m_handlerPointer;
                             slot = hp +1 ;
                         }
                         if (m_extraHandlers != null) {
                             THandler handler;
                             while (m_extraHandlers.TryDequeue(out handler))
                                 SignalSuccess(handler);
                         }
                     }
                     void OnError() {
                         var hp = m_handlerPointer;
                         var slot = hp +1 ;
                         while (slot < m_handlersCommited) {
                             if (Interlocked.CompareExchange(ref m_handlerPointer, slot, hp) == hp) {
                                 SignalError(m_handlers[slot],m_error);
                             }
                             hp = m_handlerPointer;
                             slot = hp +1 ;
                         }
                         if (m_extraHandlers != null) {
                             THandler handler;
                             while (m_extraHandlers.TryDequeue(out handler))
                                 SignalError(handler, m_error);
                         }
                     }
                     void OnCancelled() {
                         var hp = m_handlerPointer;
                         var slot = hp +1 ;
                         while (slot < m_handlersCommited) {
                             if (Interlocked.CompareExchange(ref m_handlerPointer, slot, hp) == hp) {
-                                SignalCancelled(m_handlers[slot]);
+                                SignalCancelled(m_handlers[slot], m_error);
                             }
                             hp = m_handlerPointer;
                             slot = hp +1 ;
                         }
                         if (m_extraHandlers != null) {
                             THandler handler;
                             while (m_extraHandlers.TryDequeue(out handler))
-                                SignalCancelled(handler);
+                                SignalCancelled(handler, m_error);
                         }
                     }
                     #endregion
                     protected abstract void Listen(PromiseEventType events, Action handler);
                     #region synchronization traits
                     protected void WaitResult(int timeout) {
                         if (!IsResolved) {
                             var lk = new object();
                             Listen(PromiseEventType.All, () => {
                                 lock(lk) {
                                     Monitor.Pulse(lk);
                                 }
                             });
                             lock (lk) {
                                 while(!IsResolved) {
                                     if(!Monitor.Wait(lk,timeout))
                                         throw new TimeoutException();
                                 }
                             }
                         }
                         switch (m_state) {
                             case SUCCEEDED_STATE:
                                 return;
                             case CANCELLED_STATE:
                                 throw new OperationCanceledException();
                             case REJECTED_STATE:
                                 throw new TargetInvocationException(m_error);
                             default:
                                 throw new ApplicationException(String.Format("Invalid promise state {0}", m_state));
                         }
                     }
                     #endregion
                     #region handlers managment
                     protected void AddHandler(THandler handler) {
                         if (m_state > 1) {
                             // the promise is in the resolved state, just invoke the handler
                             InvokeHandler(handler);
                         } else {
                             var slot = Interlocked.Increment(ref m_handlersCount) - 1;
                             if (slot < RESERVED_HANDLERS_COUNT) {
                                 m_handlers[slot] = handler;
                                 while (slot != Interlocked.CompareExchange(ref m_handlersCommited, slot + 1, slot)) {
                                 }
                                 if (m_state > 1) {
                                     do {
                                         var hp = m_handlerPointer;
                                         slot = hp + 1;
                                         if (slot < m_handlersCommited) {
                                             if (Interlocked.CompareExchange(ref m_handlerPointer, slot, hp) != hp)
                                                 continue;
                                             InvokeHandler(m_handlers[slot]);
                                         }
                                         break;
                                     } while(true);
                                 }
                             } else {
                                 if (slot == RESERVED_HANDLERS_COUNT) {
                                     m_extraHandlers = new MTQueue<THandler>();
                                 } else {
                                     while (m_extraHandlers == null)
                                         Thread.MemoryBarrier();
                                 }
                                 m_extraHandlers.Enqueue(handler);
                                 if (m_state > 1 && m_extraHandlers.TryDequeue(out handler))
                                 // if the promise have been resolved while we was adding the handler to the queue
                                 // we can't guarantee that someone is still processing it
                                 // therefore we need to fetch a handler from the queue and execute it
                                 // note that fetched handler may be not the one that we have added
                                 // even we can fetch no handlers at all :)
                                 InvokeHandler(handler);
                             }
                         }
                     }
                     protected void InvokeHandler(THandler handler) {
                         switch (m_state) {
                             case SUCCEEDED_STATE:
                                 SignalSuccess(handler);
                                 break;
                             case CANCELLED_STATE:
-                                SignalCancelled(handler);
+                                SignalCancelled(handler, m_error);
                                 break;
                             case REJECTED_STATE:
                                 SignalError(handler, m_error);
                                 break;
                             default:
                                 throw new Exception(String.Format("Invalid promise state {0}", m_state));
                         }
                     }
                     #endregion
                     #region IPromise implementation
                     public void Join(int timeout) {
                         WaitResult(timeout);
                     }
                     public void Join() {
                         WaitResult(-1);
                     }
                     public bool IsResolved {
                         get {
                             Thread.MemoryBarrier();
                             return m_state > 1;
                         }
                     }
                     public bool IsCancelled {
                         get {
                             Thread.MemoryBarrier();
                             return m_state == CANCELLED_STATE;
                         }
                     }
                     #endregion
                     #region ICancellable implementation
                     public void Cancel() {
-                        SetCancelled();
+                        SetCancelled(null);
+                    }
+                    public void Cancel(Exception reason) {
+                        SetCancelled(reason);
                     }
                     #endregion
+                    public Exception Error {
+                        get {
+                            return m_error;
+                        }
+                    }
                 }
             }

Implab/Diagnostics/Extensions.cs +2 -2

             namespace Implab.Diagnostics {
                 public static class Extensions {
                     public static IPromise<T> EndLogicalOperation<T>(this IPromise<T> promise) {
                         Safe.ArgumentNotNull(promise, "promise");
                         var op = TraceContext.Instance.DetachLogicalOperation();
                         return promise.On(
                             x => {
                                 TraceContext.Instance.EnterLogicalOperation(op,true);
                                 TraceLog.TraceInformation("promise = {0}", x);
                                 TraceLog.EndLogicalOperation();
                                 TraceContext.Instance.Leave();
                             },
                             err =>{
                                 TraceContext.Instance.EnterLogicalOperation(op,true);
                                 TraceLog.TraceError("promise died {0}", err);
                                 TraceLog.EndLogicalOperation();
                                 TraceContext.Instance.Leave();
                             },
-                            () => {
+                            reason => {
                                 TraceContext.Instance.EnterLogicalOperation(op,true);
-                                TraceLog.TraceInformation("promise cancelled");
+                                TraceLog.TraceInformation("promise cancelled {0}", reason.Message);
                                 TraceLog.EndLogicalOperation();
                                 TraceContext.Instance.Leave();
                             }
                         );
                     }
                     public static IPromise EndLogicalOperation(this IPromise promise) {
                         Safe.ArgumentNotNull(promise, "promise");
                         var op = TraceContext.Instance.DetachLogicalOperation();
                         return promise.On(() => {
                             TraceContext.Instance.EnterLogicalOperation(op,true);
                             TraceLog.EndLogicalOperation();
                             TraceContext.Instance.Leave();
                         }, PromiseEventType.All);
                     }
                 }
             }

Implab/ICancellable.cs +1 0

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             namespace Implab {
                 public interface ICancellable {
                     void Cancel();
+                    void Cancel(Exception reason);
                 }
             }

Implab/IDeferred.cs +10 0

             using System;
             namespace Implab {
                 /// <summary>
                 /// Deferred result, usually used by asynchronous services as the service part of the promise.
                 /// </summary>
                 public interface IDeferred : ICancellable {
                     void Resolve();
+                    /// <summary>
+                    /// Reject the promise with the specified error.
+                    /// </summary>
+                    /// <param name="error">The reason why the promise is rejected.</param>
+                    /// <remarks>
+                    /// Some exceptions are treated in a special case:
+                    /// <see cref="OperationCanceledException"/> is interpreted as call to <see cref="Cancel()"/> method,
+                    /// and <see cref="PromiseTransientException"/> is always unwrapped and its
+                    /// <see cref="PromiseTransientException.InnerException"> is used as the reason to reject promise.
+                    /// </remarks>
                     void Reject(Exception error);
                 }
             }

Implab/IPromise.cs +12 -41

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             namespace Implab {
                 public interface IPromise: ICancellable {
                     /// <summary>
                     /// Тип результата, получаемого через данное обещание.
                     /// </summary>
                     Type PromiseType { get; }
                     /// <summary>
                     /// Обещание является выполненым, либо успешно, либо с ошибкой, либо отменено.
                     /// </summary>
                     bool IsResolved { get; }
                     /// <summary>
                     /// Обещание было отменено.
                     /// </summary>
                     bool IsCancelled { get; }
                     /// <summary>
+                    /// Исключение возникшее в результате выполнения обещания, либо причина отмены.
+                    /// </summary>
+                    Exception Error { get; }
+                    /// <summary>
                     /// Creates a new promise dependend on the current one and resolved on
                     /// executing the specified handlers.
                     /// </summary>
                     /// <param name="success">The handler called on the successful promise completion.</param>
                     /// <param name="error">The handler is called if an error while completing the promise occurred.</param>
                     /// <param name="cancel">The handler is called in case of promise cancellation.</param>
                     /// <returns>The newly created dependant promise.</returns>
                     /// <remarks>
                     /// <para>
                     /// If the success handler is specified the dependend promise will be resolved after the handler is
                     /// executed and the dependent promise will be linked to the current one, i.e. the cancellation
                     /// of the dependent property will lead to the cancellation of the current promise. If the
                     /// success handler isn't specified the dependent promise will not be linked to and
                     /// will not be resolved after the successfull resolution of the current one.
                     /// </para>
                     /// <para>
                     /// When the error handler is specified, the exception raised during the current promise completion
                     /// will be passed to it as the parameter. If the error handler returns without raising an
                     /// exception then the dependant promise will be resolved successfully, otherwise the exception
                     /// raised by the handler will be transmitted to the dependent promise. If the handler wants
                     /// to passthrough the original exception it needs to wrap the exception with
-                    /// the <see cref="PromiseTransientException"/>.
+                    /// the <see cref="PromiseTransientException"/>. The handler may raise <see cref="OperationCanceledException"/>
+                    /// to cancel the dependant promise, the innner exception specifies the reason why the promise
+                    /// is canceled.
                     /// </para>
                     /// <para>
                     /// If the cancelation handler is specified and the current promise is cancelled then the dependent
-                    /// promise will be resolved after the handler is executed. If the cancelation hendler raises the
+                    /// promise will be resolved after the handler is executed. If the cancelation handler raises the
                     /// exception it will be passed to the dependent promise.
                     /// </para>
                     /// </remarks>
-                    IPromise Then(Action success, Action<Exception> error, Action cancel);
+                    IPromise Then(Action success, Action<Exception> error, Action<Exception> cancel);
                     IPromise Then(Action success, Action<Exception> error);
                     IPromise Then(Action success);
-                    IPromise Chain(Func<IPromise> chained, Func<Exception, IPromise> error, Func<IPromise> cancel);
+                    IPromise Chain(Func<IPromise> chained, Func<Exception, IPromise> error, Func<Exception, IPromise> cancel);
                     IPromise Chain(Func<IPromise> chained, Func<Exception, IPromise> error);
                     IPromise Chain(Func<IPromise> chained);
                     /// <summary>
                     /// Adds specified listeners to the current promise.
                     /// </summary>
                     /// <param name="success">The handler called on the successful promise completion.</param>
                     /// <param name="error">The handler is called if an error while completing the promise occurred.</param>
                     /// <param name="cancel">The handler is called in case of promise cancellation.</param>
                     /// <returns>The current promise.</returns>
-                    IPromise On(Action success, Action<Exception> error, Action cancel);
+                    IPromise On(Action success, Action<Exception> error, Action<Exception> cancel);
                     IPromise On(Action success, Action<Exception> error);
                     IPromise On(Action success);
                     /// <summary>
                     /// Adds specified listeners to the current promise.
                     /// </summary>
                     /// <param name="handler">The handler called on the specified events.</param>
                     /// <param name = "events">The combination of flags denoting the events for which the
                     /// handler shoud be called.</param>
                     /// <returns>The current promise.</returns>
                     IPromise On(Action handler, PromiseEventType events);
                     /// <summary>
-                    /// Adds the specified error handler to the current promise
-                    /// and creates the new dependant promise.
-                    /// </summary>
-                    /// <param name="error">
-                    /// The error handler. If the error handler returns without
-                    /// an error the dependant promise will be successfully resolved.
-                    /// </param>
-                    /// <returns>
-                    /// The new dependant promise which will be resolved after the error
-                    /// handler is executed.
-                    /// </returns>
-                    /// <remarks>
-                    /// The successfull result of the current promise will be ignored.
-                    /// </remarks>
-                    IPromise Error(Action<Exception> error);
-                    /// <summary>
-                    /// Adds the specified cncellation handler to the current promise
-                    /// and creates the new dependant promise.
-                    /// </summary>
-                    /// <returns>
-                    /// The new dependant promise which will be resolved after the cancellation
-                    /// handler is executed.
-                    /// </returns>
-                    /// <param name="handler">
-                    /// The cancellation handler.
-                    /// </param>
-                    /// <remarks>
-                    /// If the cancellation handler is executed without an error the dependent
-                    /// promise will be successfully resolved, otherwise the raised exception
-                    /// will be passed to the dependant promise. The successful result of the
-                    /// current promise will be ignored.
-                    /// </remarks>
-                    IPromise Cancelled(Action handler);
-                    /// <summary>
                     /// Преобразует результат обещания к заданному типу и возвращает новое обещание.
                     /// </summary>
                     IPromise<T> Cast<T>();
                     /// <summary>
                     /// Синхронизирует текущий поток с обещанием.
                     /// </summary>
                     void Join();
                     /// <summary>
                     /// Синхронизирует текущий поток с обещанием.
                     /// </summary>
                     /// <param name="timeout">Время ожидания, по его истечению возникнет исключение.</param>
                     /// <exception cref="TimeoutException">Превышено время ожидания.</exception>
                     void Join(int timeout);
                 }
             }

Implab/IPromiseT.cs +5 -9

             using System;
             namespace Implab {
                 public interface IPromise<out T> : IPromise {
                     new T Join();
                     new T Join(int timeout);
-                    IPromise<T> On(Action<T> success, Action<Exception> error, Action cancel);
+                    IPromise<T> On(Action<T> success, Action<Exception> error, Action<Exception> cancel);
                     IPromise<T> On(Action<T> success, Action<Exception> error);
                     IPromise<T> On(Action<T> success);
                     new IPromise<T> On(Action handler, PromiseEventType events);
-                    IPromise<T2> Then<T2>(Func<T, T2> mapper, Func<Exception,T2> error, Func<T2> cancel);
+                    IPromise<T2> Then<T2>(Func<T, T2> mapper, Func<Exception, T2> error, Func<Exception, T2> cancel);
-                    IPromise<T2> Then<T2>(Func<T, T2> mapper, Func<Exception,T2> error);
+                    IPromise<T2> Then<T2>(Func<T, T2> mapper, Func<Exception, T2> error);
                     IPromise<T2> Then<T2>(Func<T, T2> mapper);
-                    IPromise<T2> Chain<T2>(Func<T, IPromise<T2>> chained, Func<Exception,IPromise<T2>> error, Func<IPromise<T2>> cancel);
+                    IPromise<T2> Chain<T2>(Func<T, IPromise<T2>> chained, Func<Exception, IPromise<T2>> error, Func<Exception, IPromise<T2>> cancel);
-                    IPromise<T2> Chain<T2>(Func<T, IPromise<T2>> chained, Func<Exception,IPromise<T2>> error);
+                    IPromise<T2> Chain<T2>(Func<T, IPromise<T2>> chained, Func<Exception, IPromise<T2>> error);
                     IPromise<T2> Chain<T2>(Func<T, IPromise<T2>> chained);
-                    IPromise<T2> Error<T2>(Func<Exception,T2> error);
-                    IPromise<T2> Cancelled<T2>(Func<T2> handler);
                 }
             }

Implab/Promise.cs +25 -61

             using System;
             using System.Diagnostics;
             namespace Implab {
                 public class Promise : AbstractPromise<Promise.HandlerDescriptor>, IPromise, IDeferred {
                     public struct HandlerDescriptor {
                         readonly Action m_success;
                         readonly Action<Exception> m_error;
-                        readonly Action m_cancel;
+                        readonly Action<Exception> m_cancel;
                         readonly IDeferred m_deferred;
-                        public HandlerDescriptor(Action success, Action<Exception> error, Action cancel, IDeferred deferred) {
+                        public HandlerDescriptor(Action success, Action<Exception> error, Action<Exception> cancel, IDeferred deferred) {
                             m_success = success;
                             m_error = error;
                             m_cancel = cancel;
                             m_deferred = deferred;
                         }
                         public void SignalSuccess() {
                             if (m_success != null) {
                                 try {
                                     m_success();
                                     if (m_deferred != null)
                                         m_deferred.Resolve();
                                 } catch (Exception err) {
                                     SignalError(err);
                                 }
                             }
                         }
                         public void SignalError(Exception err) {
                             if (m_error != null) {
                                 try {
                                     m_error(err);
                                     if (m_deferred != null)
                                         m_deferred.Resolve();
                                 } catch (Exception err2) {
                                     if (m_deferred != null)
                                         m_deferred.Reject(err2);
                                 }
                             } else {
                                 if (m_deferred != null)
                                     m_deferred.Reject(err);
                             }
                         }
-                        public void SignalCancel() {
+                        public void SignalCancel(Exception reason) {
                             if (m_cancel != null) {
                                 try {
-                                    m_cancel();
+                                    m_cancel(reason);
+                                    if (m_deferred != null)
+                                        m_deferred.Resolve();
+                                } catch (Exception err) {
+                                    SignalError(err);
+                                }
+                            } else if (reason != null && m_error != null) {
+                                try {
+                                    m_error(new OperationCanceledException("The operation was canceled.", reason));
                                     if (m_deferred != null)
                                         m_deferred.Resolve();
                                 } catch (Exception err) {
                                     SignalError(err);
                                 }
                             } else {
                                 if (m_deferred != null)
-                                    m_deferred.Cancel();
+                                    m_deferred.Cancel(reason);
                             }
                         }
                     }
                     public void Resolve() {
                         BeginSetResult();
                         EndSetResult();
                     }
                     public void Reject(Exception error) {
                         SetError(error);
                     }
                     #region implemented abstract members of AbstractPromise
                     protected override void SignalSuccess(HandlerDescriptor handler) {
                         handler.SignalSuccess();
                     }
                     protected override void SignalError(HandlerDescriptor handler, Exception error) {
                         handler.SignalError(error);
                     }
-                    protected override void SignalCancelled(HandlerDescriptor handler) {
+                    protected override void SignalCancelled(HandlerDescriptor handler, Exception reason) {
-                        handler.SignalCancel();
+                        handler.SignalCancel(reason);
                     }
                     protected override void Listen(PromiseEventType events, Action handler) {
                         AddHandler(new HandlerDescriptor(
                             events.HasFlag(PromiseEventType.Success) ? handler : null,
                             events.HasFlag(PromiseEventType.Error) ? new Action<Exception>(err => handler()) : null,
-                            events.HasFlag(PromiseEventType.Cancelled) ? handler : null,
+                            events.HasFlag(PromiseEventType.Cancelled) ? new Action<Exception>(reason => handler()) : null,
                             null
                         ));
                     }
                     #endregion
                     public Type PromiseType {
                         get {
                             return typeof(void);
                         }
                     }
-                    public IPromise Then(Action success, Action<Exception> error, Action cancel) {
+                    public IPromise Then(Action success, Action<Exception> error, Action<Exception> cancel) {
                         var promise = new Promise();
                         if (success != null)
                             promise.On(Cancel, PromiseEventType.Cancelled);
                         AddHandler(new HandlerDescriptor(success, error, cancel, promise));
                         return promise;
                     }
                     public IPromise Then(Action success, Action<Exception> error) {
                         return Then(success, error, null);
                     }
                     public IPromise Then(Action success) {
                         return Then(success, null, null);
                     }
-                    public IPromise On(Action success, Action<Exception> error, Action cancel) {
+                    public IPromise On(Action success, Action<Exception> error, Action<Exception> cancel) {
                         AddHandler(new HandlerDescriptor(success, error, cancel, null));
                         return this;
                     }
                     public IPromise On(Action success, Action<Exception> error) {
                         return On(success, error, null);
                     }
                     public IPromise On(Action success) {
                         return On(success, null, null);
                     }
                     public IPromise On(Action handler, PromiseEventType events) {
                         return On(
                             events.HasFlag(PromiseEventType.Success) ? handler : null,
                             events.HasFlag(PromiseEventType.Error) ? new Action<Exception>(err => handler()) : null,
-                            events.HasFlag(PromiseEventType.Cancelled) ? handler : null
+                            events.HasFlag(PromiseEventType.Cancelled) ? new Action<Exception>(reason => handler()) : null
                         );
                     }
                     public IPromise<T> Cast<T>() {
                         throw new InvalidCastException();
                     }
-                    public IPromise Chain(Func<IPromise> chained, Func<Exception, IPromise> error, Func<IPromise> cancel) {
+                    public IPromise Chain(Func<IPromise> chained, Func<Exception, IPromise> error, Func<Exception,IPromise> cancel) {
                         var medium = new Promise();
                         On(
                             () => {
                                 if (medium.IsCancelled)
                                     return;
                                 if (chained != null)
                                     ConnectPromise(chained(), medium);
                             },
                             ex => {
                                 if (medium.IsCancelled)
                                     return;
                                 if (error != null) {
                                     try {
                                         ConnectPromise(error(ex), medium);
                                     } catch (Exception ex2) {
                                         medium.Reject(ex2);
                                     }
                                 } else {
                                     medium.Reject(ex);
                                 }
                             },
-                            () => {
+                            reason => {
                                 if (medium.IsCancelled)
                                     return;
                                 if (cancel != null)
-                                    ConnectPromise(cancel(), medium);
+                                    ConnectPromise(cancel(reason), medium);
                                 else
-                                    medium.Cancel();
+                                    medium.Cancel(reason);
                             }
                         );
                         if (chained != null)
                             medium.On(Cancel, PromiseEventType.Cancelled);
                         return medium;
                     }
                     static void ConnectPromise(IPromise result, Promise medium) {
                         if (result != null) {
                             result.On(
                                 medium.Resolve,
                                 medium.Reject,
-                                () => medium.Reject(new OperationCanceledException())
+                                medium.Cancel
                             );
-                            medium.On(result.Cancel, PromiseEventType.Cancelled);
+                            medium.On(null,null,result.Cancel);
                         } else {
                             medium.Reject(
                                 new NullReferenceException(
                                     "The chained asynchronous operation returned" +
                                     " 'null' where the promise instance is expected"
                                 )
                             );
                         }
                     }
                     public IPromise Chain(Func<IPromise> chained, Func<Exception, IPromise> error) {
                         return Chain(chained, error, null);
                     }
                     public IPromise Chain(Func<IPromise> chained) {
                         return Chain(chained, null, null);
                     }
-                    public IPromise Error(Action<Exception> error) {
-                        var promise = new Promise();
-                        On(
-                            null,
-                            err => {
-                                if (error != null)
-                                    try {
-                                        error(err);
-                                        promise.Resolve();
-                                    } catch (Exception err2) {
-                                        promise.Reject(err2);
-                                else
-                                    promise.Reject(err);
-                        );
-                        return promise;
-                    public IPromise Cancelled(Action handler) {
-                        var promise = new Promise();
-                        On(
-                            null,
-                            null,
-                            () => {
-                                if (handler != null) {
-                                    try {
-                                        handler();
-                                        promise.Resolve();
-                                    } catch (Exception err) {
-                                        promise.Reject(err);
-                                } else {
-                                    promise.Cancel();
-                        );
-                        return promise;
                 }
             }

Implab/PromiseExtensions.cs +7 -7

             using System.Threading;
             using System;
             using Implab.Diagnostics;
             using System.Collections.Generic;
             #if NET_4_5
             using System.Threading.Tasks;
             #endif
             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.On(that.Cancel, PromiseEventType.Cancelled);
                         that.On(
                             p.Resolve,
                             p.Reject,
                             p.Cancel
                         );
                         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.On(that.Cancel, PromiseEventType.Cancelled);
                         that.On(
                             p.Resolve,
                             p.Reject,
                             p.Cancel
                         );
                         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(null,null,() => head.On(cleanup));
+                        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 CancelCallback(object cookie) {
                         ((ICancellable)cookie).Cancel();
                     }
                     /// <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(CancelCallback, that, milliseconds, -1);
                         that.On(timer.Dispose, PromiseEventType.All);
                         return that;
                     }
                     public static IPromise Bundle(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.Reject(
+                                        medium.Cancel(
                                             new Exception("The dependency promise is cancelled")
                                         );
                                 }
                             );
                         return medium;
                     }
                     public static IPromise<T[]> Bundle<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.Reject(
+                                        medium.Cancel(
-                                            new Exception("The dependency promise is cancelled")
+                                            new Exception("The dependency promise is cancelled", reason)
                                         );
                                 }
                             );
                             i++;
                         }
                         return medium;
                     }
                     #if NET_4_5
                     public static Task<T> GetTask<T>(this IPromise<T> that) {
                         Safe.ArgumentNotNull(that, "that");
                         var tcs = new TaskCompletionSource<T>();
-                        that.On(tcs.SetResult, tcs.SetException, tcs.SetCanceled);
+                        that.On(tcs.SetResult, tcs.SetException, r => tcs.SetCanceled());
                         return tcs.Task;
                     }
                     #endif
                 }
             }

Implab/PromiseT.cs +61 -115

             using System;
             using System.Diagnostics;
             namespace Implab {
                 /// <summary>
                 /// Класс для асинхронного получения результатов. Так называемое "обещание".
                 /// </summary>
                 /// <typeparam name="T">Тип получаемого результата</typeparam>
                 /// <remarks>
                 /// <para>Сервис при обращении к его методу дает обещаиние о выполнении операции,
                 /// клиент получив такое обещание может установить ряд обратных вызово для получения
                 /// событий выполнения обещания, тоесть завершения операции и предоставлении результатов.</para>
                 /// <para>
                 /// Обещение может быть как выполнено, так и выполнено с ошибкой. Для подписки на
                 /// данные события клиент должен использовать методы <c>Then</c>.
                 /// </para>
                 /// <para>
                 /// Сервис, в свою очередь, по окончанию выполнения операции (возможно с ошибкой),
                 /// использует методы <c>Resolve</c> либо <c>Reject</c> для оповещения клиетна о
                 /// выполнении обещания.
                 /// </para>
                 /// <para>
                 /// Если сервер успел выполнить обещание еще до того, как клиент на него подписался,
                 /// то в момент подписки клиента будут вызваны соответсвующие события в синхронном
                 /// режиме и клиент будет оповещен в любом случае. Иначе, обработчики добавляются в
                 /// список в порядке подписания и в этом же порядке они будут вызваны при выполнении
                 /// обещания.
                 /// </para>
                 /// <para>
                 /// Обрабатывая результаты обещания можно преобразовывать результаты либо инициировать
                 /// связанные асинхронные операции, которые также возвращают обещания. Для этого следует
                 /// использовать соответствующую форму методе <c>Then</c>.
                 /// </para>
                 /// <para>
                 /// Также хорошим правилом является то, что <c>Resolve</c> и <c>Reject</c> должен вызывать
                 /// только инициатор обещания иначе могут возникнуть противоречия.
                 /// </para>
                 /// </remarks>
                 public class Promise<T> : AbstractPromise<IDeferred<T>>, IPromise<T>, IDeferred<T> {
-                    class StubDeferred : IDeferred<T> {
+                    class StubDeferred : IDeferred, IDeferred<T> {
                         public static readonly StubDeferred instance = new StubDeferred();
                         StubDeferred() {
                         }
                         #region IDeferred implementation
                         public void Resolve(T value) {
                         }
+                        public void Resolve() {
+                        }
                         public void Reject(Exception error) {
                         }
                         #endregion
                         #region ICancellable implementation
                         public void Cancel() {
                         }
+                        public void Cancel(Exception reason) {
+                        }
                         #endregion
                     }
                     class RemapDescriptor<T2> : IDeferred<T> {
                         readonly Func<T,T2> m_remap;
-                        readonly Func<Exception,T2> m_failed;
+                        readonly Func<Exception, T2> m_failed;
-                        readonly Func<T2> m_cancel;
+                        readonly Func<Exception, T2> m_cancel;
                         readonly IDeferred<T2> m_deferred;
-                        public RemapDescriptor(Func<T,T2> remap, Func<Exception,T2> failed, Func<T2> cancel, IDeferred<T2> deferred ) {
+                        public RemapDescriptor(Func<T,T2> remap, Func<Exception,T2> failed, Func<Exception, T2> cancel, IDeferred<T2> deferred ) {
                             Debug.Assert(deferred != null);
                             m_remap = remap;
                             m_failed = failed;
                             m_cancel = cancel;
                             m_deferred = deferred;
                         }
                         #region IDeferred implementation
                         public void Resolve(T value) {
                             if (m_remap != null) {
                                 try {
                                     m_deferred.Resolve(m_remap(value));
                                 } catch (Exception ex) {
                                     Reject(ex);
                                 }
                             }
                         }
                         public void Reject(Exception error) {
                             if (m_failed != null) {
                                 try {
                                     m_deferred.Resolve(m_failed(error));
                                 } catch (Exception ex) {
                                     m_deferred.Reject(ex);
                                 }
                             } else {
                                 m_deferred.Reject(error);
                             }
                         }
                         #endregion
                         #region ICancellable implementation
-                        public void Cancel() {
+                        public void Cancel(Exception reason) {
                             if (m_cancel != null) {
                                 try {
-                                    m_deferred.Resolve(m_cancel());
+                                    m_deferred.Resolve(m_cancel(reason));
                                 } catch (Exception ex) {
                                     Reject(ex);
                                 }
                             } else {
-                                m_deferred.Cancel();
+                                m_deferred.Cancel(reason);
                             }
                         }
+                        public void Cancel() {
+                            Cancel(null);
+                        }
                         #endregion
                     }
                     class ListenerDescriptor : IDeferred<T> {
                         readonly Action m_handler;
                         readonly PromiseEventType m_events;
                         public ListenerDescriptor(Action handler, PromiseEventType events) {
                             Debug.Assert(handler != null);
                             m_handler = handler;
                             m_events = events;
                         }
                         #region IDeferred implementation
                         public void Resolve(T value) {
                             if (m_events.HasFlag(PromiseEventType.Success)) {
                                 try {
                                     m_handler();
                                 // Analysis disable once EmptyGeneralCatchClause
                                 } catch {
                                 }
                             }
                         }
                         public void Reject(Exception error) {
                             if (m_events.HasFlag(PromiseEventType.Error)){
                                 try {
                                     m_handler();
                                     // Analysis disable once EmptyGeneralCatchClause
                                 } catch {
                                 }
                             }
                         }
                         #endregion
                         #region ICancellable implementation
                         public void Cancel() {
+                            Cancel(null);
+                        }
+                        public void Cancel(Exception reason) {
                             if (m_events.HasFlag(PromiseEventType.Cancelled)){
                                 try {
                                     m_handler();
                                     // Analysis disable once EmptyGeneralCatchClause
                                 } catch {
                                 }
                             }
                         }
                         #endregion
                     }
                     class ValueEventDescriptor : IDeferred<T> {
                         readonly Action<T> m_success;
                         readonly Action<Exception> m_failed;
-                        readonly Action m_cancelled;
+                        readonly Action<Exception> m_cancelled;
                         readonly IDeferred<T> m_deferred;
-                        public ValueEventDescriptor(Action<T> success, Action<Exception> failed, Action cancelled, IDeferred<T> deferred) {
+                        public ValueEventDescriptor(Action<T> success, Action<Exception> failed, Action<Exception> cancelled, IDeferred<T> deferred) {
                             Debug.Assert(deferred != null);
                             m_success = success;
                             m_failed = failed;
                             m_cancelled = cancelled;
                             m_deferred = deferred;
                         }
                         #region IDeferred implementation
                         public void Resolve(T value) {
                             if (m_success != null) {
                                 try {
                                     m_success(value);
                                     m_deferred.Resolve(value);
                                 } catch (Exception ex) {
                                     Reject(ex);
                                 }
                             }
                         }
                         public void Reject(Exception error) {
                             if (m_failed != null) {
                                 try {
                                     m_failed(error);
                                     m_deferred.Resolve(default(T));
                                 } catch(Exception ex) {
                                     m_deferred.Reject(ex);
                                 }
                             } else {
                                 m_deferred.Reject(error);
                             }
                         }
                         #endregion
                         #region ICancellable implementation
-                        public void Cancel() {
+                        public void Cancel(Exception reason) {
                             if (m_cancelled != null) {
                                 try {
-                                    m_cancelled();
+                                    m_cancelled(reason);
                                     m_deferred.Resolve(default(T));
-                                } catch(Exception ex) {
+                                } catch (Exception ex) {
                                     Reject(ex);
                                 }
                             } else {
-                                m_deferred.Cancel();
+                                m_deferred.Cancel(reason);
                             }
                         }
+                        public void Cancel() {
+                            Cancel(null);
+                        }
                         #endregion
                     }
                     public class EventDescriptor : IDeferred<T> {
                         readonly Action m_success;
                         readonly Action<Exception> m_failed;
-                        readonly Action m_cancelled;
+                        readonly Action<Exception> m_cancelled;
-                        readonly IDeferred<T> m_deferred;
+                        readonly IDeferred m_deferred;
-                        public EventDescriptor(Action success, Action<Exception> failed, Action cancelled, IDeferred<T> deferred) {
+                        public EventDescriptor(Action success, Action<Exception> failed, Action<Exception> cancelled, IDeferred deferred) {
                             Debug.Assert(deferred != null);
                             m_success = success;
                             m_failed = failed;
                             m_cancelled = cancelled;
                             m_deferred = deferred;
                         }
                         #region IDeferred implementation
                         public void Resolve(T value) {
                             if (m_success != null) {
                                 try {
                                     m_success();
-                                    m_deferred.Resolve(value);
+                                    m_deferred.Resolve();
                                 } catch (Exception ex) {
                                     Reject(ex);
                                 }
                             }
                         }
                         public void Reject(Exception error) {
                             if (m_failed != null) {
                                 try {
                                     m_failed(error);
-                                    m_deferred.Resolve(default(T));
+                                    m_deferred.Resolve();
-                                }catch (Exception ex)
+                                } catch (Exception ex) {
                                     m_deferred.Reject(ex);
                                 }
                             } else {
                                 m_deferred.Reject(error);
                             }
                         }
                         #endregion
                         #region ICancellable implementation
-                        public void Cancel() {
+                        public void Cancel(Exception reason) {
                             if (m_cancelled != null) {
                                 try {
-                                    m_cancelled();
+                                    m_cancelled(reason);
-                                    m_deferred.Resolve(default(T));
+                                    m_deferred.Resolve();
                                 } catch (Exception ex) {
                                     Reject(ex);
                                 }
                             } else {
-                                m_deferred.Cancel();
+                                m_deferred.Cancel(reason);
                             }
                         }
+                        public void Cancel() {
+                            Cancel(null);
+                        }
                         #endregion
                     }
                     T m_result;
                     public virtual void Resolve(T value) {
                         if (BeginSetResult()) {
                             m_result = value;
                             EndSetResult();
                         }
                     }
                     public void Reject(Exception error) {
                         SetError(error);
                     }
                     public Type PromiseType {
                         get {
                             return typeof(T);
                         }
                     }
                     public new T Join() {
                         WaitResult(-1);
                         return m_result;
                     }
                     public new T Join(int timeout) {
                         WaitResult(timeout);
                         return m_result;
                     }
-                    public IPromise<T> On(Action<T> success, Action<Exception> error, Action cancel) {
+                    public IPromise<T> On(Action<T> success, Action<Exception> error, Action<Exception> cancel) {
                         AddHandler(new ValueEventDescriptor(success, error, cancel, StubDeferred.instance));
                         return this;
                     }
                     public IPromise<T> On(Action<T> success, Action<Exception> error) {
                         AddHandler(new ValueEventDescriptor(success, error, null, StubDeferred.instance));
                         return this;
                     }
                     public IPromise<T> On(Action<T> success) {
                         AddHandler(new ValueEventDescriptor(success, null, null, StubDeferred.instance));
                         return this;
                     }
                     public IPromise<T> On(Action handler, PromiseEventType events) {
                         Listen(events, handler);
                         return this;
                     }
-                    public IPromise<T2> Then<T2>(Func<T, T2> mapper, Func<Exception, T2> error, Func<T2> cancel) {
+                    public IPromise<T2> Then<T2>(Func<T, T2> mapper, Func<Exception, T2> error, Func<Exception, T2> cancel) {
                         var promise = new Promise<T2>();
                         if (mapper != null)
-                            promise.On(Cancel, PromiseEventType.Cancelled);
+                            promise.On((Action)null, null, Cancel);
                         AddHandler(new RemapDescriptor<T2>(mapper, error, cancel, promise));
                         return promise;
                     }
                     public IPromise<T2> Then<T2>(Func<T, T2> mapper, Func<Exception, T2> error) {
                         var promise = new Promise<T2>();
                         if (mapper != null)
-                            promise.On(Cancel, PromiseEventType.Cancelled);
+                            promise.On((Action)null, null, Cancel);
                         AddHandler(new RemapDescriptor<T2>(mapper, error, null, promise));
                         return promise;
                     }
                     public IPromise<T2> Then<T2>(Func<T, T2> mapper) {
                         var promise = new Promise<T2>();
                         if (mapper != null)
-                            promise.On(Cancel, PromiseEventType.Cancelled);
+                            promise.On((Action)null, null, Cancel);
                         AddHandler(new RemapDescriptor<T2>(mapper, null, null, promise));
                         return promise;
                     }
-                    public IPromise<T2> Chain<T2>(Func<T, IPromise<T2>> chained, Func<Exception, IPromise<T2>> error, Func<IPromise<T2>> cancel) {
+                    public IPromise<T2> Chain<T2>(Func<T, IPromise<T2>> chained, Func<Exception, IPromise<T2>> error, Func<Exception, IPromise<T2>> cancel) {
                         // this promise will be resolved when an asyc operation is started
                         var promise = new Promise<IPromise<T2>>();
                         AddHandler(new RemapDescriptor<IPromise<T2>>(
                             chained,
                             error,
                             cancel,
                             promise
                         ));
                         var medium = new Promise<T2>();
                         if (chained != null)
                             medium.On(Cancel, PromiseEventType.Cancelled);
                         // we need to connect started async operation with the medium
                         // if the async operation hasn't been started by the some reason
                         // report is to the medium
                         promise.On(
                             result => ConnectPromise<T2>(result, medium),
                             medium.Reject,
                             medium.Cancel
                         );
                         return medium;
                     }
                     static void ConnectPromise<T2>(IPromise<T2> result, Promise<T2> medium) {
                         if (result != null) {
                             result.On(
                                 medium.Resolve,
                                 medium.Reject,
-                                () => medium.Reject(new OperationCanceledException())
+                                medium.Cancel
                             );
                             medium.On(result.Cancel, PromiseEventType.Cancelled);
                         } else {
                             medium.Reject(
                                 new NullReferenceException(
                                     "The chained asynchronous operation returned" +
                                     " 'null' where the promise instance is expected"
                                 )
                             );
                         }
                     }
                     public IPromise<T2> Chain<T2>(Func<T, IPromise<T2>> chained, Func<Exception, IPromise<T2>> error) {
                         return Chain(chained, error, null);
                     }
                     public IPromise<T2> Chain<T2>(Func<T, IPromise<T2>> chained) {
                         return Chain(chained, null, null);
                     }
-                    public IPromise<T2> Error<T2>(Func<Exception, T2> error) {
+                    public IPromise Then(Action success, Action<Exception> error, Action<Exception> cancel) {
-                        var promise = new Promise<T2>();
+                        var promise = new Promise();
-                        if (error != null)
-                            On(
-                                (Action<T>)null,
-                                ex => {
-                                    try {
-                                        promise.Resolve(error(ex));
-                                    } catch (Exception ex2) {
-                                        promise.Reject(ex2);
-                            );
-                        else
-                            Listen(PromiseEventType.Error, () => promise.Resolve(default(T2)));
-                        return promise;
-                    public IPromise<T2> Cancelled<T2>(Func<T2> handler) {
-                        var promise = new Promise<T2>();
-                        if (handler != null)
-                            On(
-                                (Action<T>)null,
-                                null,
-                                () => {
-                                    try {
-                                        promise.Resolve(handler());
-                                    } catch (Exception ex) {
-                                        promise.Reject(ex);
-                            });
-                        else
-                            Listen(PromiseEventType.Cancelled, () => promise.Resolve(default(T2)));
-                        return promise;
-                    public IPromise Then(Action success, Action<Exception> error, Action cancel) {
-                        var promise = new Promise<T>();
                         if (success != null)
-                            promise.On(Cancel, PromiseEventType.Cancelled);
+                            promise.On(null, null, Cancel);
                         AddHandler(new EventDescriptor(success, error, cancel, promise));
                         return promise;
                     }
                     public IPromise Then(Action success, Action<Exception> error) {
                         return Then(success, error, null);
                     }
                     public IPromise Then(Action success) {
                         return Then(success, null, null);
                     }
-                    public IPromise Chain(Func<IPromise> chained, Func<Exception, IPromise> error, Func<IPromise> cancel) {
+                    public IPromise Chain(Func<IPromise> chained, Func<Exception, IPromise> error, Func<Exception, IPromise> cancel) {
                         var promise = new Promise<IPromise>();
                         AddHandler(
                             new RemapDescriptor<IPromise>(
                                 x => chained(),
                                 error,
                                 cancel,
                                 promise
                             )
                         );
                         var medium = new Promise();
                         if (chained != null)
-                            medium.On(Cancel, PromiseEventType.Cancelled);
+                            medium.On(null, null, Cancel);
                         promise.On(
                             result => ConnectPromise(result, medium),
                             medium.Reject,
                             medium.Cancel
                         );
                         return medium;
                     }
                     static void ConnectPromise(IPromise result, Promise medium) {
                         if (result != null) {
                             result.On(
                                 medium.Resolve,
                                 medium.Reject,
-                                () => medium.Reject(new OperationCanceledException())
+                                medium.Cancel
                             );
-                            medium.On(result.Cancel, PromiseEventType.Cancelled);
+                            medium.On(null, null, result.Cancel);
                         } else {
                             medium.Reject(
                                 new NullReferenceException(
                                     "The chained asynchronous operation returned" +
                                     " 'null' where the promise instance is expected"
                                 )
                             );
                         }
                     }
                     public IPromise Chain(Func<IPromise> chained, Func<Exception, IPromise> error) {
                         return Chain(chained, error, null);
                     }
                     public IPromise Chain(Func<IPromise> chained) {
                         return Chain(chained, null, null);
                     }
-                    public IPromise On(Action success, Action<Exception> error, Action cancel) {
+                    public IPromise On(Action success, Action<Exception> error, Action<Exception> cancel) {
                         AddHandler(new EventDescriptor(success,error,cancel, StubDeferred.instance));
                         return this;
                     }
                     public IPromise On(Action success, Action<Exception> error) {
                         AddHandler(new EventDescriptor(success, error, null, StubDeferred.instance));
                         return this;
                     }
                     public IPromise On(Action success) {
                         Listen(PromiseEventType.Success, success);
                         return this;
                     }
                     IPromise IPromise.On(Action handler, PromiseEventType events) {
                         Listen(events,handler);
                         return this;
                     }
-                    public IPromise Error(Action<Exception> error) {
-                        var promise = new Promise();
-                        if (error != null)
-                            On(
-                                (Action<T>)null,
-                                ex => {
-                                try {
-                                    error(ex);
-                                    promise.Resolve();
-                                } catch (Exception ex2) {
-                                    promise.Reject(ex2);
-                            });
-                        else
-                            Listen(PromiseEventType.Error, promise.Resolve);
-                        return promise;
-                    public IPromise Cancelled(Action handler) {
-                        var promise = new Promise();
-                        if (handler != null)
-                            On(
-                                (Action<T>)null,
-                                null,
-                                () => {
-                                    try {
-                                        handler();
-                                        promise.Resolve();
-                                    } catch (Exception ex) {
-                                        promise.Reject(ex);
-                                });
-                        else
-                            Listen(PromiseEventType.Cancelled, promise.Resolve);
-                        return promise;
                     public IPromise<T2> Cast<T2>() {
                         return (IPromise<T2>)this;
                     }
                     #region implemented abstract members of AbstractPromise
                     protected override void SignalSuccess(IDeferred<T> handler) {
                         handler.Resolve(m_result);
                     }
                     protected override void SignalError(IDeferred<T> handler, Exception error) {
                         handler.Reject(error);
                     }
-                    protected override void SignalCancelled(IDeferred<T> handler) {
+                    protected override void SignalCancelled(IDeferred<T> handler, Exception reason) {
-                        handler.Cancel();
+                        handler.Cancel(reason);
                     }
                     protected override void Listen(PromiseEventType events, Action handler) {
                         if (handler != null)
                             AddHandler(new ListenerDescriptor(handler, events));
                     }
                     #endregion
                     public static IPromise<T> ResultToPromise(T value) {
                         var p = new Promise<T>();
                         p.Resolve(value);
                         return p;
                     }
                     public static IPromise<T> ExceptionToPromise(Exception error) {
                         var p = new Promise<T>();
                         p.Reject(error);
                         return p;
                     }
                 }
             }

Implab/PromiseTransientException.cs 0 -1

             using System;
             namespace Implab {
                 [Serializable]
                 public class PromiseTransientException : Exception {
                     /// <summary>
                     /// Initializes a new instance of the <see cref="PromiseTransientException"/> class.
                     /// </summary>
                     /// <param name="inner">The exception that is the cause of the current exception.</param>
                     public PromiseTransientException(Exception inner) : base("The preceding promise has failed", inner) {
                     }
                     /// <summary>
                     /// Initializes a new instance of the <see cref="PromiseTransientException"/> class
                     /// </summary>
                     /// <param name="message">A <see cref="T:System.String"/> that describes the exception. </param>
                     /// <param name="inner">The exception that is the cause of the current exception. </param>
                     public PromiseTransientException(string message, Exception inner)
                         : base(message, inner) {
                     }
                     /// <summary>
                     /// Initializes a new instance of the <see cref="PromiseTransientException"/> class
                     /// </summary>
                     /// <param name="context">The contextual information about the source or destination.</param>
                     /// <param name="info">The object that holds the serialized object data.</param>
                     protected PromiseTransientException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
                         : base(info, context) {
                     }
                 }
             }

Implab/SyncContextPromise.cs +4 -3

             using System.Threading;
+            using System;
             namespace Implab {
                 public class SyncContextPromise<T> : Promise<T> {
                     readonly SynchronizationContext m_context;
                     public SyncContextPromise(SynchronizationContext context) {
                         Safe.ArgumentNotNull(context, "context");
                         m_context = context;
                     }
                     protected override void SignalSuccess(IDeferred<T> handler) {
                         m_context.Post(x => base.SignalSuccess(handler), null);
                     }
-                    protected override void SignalError(IDeferred<T> handler, System.Exception error) {
+                    protected override void SignalError(IDeferred<T> handler, Exception error) {
                         m_context.Post(x => base.SignalError(handler, error), null);
                     }
-                    protected override void SignalCancelled(IDeferred<T> handler) {
+                    protected override void SignalCancelled(IDeferred<T> handler, Exception reason) {
-                        m_context.Post(x => base.SignalCancelled(handler), null);
+                        m_context.Post(x => base.SignalCancelled(handler, reason), null);
                     }
                 }
             }

Implab/TaskController.cs +7 0

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Threading;
             namespace Implab
             {
                 /// <summary>
                 /// This class allows to interact with asyncronuos task.
                 /// </summary>
                 /// <remarks>
                 /// Members of this object are thread safe.
                 /// </remarks>
                 public class TaskController: IProgressNotifier, ITaskController
                 {
                     readonly object m_lock;
                     string m_message;
                     float m_current;
                     float m_max;
                     bool m_cancelled;
                     public event EventHandler Cancelled;
                     public event EventHandler<ValueEventArgs<string>> MessageUpdated;
                     public event EventHandler<ValueEventArgs<float>> ProgressUpdated;
                     public event EventHandler<ProgressInitEventArgs> ProgressInit;
                     public TaskController()
                     {
                         m_lock = new Object();
                     }
                     public string Message
                     {
                         get
                         {
                             lock (m_lock)
                                 return m_message;
                         }
                         set
                         {
                             lock (m_lock)
                             {
                                 m_message = value;
                                 OnMessageUpdated();
                             }
                         }
                     }
                     public float CurrentProgress
                     {
                         get
                         {
                             lock (m_lock)
                                 return m_current;
                         }
                         set
                         {
                             lock (m_lock)
                             {
                                 var prev = m_current;
                                 m_current = value;
                                 if (m_current >= m_max)
                                     m_current = m_max;
                                 if (m_current != prev)
                                     OnProgressUpdated();
                             }
                         }
                     }
                     public void InitProgress(float current, float max, string message)
                     {
                         if (max < 0)
                             throw new ArgumentOutOfRangeException("max");
                         if (current < 0 || current > max)
                             throw new ArgumentOutOfRangeException("current");
                         lock(m_lock) {
                             m_current = current;
                             m_max = max;
                             m_message = message;
                             OnProgressInit();
                         }
                     }
                     public bool IsCancelled {
                         get {
                             lock (m_lock)
                                 return m_cancelled;
                         }
                     }
                     public void Cancel() {
                         lock (m_lock) {
                             if (!m_cancelled)
                                 m_cancelled = true;
                         }
                     }
+                    public void Cancel(Exception reason) {
+                        lock (m_lock) {
+                            if (!m_cancelled)
+                                m_cancelled = true;
+                        }
+                    }
                     protected virtual void OnCancelled() {
                         var temp = Cancelled;
                         if (temp != null) {
                             temp(this,new EventArgs());
                         }
                     }
                     protected virtual void OnMessageUpdated()
                     {
                         var temp = MessageUpdated;
                         if (temp != null)
                         {
                             temp(this, new ValueEventArgs<string>(m_message));
                         }
                     }
                     protected virtual void OnProgressUpdated()
                     {
                         var temp = ProgressUpdated;
                         if (temp != null)
                         {
                             temp(this,new ValueEventArgs<float>(m_current));
                         }
                     }
                     protected virtual void OnProgressInit()
                     {
                         var temp = ProgressInit;
                         if (temp != null)
                         {
                             temp(this, new ProgressInitEventArgs(m_current,m_max, m_message));
                         }
                     }
                 }
             }

MonoPlay/Program.cs +1 -1

             using System;
             using Implab.Diagnostics;
             using Implab.Parallels;
             using Implab;
             using System.Collections.Generic;
             using System.Collections.Concurrent;
             using System.Threading;
             namespace MonoPlay {
                 class MainClass {
                     public static void Main(string[] args) {
                         if (args == null)
                             throw new ArgumentNullException("args");
                         var t1 = Environment.TickCount;
                         const int reads = 100000;
                         const int writes = 1000;
                         const int readThreads = 8;
                         const int writeThreads = 0;
                         var l = new SharedLock();
                         var st = new HashSet<int>();
                         Action reader1 = () => {
                             for (int i =0; i < reads; i++) {
                                 try {
                                     l.LockShared();
                                     st.Contains(i % 1000);
                                     Thread.Sleep(0);
                                 } finally {
                                     l.Release();
                                 }
                             }
                         };
                         Action reader2 = () => {
                             for(var i = 0; i < reads; i++)
                                 lock(st) {
                                     st.Contains(i % 1000);
                                     Thread.Sleep(0);
                                 }
                         };
                         Action writer1 = () => {
                             var rnd = new Random(Environment.TickCount);
                             for (int i = 0; i < writes; i++) {
                                 try {
                                     l.LockExclusive();
                                     st.Add(rnd.Next(1000));
                                     //Thread.Sleep(1);
                                 } finally {
                                     l.Release();
                                 }
                             }
                         };
                         Action writer2 = () => {
                             var rnd = new Random(Environment.TickCount);
                             for (int i = 0; i < writes; i++) {
                                 lock (st) {
                                     st.Add(rnd.Next(1000));
                                     //Thread.Sleep(1);
                                 }
                             }
                         };
                         var readers = new IPromise[readThreads];
                         for (int i = 0; i < readThreads; i++)
-                            readers[i] = AsyncPool.RunThread(reader1);
+                            readers[i] = AsyncPool.RunThread(reader2);
                         var writers = new IPromise[writeThreads];
                         for (int i = 0; i < writeThreads; i++)
                             writers[i] = AsyncPool.RunThread(writer1);
                         new [] {
                             readers.Bundle().On(() => Console.WriteLine("readers complete in {0} ms", Environment.TickCount - t1)),
                             writers.Bundle().On(() => Console.WriteLine("writers complete in {0} ms", Environment.TickCount - t1))
                         }.Bundle().Join();
                         var t2 = Environment.TickCount;
                         Console.WriteLine("done: {0} ms, {1:.00} Mb, {2} GC", t2 - t1, GC.GetTotalMemory(false) / (1024*1024), GC.CollectionCount(0) );
                     }
                 }
             }

General Comments 0

Write
Preview

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

No TODOs yet

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

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