diff --git a/.hgignore b/.hgignore
--- a/.hgignore
+++ b/.hgignore
@@ -10,3 +10,4 @@ Implab.Fx/obj/
 Implab.Fx/bin/
 Implab.Fx.Test/bin/
 Implab.Fx.Test/obj/
+_ReSharper.Implab/
diff --git a/Implab.Test/AsyncTests.cs b/Implab.Test/AsyncTests.cs
--- a/Implab.Test/AsyncTests.cs
+++ b/Implab.Test/AsyncTests.cs
@@ -1,101 +1,333 @@
 using System;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using Implab;
 using System.Reflection;
 using System.Threading;
+using Implab.Parallels;
 
-namespace Implab.Tests
-{
-	[TestClass]
-	public class AsyncTests
-	{
-		[TestMethod]
-		public void ResolveTest ()
-		{
-			int res = -1;
-			var p = new Promise<int> ();
-			p.Then (x => res = x);
-			p.Resolve (100);
+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(res, 100);
+        }
+
+        [TestMethod]
+        public void RejectTest() {
+            int res = -1;
+            Exception err = null;
+
+            var p = new Promise<int>();
+            p.Then(x => res = x, e => err = e);
+            p.Reject(new ApplicationException("error"));
+
+            Assert.AreEqual(res, -1);
+            Assert.AreEqual(err.Message, "error");
+
+        }
+
+        [TestMethod]
+        public void JoinSuccessTest() {
+            var p = new Promise<int>();
+            p.Resolve(100);
+            Assert.AreEqual(p.Join(), 100);
+        }
 
-			Assert.AreEqual (res, 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.Map(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);
+
+            p.Reject(new Exception());
+
+            Assert.AreEqual(p2.Join(), 101);
+        }
 
         [TestMethod]
-		public void RejectTest ()
-		{
-			int res = -1;
-			Exception err = null;
+        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);
 
-			var p = new Promise<int> ();
-			p.Then (x => res = x, e => err = e);
-			p.Reject (new ApplicationException ("error"));
+            Assert.AreEqual(p3.Join(), "100");
+        }
 
-			Assert.AreEqual (res, -1);
-			Assert.AreEqual (err.Message, "error");
+        [TestMethod]
+        public void PoolTest() {
+            var pid = Thread.CurrentThread.ManagedThreadId;
+            var p = AsyncPool.Invoke(() => Thread.CurrentThread.ManagedThreadId);
 
-		}
+            Assert.AreNotEqual(pid, p.Join());
+        }
 
         [TestMethod]
-		public void JoinSuccessTest ()
-		{
-			var p = new Promise<int> ();
-			p.Resolve (100);
-			Assert.AreEqual (p.Join (), 100);
-		}
+        public void WorkerPoolSizeTest() {
+            var pool = new WorkerPool(5, 10, 0);
+
+            Assert.AreEqual(5, pool.ThreadCount);
+
+            pool.Invoke(() => { Thread.Sleep(1000000); return 10; });
+            pool.Invoke(() => { Thread.Sleep(1000000); return 10; });
+            pool.Invoke(() => { Thread.Sleep(1000000); return 10; });
+
+            Assert.AreEqual(5, pool.ThreadCount);
+
+            for (int i = 0; i < 100; i++)
+                pool.Invoke(() => { Thread.Sleep(1000000); return 10; });
+            Thread.Sleep(100);
+            Assert.AreEqual(10, pool.ThreadCount);
+
+            pool.Dispose();
+        }
+
+        [TestMethod]
+        public void WorkerPoolCorrectTest() {
+            var pool = new WorkerPool(0,1000,100);
+
+            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))
+                    .Anyway(() => {
+                        Interlocked.Decrement(ref pending);
+                        if (pending == 0)
+                            stop.Set();
+                    });
+            }
+
+            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.ThreadCount);
+            pool.Dispose();
+            Thread.Sleep(100);
+            Assert.AreEqual(0, pool.ThreadCount);
+            pool.Dispose();
+        }
 
         [TestMethod]
-		public void JoinFailTest ()
-		{
-			var p = new Promise<int> ();
-			p.Reject (new ApplicationException ("failed"));
+        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;
+
+            int itemsPerWriter = 1000;
+            int writersCount = 3;
 
-			try {
-				p.Join ();
-				throw new ApplicationException ("WRONG!");
-			} catch (TargetInvocationException err) {
-				Assert.AreEqual (err.InnerException.Message, "failed");
-			} catch {
-				Assert.Fail ("Got wrong excaption");
-			}
-		}
+            for (int i = 0; i < writersCount; i++) {
+                Interlocked.Increment(ref writers);
+                var wn = i;
+                AsyncPool
+                    .InvokeNewThread(() => {
+                        for (int ii = 0; ii < itemsPerWriter; ii++) {
+                            queue.Enqueue(1);
+                        }
+                        return 1;
+                    })
+                    .Anyway(() => Interlocked.Decrement(ref writers));
+            }
+
+            for (int i = 0; i < 10; i++) {
+                Interlocked.Increment(ref readers);
+                var wn = i;
+                AsyncPool
+                    .InvokeNewThread(() => {
+                        int t;
+                        do {
+                            while (queue.TryDequeue(out t))
+                                Interlocked.Add(ref total, t);
+                        } while (writers > 0);
+                        return 1;
+                    })
+                    .Anyway(() => {
+                        Interlocked.Decrement(ref readers);
+                        if (readers == 0)
+                            stop.Set();
+                    });
+            }
+
+            stop.WaitOne();
+
+            Assert.AreEqual(itemsPerWriter * writersCount, total);
+        }
 
         [TestMethod]
-		public void MapTest ()
-		{
-			var p = new Promise<int> ();
+        public void ParallelMapTest() {
+
+            int count = 100000;
+
+            double[] args = new double[count];
+            var rand = new Random();
+
+            for (int i = 0; i < count; i++)
+                args[i] = rand.NextDouble();
 
-			var p2 = p.Map (x => x.ToString ());
-			p.Resolve (100);
+            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);
 
-			Assert.AreEqual (p2.Join (), "100");
-		}
+            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 ChainTest ()
-		{
-			var p1 = new Promise<int> ();
+        public void ChainedMapTest() {
+
+            using (var pool = new WorkerPool(8,100,0)) {
+                int count = 10000;
+
+                double[] args = new double[count];
+                var rand = new Random();
+
+                for (int i = 0; i < count; i++)
+                    args[i] = rand.NextDouble();
 
-			var p3 = p1.Chain (x => {
-				var p2 = new Promise<string> ();
-				p2.Resolve (x.ToString ());
-				return p2;
-			});
+                var t = Environment.TickCount;
+                var res = args
+                    .ChainedMap(
+                        x => pool.Invoke(
+                            () => Math.Sin(x * x)
+                        ),
+                        4
+                    )
+                    .Join();
 
-			p1.Resolve (100);
+                Console.WriteLine("Map complete in {0} ms", Environment.TickCount - t);
 
-			Assert.AreEqual (p3.Join (), "100");
-		}
+                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 PoolTest ()
-		{
-			var pid = Thread.CurrentThread.ManagedThreadId;
-			var p = AsyncPool.Invoke (() => {
-				return Thread.CurrentThread.ManagedThreadId;
-			});
+        public void ParallelForEachTest() {
+
+            int count = 100000;
+
+            int[] 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);
+        }
 
-			Assert.AreNotEqual (pid, p.Join ());
-		}
-	}
+        [TestMethod]
+        public void ComplexCase1Test() {
+            var flags = new bool[3];
+
+            // op1 (aync 200ms) => op2 (async 200ms) => op3 (sync map)
+
+            var p = PromiseHelper
+                .Sleep(200, "Alan")
+                .Cancelled(() => flags[0] = true)
+                .Chain(x =>
+                    PromiseHelper
+                        .Sleep(200, "Hi, " + x)
+                        .Map(y => y)
+                        .Cancelled(() => flags[1] = true)
+                )
+                .Cancelled(() => flags[2] = true);
+            Thread.Sleep(300);
+            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]);
+        }
+    }
 }
 
diff --git a/Implab.Test/Implab.Test.csproj b/Implab.Test/Implab.Test.csproj
--- a/Implab.Test/Implab.Test.csproj
+++ b/Implab.Test/Implab.Test.csproj
@@ -46,6 +46,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="AsyncTests.cs" />
+    <Compile Include="PromiseHelper.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
diff --git a/Implab.Test/PromiseHelper.cs b/Implab.Test/PromiseHelper.cs
new file mode 100644
--- /dev/null
+++ b/Implab.Test/PromiseHelper.cs
@@ -0,0 +1,17 @@
+using Implab.Parallels;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+
+namespace Implab.Test {
+    class PromiseHelper {
+        public static Promise<T> Sleep<T>(int timeout, T retVal) {
+            return AsyncPool.Invoke(() => {
+                Thread.Sleep(timeout);
+                return retVal;
+            });
+        }
+    }
+}
diff --git a/Implab.suo b/Implab.suo
index 61301b443c112c10f3b3ee2fe11cecb25781ac9c..453df4ad2d602dd29c42a1de303bdb9f56e12f58
GIT binary patch
literal 75776
zc%1D$4R{;Xk?SN*oRC0B1BBliYEnooMY1i)PDqKYpAc{o6FWZzhh#0UZ4p@#lAPEf
zKq>SGD5WKZ0xcv2C|qgF(Q7GfY00HPq2&U!&9yYW{vAE|dUq6#pK@?CH#56WTCG>w
zeJjaWW}m;YcBS1n^Zw?|o0&K7*=LUa!<`SF@JB(DJ}OKV{(g9-FkSWC6o49bGgrQ!
z3h?*ChYz!_F9A4gr>aTs0!)K8I}xB3U<LrT`AmR1fH?rO0FD5dEjPPxB*0Ms3jmG=
zm<R9yfcXH&02~W&9Ki7aCjhtrngLEy`pPNr`9XksfKvfZ1Naa?1HkD33jsb1a0bAc
z0E+-V0?-KH0B`~<2516s1GE6N0R#X%0A2teKr6rn080Rt0-Ob~jQX}9oDHxXU=2V!
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
Wo_uO04<2jYWh|n%-Tsrk{r?{w1?ye_

diff --git a/Implab.v11.suo b/Implab.v11.suo
new file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0324d71b1911ff2672c0c8ae7c7d19bceabeae2e
GIT binary patch
literal 121344
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
WoO;jv`>tL0!1LQ?6;=O-IQ%~u*9_DE

diff --git a/Implab/AsyncPool.cs b/Implab/AsyncPool.cs
deleted file mode 100644
--- a/Implab/AsyncPool.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-using System;
-using System.Threading;
-
-namespace Implab {
-	/// <summary>
-	/// Класс для распаралеливания задач.
-	/// </summary>
-	/// <remarks>
-	/// Используя данный класс и лямда выражения можно распараллелить
-	/// вычисления, для этого используется концепция обещаний.
-	/// </remarks>
-	public static class AsyncPool {
-
-		public static Promise<T> Invoke<T>(Func<T> func) {
-			var p = new Promise<T>();
-
-			ThreadPool.QueueUserWorkItem(param => {
-				try {
-					p.Resolve(func());
-				} catch(Exception e) {
-					p.Reject(e);
-				}
-			});
-
-			return p;
-		}
-	}
-}
diff --git a/Implab/ICancellable.cs b/Implab/ICancellable.cs
new file mode 100644
--- /dev/null
+++ b/Implab/ICancellable.cs
@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Implab {
+    public interface ICancellable {
+        bool Cancel();
+    }
+}
diff --git a/Implab/IProgressHandler.cs b/Implab/IProgressHandler.cs
new file mode 100644
--- /dev/null
+++ b/Implab/IProgressHandler.cs
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Implab {
+    public interface IProgressHandler {
+        string Message {
+            get;
+            set;
+        }
+        float CurrentProgress {
+            get;
+            set;
+        }
+        void InitProgress(float current, float max, string message);
+    }
+}
diff --git a/Implab/IProgressNotifier.cs b/Implab/IProgressNotifier.cs
new file mode 100644
--- /dev/null
+++ b/Implab/IProgressNotifier.cs
@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Implab
+{
+    public interface IProgressNotifier
+    {
+        event EventHandler<ValueEventArgs<string>> MessageUpdated;
+        event EventHandler<ValueEventArgs<float>> ProgressUpdated;
+        event EventHandler<ProgressInitEventArgs> ProgressInit;
+    }
+}
diff --git a/Implab/IPromise.cs b/Implab/IPromise.cs
new file mode 100644
--- /dev/null
+++ b/Implab/IPromise.cs
@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Implab
+{
+    public interface IPromise: ICancellable
+    {
+        /// <summary>
+        /// Check whereather the promise has no more than one dependent promise.
+        /// </summary>
+        bool IsExclusive
+        {
+            get;
+        }
+
+        /// <summary>
+        /// The current state of the promise.
+        /// </summary>
+        PromiseState State
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Registers handler for the case when the promise is cencelled. If the promise already cancelled the
+        /// handler will be invoked immediatelly.
+        /// </summary>
+        /// <param name="handler">The handler</param>
+        void HandleCancelled(Action handler);
+    }
+}
diff --git a/Implab/ITaskController.cs b/Implab/ITaskController.cs
new file mode 100644
--- /dev/null
+++ b/Implab/ITaskController.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Implab {
+    public interface ITaskController: IProgressHandler {
+        bool Cancelled {
+            get;
+        }
+    }
+}
diff --git a/Implab/Implab.csproj b/Implab/Implab.csproj
--- a/Implab/Implab.csproj
+++ b/Implab/Implab.csproj
@@ -32,13 +32,25 @@
     <Reference Include="System" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ICancellable.cs" />
+    <Compile Include="IProgressHandler.cs" />
+    <Compile Include="IProgressNotifier.cs" />
+    <Compile Include="IPromise.cs" />
+    <Compile Include="ITaskController.cs" />
+    <Compile Include="ManagedPromise.cs" />
+    <Compile Include="Parallels\DispatchPool.cs" />
+    <Compile Include="Parallels\ArrayTraits.cs" />
+    <Compile Include="Parallels\MTQueue.cs" />
+    <Compile Include="Parallels\WorkerPool.cs" />
+    <Compile Include="PromiseState.cs" />
+    <Compile Include="TaskController.cs" />
+    <Compile Include="ProgressInitEventArgs.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Promise.cs" />
-    <Compile Include="AsyncPool.cs" />
+    <Compile Include="Parallels\AsyncPool.cs" />
     <Compile Include="Safe.cs" />
+    <Compile Include="ValueEventArgs.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
-  <ItemGroup>
-    <Folder Include="Parallels\" />
-  </ItemGroup>
+  <ItemGroup />
 </Project>
\ No newline at end of file
diff --git a/Implab/ManagedPromise.cs b/Implab/ManagedPromise.cs
new file mode 100644
--- /dev/null
+++ b/Implab/ManagedPromise.cs
@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Implab {
+
+    /*public class ManagedPromise<T>: Promise<T>, ITaskController, IProgressNotifier {
+        
+    }*/
+}
diff --git a/Implab/Parallels/ArrayTraits.cs b/Implab/Parallels/ArrayTraits.cs
new file mode 100644
--- /dev/null
+++ b/Implab/Parallels/ArrayTraits.cs
@@ -0,0 +1,171 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading;
+
+namespace Implab.Parallels {
+    public static class ArrayTraits {
+        class ArrayIterator<TSrc> : DispatchPool<int> {
+            readonly Action<TSrc> m_action;
+            readonly TSrc[] m_source;
+            readonly Promise<int> m_promise = new Promise<int>();
+
+            int m_pending;
+            int m_next;
+
+            public ArrayIterator(TSrc[] source, Action<TSrc> action, int threads)
+                : base(threads) {
+
+                Debug.Assert(source != null);
+                Debug.Assert(action != null);
+
+                m_next = 0;
+                m_source = source;
+                m_pending = source.Length;
+                m_action = action;
+
+                m_promise.Anyway(() => Dispose());
+                m_promise.Cancelled(() => Dispose());
+
+                InitPool();
+            }
+
+            public Promise<int> Promise {
+                get {
+                    return m_promise;
+                }
+            }
+
+            protected override bool TryDequeue(out int unit) {
+                unit = Interlocked.Increment(ref m_next) - 1;
+                return unit >= m_source.Length ? false : true;
+            }
+
+            protected override void InvokeUnit(int unit) {
+                try {
+                    m_action(m_source[unit]);
+                    var pending = Interlocked.Decrement(ref m_pending);
+                    if (pending == 0)
+                        m_promise.Resolve(m_source.Length);
+                } catch (Exception e) {
+                    m_promise.Reject(e);
+                }
+            }
+        }
+
+        class ArrayMapper<TSrc, TDst>: DispatchPool<int> {
+            readonly Func<TSrc, TDst> m_transform;
+            readonly TSrc[] m_source;
+            readonly TDst[] m_dest;
+            readonly Promise<TDst[]> m_promise = new Promise<TDst[]>();
+
+            int m_pending;
+            int m_next;
+
+            public ArrayMapper(TSrc[] source, Func<TSrc, TDst> transform, int threads)
+                : base(threads) {
+
+                Debug.Assert (source != null);
+                Debug.Assert( transform != null);
+
+                m_next = 0;
+                m_source = source;
+                m_dest = new TDst[source.Length];
+                m_pending = source.Length;
+                m_transform = transform;
+
+                m_promise.Anyway(() => Dispose());
+                m_promise.Cancelled(() => Dispose());
+
+                InitPool();
+            }
+
+            public Promise<TDst[]> Promise {
+                get {
+                    return m_promise;
+                }
+            }
+
+            protected override bool TryDequeue(out int unit) {
+                unit = Interlocked.Increment(ref m_next) - 1;
+                return unit >= m_source.Length ? false : true;
+            }
+
+            protected override void InvokeUnit(int unit) {
+                try {
+                    m_dest[unit] = m_transform(m_source[unit]);
+                    var pending = Interlocked.Decrement(ref m_pending);
+                    if (pending == 0)
+                        m_promise.Resolve(m_dest);
+                } catch (Exception e) {
+                    m_promise.Reject(e);
+                }
+            }
+        }
+
+        public static Promise<TDst[]> ParallelMap<TSrc, TDst> (this TSrc[] source, Func<TSrc,TDst> transform, int threads) {
+            if (source == null)
+                throw new ArgumentNullException("source");
+            if (transform == null)
+                throw new ArgumentNullException("transform");
+
+            var mapper = new ArrayMapper<TSrc, TDst>(source, transform, threads);
+            return mapper.Promise;
+        }
+
+        public static Promise<int> ParallelForEach<TSrc>(this TSrc[] source, Action<TSrc> action, int threads) {
+            if (source == null)
+                throw new ArgumentNullException("source");
+            if (action == null)
+                throw new ArgumentNullException("action");
+
+            var iter = new ArrayIterator<TSrc>(source, action, threads);
+            return iter.Promise;
+        }
+
+        public static Promise<TDst[]> ChainedMap<TSrc, TDst>(this TSrc[] source, ChainedOperation<TSrc, TDst> transform, int threads) {
+            if (source == null)
+                throw new ArgumentNullException("source");
+            if (transform == null)
+                throw new ArgumentNullException("transform");
+            if (threads <= 0)
+                throw new ArgumentOutOfRangeException("Threads number must be greater then zero");
+
+            var promise = new Promise<TDst[]>();
+            var res = new TDst[source.Length];
+            var pending = source.Length;
+            var semaphore = new Semaphore(threads, threads);
+
+            AsyncPool.InvokeNewThread(() => {
+                for (int i = 0; i < source.Length; i++) {
+                    if(promise.State != PromiseState.Unresolved)
+                        break; // stop processing in case of error or cancellation
+                    var idx = i;
+                    semaphore.WaitOne();
+                    try {
+                        var p1 = transform(source[i]);
+                        p1.Anyway(() => semaphore.Release());
+                        p1.Cancelled(() => semaphore.Release());
+                        p1.Then(
+                            x => {
+                                res[idx] = x;
+                                var left = Interlocked.Decrement(ref pending);
+                                if (left == 0)
+                                    promise.Resolve(res);
+                            },
+                            e => promise.Reject(e)
+                        );
+
+                    } catch (Exception e) {
+                        promise.Reject(e);
+                    }
+                }
+                return 0;
+            });
+
+            return promise.Anyway(() => semaphore.Dispose());
+        }
+    }
+}
diff --git a/Implab/Parallels/AsyncPool.cs b/Implab/Parallels/AsyncPool.cs
new file mode 100644
--- /dev/null
+++ b/Implab/Parallels/AsyncPool.cs
@@ -0,0 +1,44 @@
+using System;
+using System.Threading;
+
+namespace Implab.Parallels {
+	/// <summary>
+	/// Класс для распаралеливания задач.
+	/// </summary>
+	/// <remarks>
+	/// Используя данный класс и лямда выражения можно распараллелить
+	/// вычисления, для этого используется концепция обещаний.
+	/// </remarks>
+	public static class AsyncPool {
+
+		public static Promise<T> Invoke<T>(Func<T> func) {
+			var p = new Promise<T>();
+
+			ThreadPool.QueueUserWorkItem(param => {
+				try {
+					p.Resolve(func());
+				} catch(Exception e) {
+					p.Reject(e);
+				}
+			});
+
+			return p;
+		}
+
+        public static Promise<T> InvokeNewThread<T>(Func<T> func) {
+            var p = new Promise<T>();
+
+            var worker = new Thread(() => {
+                try {
+                    p.Resolve(func());
+                } catch (Exception e) {
+                    p.Reject(e);
+                }
+            });
+            worker.IsBackground = true;
+            worker.Start();
+
+            return p;
+        }
+	}
+}
diff --git a/Implab/Parallels/DispatchPool.cs b/Implab/Parallels/DispatchPool.cs
new file mode 100644
--- /dev/null
+++ b/Implab/Parallels/DispatchPool.cs
@@ -0,0 +1,238 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Diagnostics;
+
+namespace Implab.Parallels {
+    public abstract class DispatchPool<TUnit> : IDisposable {
+        readonly int m_minThreads;
+        readonly int m_maxThreads;
+        int m_runningThreads = 0;
+        int m_maxRunningThreads = 0;
+        int m_suspended = 0;
+        int m_exitRequired = 0;
+        AutoResetEvent m_hasTasks = new AutoResetEvent(false);
+
+        protected DispatchPool(int min, int max) {
+            if (min < 0)
+                throw new ArgumentOutOfRangeException("min");
+            if (max <= 0)
+                throw new ArgumentOutOfRangeException("max");
+
+            if (min > max)
+                min = max;
+            m_minThreads = min;
+            m_maxThreads = max;
+        }
+
+        protected DispatchPool(int threads)
+            : this(threads, threads) {
+        }
+
+        protected DispatchPool() {
+            int maxThreads, maxCP;
+            ThreadPool.GetMaxThreads(out maxThreads, out maxCP);
+
+            m_minThreads = 0;
+            m_maxThreads = maxThreads;
+        }
+
+        protected void InitPool() {
+            for (int i = 0; i < m_minThreads; i++)
+                StartWorker();
+        }
+
+        public int ThreadCount {
+            get {
+                return m_runningThreads;
+            }
+        }
+
+        public int MaxRunningThreads {
+            get {
+                return m_maxRunningThreads;
+            }
+        }
+
+        protected bool IsDisposed {
+            get {
+                return m_exitRequired != 0;
+            }
+        }
+
+        protected abstract bool TryDequeue(out TUnit unit);
+
+        protected virtual bool ExtendPool() {
+            if (m_suspended > 0) {
+                m_hasTasks.Set();
+                return true;
+            } else
+                return StartWorker();
+        }
+
+        /// <summary>
+        /// Запускает либо новый поток, если раньше не было ни одного потока, либо устанавливает событие пробуждение одного спящего потока
+        /// </summary>
+        protected void WakePool() {
+            m_hasTasks.Set(); // wake sleeping thread;
+
+            if (AllocateThreadSlot(1)) {
+                var worker = new Thread(this.Worker);
+                worker.IsBackground = true;
+                worker.Start();
+            }
+        }
+
+        protected virtual void Suspend() {
+            m_hasTasks.WaitOne();
+        }
+
+        #region thread slots traits
+
+        bool AllocateThreadSlot() {
+            int current;
+            // use spins to allocate slot for the new thread
+            do {
+                current = m_runningThreads;
+                if (current >= m_maxThreads || m_exitRequired != 0)
+                    // no more slots left or the pool has been disposed
+                    return false;
+            } while (current != Interlocked.CompareExchange(ref m_runningThreads, current + 1, current));
+
+            UpdateMaxThreads(current + 1);
+
+            return true;
+        }
+
+        bool AllocateThreadSlot(int desired) {
+            if (desired - 1 != Interlocked.CompareExchange(ref m_runningThreads, desired, desired - 1))
+                return false;
+
+            UpdateMaxThreads(desired);
+
+            return true;
+        }
+
+        bool ReleaseThreadSlot(out bool last) {
+            last = false;
+            int current;
+            // use spins to release slot for the new thread
+            do {
+                current = m_runningThreads;
+                if (current <= m_minThreads && m_exitRequired == 0)
+                    // the thread is reserved
+                    return false;
+            } while (current != Interlocked.CompareExchange(ref m_runningThreads, current - 1, current));
+
+            last = (current == 1);
+
+            return true;
+        }
+
+        /// <summary>
+        /// releases thread slot unconditionally, used during cleanup
+        /// </summary>
+        /// <returns>true - no more threads left</returns>
+        bool ReleaseThreadSlotAnyway() {
+            var left = Interlocked.Decrement(ref m_runningThreads);
+            return left == 0;
+        }
+
+        void UpdateMaxThreads(int count) {
+            int max;
+            do {
+                max = m_maxRunningThreads;
+                if (max >= count)
+                    break;
+            } while(max != Interlocked.CompareExchange(ref m_maxRunningThreads, count, max));
+        }
+
+        #endregion
+
+        bool StartWorker() {
+            if (AllocateThreadSlot()) {
+                // slot successfully allocated
+                var worker = new Thread(this.Worker);
+                worker.IsBackground = true;
+                worker.Start();
+
+                return true;
+            } else {
+                return false;
+            }
+        }
+
+        bool FetchTask(out TUnit unit) {
+            do {
+                // exit if requested
+                if (m_exitRequired != 0) {
+                    // release the thread slot
+                    if (ReleaseThreadSlotAnyway()) // it was the last worker
+                        m_hasTasks.Dispose();
+                    else
+                        m_hasTasks.Set(); // wake next worker
+                    unit = default(TUnit);
+                    return false;
+                }
+
+                // fetch task
+                if (TryDequeue(out unit)) {
+                    ExtendPool();
+                    return true;
+                }
+
+                //no tasks left, exit if the thread is no longer needed
+                bool last;
+                if (ReleaseThreadSlot(out last)) {
+                    if (last && m_hasTasks.WaitOne(0)) {
+                        if (AllocateThreadSlot(1))
+                            continue; // spin again...
+                        else
+                            // we failed to reallocate slot for this thread
+                            // therefore we need to release the event
+                            m_hasTasks.Set(); 
+                    }
+
+                    return false;
+                }
+
+                // entering suspend state
+                Interlocked.Increment(ref m_suspended);
+                // keep this thread and wait                
+                Suspend();
+                Interlocked.Decrement(ref m_suspended);
+            } while (true);
+        }
+
+        protected abstract void InvokeUnit(TUnit unit);
+
+        void Worker() {
+            TUnit unit;
+            while (FetchTask(out unit))
+                InvokeUnit(unit);
+        }
+
+        protected virtual void Dispose(bool disposing) {
+            if (disposing) {
+                if (m_exitRequired == 0) {
+                    if (Interlocked.CompareExchange(ref m_exitRequired, 1, 0) != 0)
+                        return;
+
+                    // wake sleeping threads
+                    m_hasTasks.Set();
+                    GC.SuppressFinalize(this);
+                }
+            }
+        }
+
+        public void Dispose() {
+            Dispose(true);
+        }
+
+        ~DispatchPool() {
+            Dispose(false);
+        }
+    }
+}
diff --git a/Implab/Parallels/MTQueue.cs b/Implab/Parallels/MTQueue.cs
new file mode 100644
--- /dev/null
+++ b/Implab/Parallels/MTQueue.cs
@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+
+namespace Implab.Parallels {
+    public class MTQueue<T> {
+        class Node {
+            public Node(T value) {
+                this.value = value;
+            }
+            public readonly T value;
+            public Node next;
+        }
+
+        Node m_first;
+        Node m_last;
+
+        public void Enqueue(T value) {
+            var last = m_last;
+            var next = new Node(value);
+
+            while (last != Interlocked.CompareExchange(ref m_last, next, last))
+                last = m_last;
+
+            if (last != null)
+                last.next = next;
+            else
+                m_first = next;
+        }
+
+        public bool TryDequeue(out T value) {
+            Node first;
+            Node next = null;
+            value = default(T);
+
+            do {
+                first = m_first;
+                if (first == null)
+                    return false;
+                next = first.next;
+                if (next == null) {
+                    // this is the last element,
+                    // then try to update tail
+                    if (first != Interlocked.CompareExchange(ref m_last, null, first)) {
+                        // this is inconsistent situation which means that the queue is empty
+                        if (m_last == null)
+                            return false;
+                        // tail has been changed, that means that we need to restart
+                        continue; 
+                    }
+
+                    // tail succesfully updated and first.next will never be changed
+                    // other readers will fail due to inconsistency m_last != m_fist, but m_first.next == null
+                    // but the writer may update the m_first since the m_last is null
+
+                    // so we need to fix inconsistency by setting m_first to null, but if it already has been
+                    // updated by a writer then we should just give up
+                    Interlocked.CompareExchange(ref m_first, null, first);
+                    break;
+
+                } else {
+                        if (first == Interlocked.CompareExchange(ref m_first, next, first))
+                            // head succesfully updated
+                            break;
+                }
+            } while (true);
+
+            value = first.value;
+            return true;
+        }
+    }
+}
diff --git a/Implab/Parallels/WorkerPool.cs b/Implab/Parallels/WorkerPool.cs
new file mode 100644
--- /dev/null
+++ b/Implab/Parallels/WorkerPool.cs
@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Diagnostics;
+
+namespace Implab.Parallels {
+    public class WorkerPool : DispatchPool<Action> {
+
+        MTQueue<Action> m_queue = new MTQueue<Action>();
+        int m_queueLength = 0;
+        readonly int m_threshold = 1;
+
+        public WorkerPool(int minThreads, int maxThreads, int threshold)
+            : base(minThreads, maxThreads) {
+            m_threshold = threshold;
+            InitPool();
+        }
+
+        public WorkerPool(int minThreads, int maxThreads) :
+            base(minThreads, maxThreads) {
+            InitPool();
+        }
+
+        public WorkerPool(int threads)
+            : base(threads) {
+            InitPool();
+        }
+
+        public WorkerPool()
+            : base() {
+            InitPool();
+        }
+
+        public Promise<T> Invoke<T>(Func<T> task) {
+            if (task == null)
+                throw new ArgumentNullException("task");
+            if (IsDisposed)
+                throw new ObjectDisposedException(ToString());
+
+            var promise = new Promise<T>();
+
+            EnqueueTask(delegate() {
+                try {
+                    promise.Resolve(task());
+                } catch (Exception e) {
+                    promise.Reject(e);
+                }
+            });
+
+            return promise;
+        }
+
+        protected void EnqueueTask(Action unit) {
+            Debug.Assert(unit != null);
+            var len = Interlocked.Increment(ref m_queueLength);
+            m_queue.Enqueue(unit);
+
+            if(!ExtendPool())
+                WakePool();
+        }
+
+        protected override bool ExtendPool() {
+            if (m_queueLength <= m_threshold*ThreadCount)
+                // in this case we are in active thread and it request for additional workers
+                // satisfy it only when queue is longer than threshold
+                return false;
+            return base.ExtendPool();
+        }
+
+        protected override bool TryDequeue(out Action unit) {
+            if (m_queue.TryDequeue(out unit)) {
+                Interlocked.Decrement(ref m_queueLength);
+                return true;
+            }
+            return false;
+        }
+
+        protected override void InvokeUnit(Action unit) {
+            unit();
+        }
+
+        protected override void Suspend() {
+            if (m_queueLength == 0)
+                base.Suspend();
+        }
+    }
+}
diff --git a/Implab/ProgressInitEventArgs.cs b/Implab/ProgressInitEventArgs.cs
new file mode 100644
--- /dev/null
+++ b/Implab/ProgressInitEventArgs.cs
@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Implab
+{
+    [Serializable]
+    public class ProgressInitEventArgs: EventArgs
+    {
+        public float MaxProgress
+        {
+            get;
+            private set;
+        }
+
+        public float CurrentProgress
+        {
+            get;
+            private set;
+        }
+
+        public string Message
+        {
+            get;
+            private set;
+        }
+
+        public ProgressInitEventArgs(float current, float max, string message)
+        {
+            this.MaxProgress = max;
+            this.CurrentProgress = current;
+            this.Message = message;
+        }
+    }
+}
diff --git a/Implab/Promise.cs b/Implab/Promise.cs
--- a/Implab/Promise.cs
+++ b/Implab/Promise.cs
@@ -1,18 +1,16 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Reflection;
-using System.Text;
 using System.Diagnostics;
 using System.Threading;
 
 namespace Implab {
 
     public delegate void ErrorHandler(Exception e);
-
-    public delegate void ResultHandler<T>(T result);
-    public delegate TNew ResultMapper<TSrc, TNew>(TSrc result);
-    public delegate Promise<TNew> ChainedOperation<TSrc, TNew>(TSrc result);
+    public delegate T ErrorHandler<out T>(Exception e);
+    public delegate void ResultHandler<in T>(T result);
+    public delegate TNew ResultMapper<in TSrc, out TNew>(TSrc result);
+    public delegate Promise<TNew> ChainedOperation<in TSrc, TNew>(TSrc result);
 
     /// <summary>
     /// Класс для асинхронного получения результатов. Так называемое "обещание".
@@ -48,23 +46,23 @@ namespace Implab {
     /// только инициатор обещания иначе могут возникнуть противоречия.
     /// </para>
     /// </remarks>
-    public class Promise<T> {
+    public class Promise<T> : IPromise {
 
         struct ResultHandlerInfo {
             public ResultHandler<T> resultHandler;
             public ErrorHandler errorHandler;
         }
 
-        enum State {
-            Unresolved,
-            Resolving,
-            Resolved,
-            Cancelled
-        }
+        readonly IPromise m_parent;
+
+        LinkedList<ResultHandlerInfo> m_resultHandlers = new LinkedList<ResultHandlerInfo>();
+        LinkedList<Action> m_cancelHandlers = new LinkedList<Action>();
 
-        LinkedList<ResultHandlerInfo> m_handlersChain = new LinkedList<ResultHandlerInfo>();
-        State m_state;
-        bool m_cancellable;
+        readonly object m_lock = new Object();
+        readonly bool m_cancellable;
+        int m_childrenCount = 0;
+
+        PromiseState m_state;
         T m_result;
         Exception m_error;
 
@@ -72,13 +70,17 @@ namespace Implab {
             m_cancellable = true;
         }
 
-        /// <summary>
-        /// Событие, возникающее при отмене асинхронной операции.
-        /// </summary>
-        /// <description>
-        /// Как правило используется для оповещения объекта, выполняющего асинхронную операцию, о том, что ее следует отменить.
-        /// </description>
-        public event EventHandler Cancelled;
+        public Promise(IPromise parent, bool cancellable) {
+            m_cancellable = cancellable;
+            m_parent = parent;
+            if (parent != null)
+                parent.HandleCancelled(InternalCancel);
+        }
+
+        void InternalCancel() {
+            // don't try to cancel parent :)
+            Cancel(false);
+        }
 
         /// <summary>
         /// Выполняет обещание, сообщая об успешном выполнении.
@@ -86,38 +88,39 @@ namespace Implab {
         /// <param name="result">Результат выполнения.</param>
         /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
         public void Resolve(T result) {
-            lock (this) {
-                if (m_state == State.Cancelled)
+            lock (m_lock) {
+                if (m_state == PromiseState.Cancelled)
                     return;
-                if (m_state != State.Unresolved)
+                if (m_state != PromiseState.Unresolved)
                     throw new InvalidOperationException("The promise is already resolved");
                 m_result = result;
-                m_state = State.Resolving;
+                m_state = PromiseState.Resolved;
             }
 
-            ResultHandlerInfo handler;
-            while (FetchNextHandler(out handler))
-                InvokeHandler(handler);
+            OnStateChanged();
         }
 
         /// <summary>
         /// Выполняет обещание, сообщая об ошибке
         /// </summary>
+        /// <remarks>
+        /// Поскольку обещание должно работать в многопточной среде, при его выполнении сразу несколько потоков
+        /// могу вернуть ошибку, при этом только первая будет использована в качестве результата, остальные
+        /// будут проигнорированы.
+        /// </remarks>
         /// <param name="error">Исключение возникшее при выполнении операции</param>
         /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
         public void Reject(Exception error) {
-            lock (this) {
-                if (m_state == State.Cancelled)
+            lock (m_lock) {
+                if (m_state == PromiseState.Cancelled || m_state == PromiseState.Rejected)
                     return;
-                if (m_state != State.Unresolved)
+                if (m_state != PromiseState.Unresolved)
                     throw new InvalidOperationException("The promise is already resolved");
                 m_error = error;
-                m_state = State.Resolving;
+                m_state = PromiseState.Rejected;
             }
 
-            ResultHandlerInfo handler;
-            while (FetchNextHandler(out handler))
-                InvokeHandler(handler);
+            OnStateChanged();
         }
 
         /// <summary>
@@ -125,47 +128,31 @@ namespace Implab {
         /// </summary>
         /// <returns><c>true</c> Операция была отменена, обработчики не будут вызваны.<c>false</c> отмена не возможна, поскольку обещание уже выполнено и обработчики отработали.</returns>
         public bool Cancel() {
-            lock (this) {
-                if (m_state == State.Unresolved && m_cancellable) {
-                    m_state = State.Cancelled;
-                    EventHandler temp = Cancelled;
-
-                    if (temp != null)
-                        temp(this, new EventArgs());
-
-                    return true;
-                } else
-                    return false;
-            }
+            return Cancel(true);
         }
 
         /// <summary>
-        /// Добавляет обработчики событий выполнения обещания.
+        /// Adds new handlers to this promise.
         /// </summary>
-        /// <param name="success">Обработчик успешного выполнения обещания.
-        /// Данному обработчику будет передан результат выполнения операции.</param>
-        /// <param name="error">Обработчик ошибки. Данный обработчик получит
-        /// исключение возникшее при выполнении операции.</param>
-        /// <returns>Само обещание</returns>
+        /// <param name="success">The handler of the successfully completed operation.
+        /// This handler will recieve an operation result as a parameter.</param>
+        /// <param name="error">Handles an exception that may occur during the operation.</param>
+        /// <returns>The new promise chained to this one.</returns>
         public Promise<T> Then(ResultHandler<T> success, ErrorHandler error) {
             if (success == null && error == null)
                 return this;
 
-            var medium = new Promise<T>();
+            var medium = new Promise<T>(this, true);
 
             var handlerInfo = new ResultHandlerInfo();
 
             if (success != null)
                 handlerInfo.resultHandler = x => {
-                    try {
-                        success(x);
-                        medium.Resolve(x);
-                    } catch (Exception e) {
-                        medium.Reject(e);
-                    }
+                    success(x);
+                    medium.Resolve(x);
                 };
             else
-                handlerInfo.resultHandler = x => medium.Resolve(x);
+                handlerInfo.resultHandler = medium.Resolve;
 
             if (error != null)
                 handlerInfo.errorHandler = x => {
@@ -175,21 +162,106 @@ namespace Implab {
                     medium.Reject(x);
                 };
             else
-                handlerInfo.errorHandler = x => medium.Reject(x);
+                handlerInfo.errorHandler = medium.Reject;
+
+            AddHandler(handlerInfo);
+
+            return medium;
+        }
+
+        /// <summary>
+        /// Adds new handlers to this promise.
+        /// </summary>
+        /// <param name="success">The handler of the successfully completed operation.
+        /// This handler will recieve an operation result as a parameter.</param>
+        /// <param name="error">Handles an exception that may occur during the operation and returns the value which will be used as the result of the operation.</param>
+        /// <returns>The new promise chained to this one.</returns>
+        public Promise<T> Then(ResultHandler<T> success, ErrorHandler<T> error) {
+            if (success == null && error == null)
+                return this;
+
+            var medium = new Promise<T>(this, true);
+
+            var handlerInfo = new ResultHandlerInfo();
+
+            if (success != null)
+                handlerInfo.resultHandler = x => {
+                    success(x);
+                    medium.Resolve(x);
+                };
+            else
+                handlerInfo.resultHandler = medium.Resolve;
+
+            if (error != null)
+                handlerInfo.errorHandler = x => {
+                    try {
+                        medium.Resolve(error(x));
+                    } catch { }
+                    medium.Reject(x);
+                };
+            else
+                handlerInfo.errorHandler = medium.Reject;
 
             AddHandler(handlerInfo);
 
             return medium;
         }
 
+
         public Promise<T> Then(ResultHandler<T> success) {
-            return Then(success, null);
+            if (success == null)
+                return this;
+
+            var medium = new Promise<T>(this, true);
+
+            var handlerInfo = new ResultHandlerInfo();
+
+            if (success != null)
+                handlerInfo.resultHandler = x => {
+                    success(x);
+                    medium.Resolve(x);
+                };
+            else
+                handlerInfo.resultHandler = medium.Resolve;
+
+            handlerInfo.errorHandler = medium.Reject;
+
+            AddHandler(handlerInfo);
+
+            return medium;
         }
 
         public Promise<T> Error(ErrorHandler error) {
             return Then(null, error);
         }
 
+        /// <summary>
+        /// Handles error and allows to keep the promise.
+        /// </summary>
+        /// <remarks>
+        /// If the specified handler throws an exception, this exception will be used to reject the promise.
+        /// </remarks>
+        /// <param name="handler">The error handler which returns the result of the promise.</param>
+        /// <returns>New promise.</returns>
+        public Promise<T> Error(ErrorHandler<T> handler) {
+            if (handler == null)
+                return this;
+
+            var medium = new Promise<T>(this, true);
+
+            AddHandler(new ResultHandlerInfo {
+                errorHandler = e => {
+                    try {
+                        medium.Resolve(handler(e));
+                    } catch (Exception e2) {
+                        medium.Reject(e2);
+                    }
+                }
+            });
+
+            return medium;
+        }
+
         public Promise<T> Anyway(Action handler) {
             if (handler == null)
                 return this;
@@ -198,6 +270,7 @@ namespace Implab {
 
             AddHandler(new ResultHandlerInfo {
                 resultHandler = x => {
+                    // to avoid handler being called multiple times we handle exception by ourselfs
                     try {
                         handler();
                         medium.Resolve(x);
@@ -229,20 +302,15 @@ namespace Implab {
                 throw new ArgumentNullException("mapper");
 
             // создаем прицепленное обещание
-            Promise<TNew> chained = new Promise<TNew>();
+            var chained = new Promise<TNew>();
 
             AddHandler(new ResultHandlerInfo() {
-                resultHandler = delegate(T result) {
-                    try {
-                        // если преобразование выдаст исключение, то сработает reject сцепленного deferred
-                        chained.Resolve(mapper(result));
-                    } catch (Exception e) {
-                        chained.Reject(e);
-                    }
-                },
+                resultHandler = result => chained.Resolve(mapper(result)),
                 errorHandler = delegate(Exception e) {
                     if (error != null)
-                        error(e);
+                        try {
+                            error(e);
+                        } catch { }
                     // в случае ошибки нужно передать исключение дальше по цепочке
                     chained.Reject(e);
                 }
@@ -271,19 +339,21 @@ namespace Implab {
             // создать посредника, к которому будут подвызяваться следующие обработчики.
             // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы
             // передать через него результаты работы.
-            Promise<TNew> medium = new Promise<TNew>();
+            var medium = new Promise<TNew>(this, true);
 
-            AddHandler(new ResultHandlerInfo() {
+            AddHandler(new ResultHandlerInfo {
                 resultHandler = delegate(T result) {
-                    try {
-                        chained(result).Then(
-                            x => medium.Resolve(x),
-                            e => medium.Reject(e)
-                            );
-                    } catch (Exception e) {
-                        // если сцепленное действие выдало исключение вместо обещания, то передаем ошибку по цепочке
-                        medium.Reject(e);
-                    }
+                    if (medium.State == PromiseState.Cancelled)
+                        return;
+
+                    var promise = chained(result);
+
+                    // notify chained operation that it's not needed
+                    medium.Cancelled(() => promise.Cancel());
+                    promise.Then(
+                        x => medium.Resolve(x),
+                        e => medium.Reject(e)
+                    );
                 },
                 errorHandler = delegate(Exception e) {
                     if (error != null)
@@ -300,6 +370,22 @@ namespace Implab {
             return Chain(chained, null);
         }
 
+        public Promise<T> Cancelled(Action handler) {
+            if (handler == null)
+                return this;
+            lock (m_lock) {
+                if (m_state == PromiseState.Unresolved)
+                    m_cancelHandlers.AddLast(handler);
+                else if (m_state == PromiseState.Cancelled)
+                    handler();
+            }
+            return this;
+        }
+
+        public void HandleCancelled(Action handler) {
+            Cancelled(handler);
+        }
+
         /// <summary>
         /// Дожидается отложенного обещания и в случае успеха, возвращает
         /// его, результат, в противном случае бросает исключение.
@@ -322,52 +408,37 @@ namespace Implab {
         /// <param name="timeout">Время ожидания</param>
         /// <returns>Результат выполнения обещания</returns>
         public T Join(int timeout) {
-            ManualResetEvent evt = new ManualResetEvent(false);
+            var evt = new ManualResetEvent(false);
             Anyway(() => evt.Set());
+            Cancelled(() => evt.Set());
 
             if (!evt.WaitOne(timeout, true))
                 throw new TimeoutException();
 
-            if (m_error != null)
-                throw new TargetInvocationException(m_error);
-            else
-                return m_result;
+            switch (State) {
+                case PromiseState.Resolved:
+                    return m_result;
+                case PromiseState.Cancelled:
+                    throw new OperationCanceledException();
+                case PromiseState.Rejected:
+                    throw new TargetInvocationException(m_error);
+                default:
+                    throw new ApplicationException(String.Format("Invalid promise state {0}", State));
+            }
         }
 
         public T Join() {
             return Join(Timeout.Infinite);
         }
 
-        /// <summary>
-        /// Данный метод последовательно извлекает обработчики обещания и когда
-        /// их больше не осталось - ставит состояние "разрешено".
-        /// </summary>
-        /// <param name="handler">Информация об обработчике</param>
-        /// <returns>Признак того, что еще остались обработчики в очереди</returns>
-        bool FetchNextHandler(out ResultHandlerInfo handler) {
-            handler = default(ResultHandlerInfo);
-
-            lock (this) {
-                Debug.Assert(m_state == State.Resolving);
-
-                if (m_handlersChain.Count > 0) {
-                    handler = m_handlersChain.First.Value;
-                    m_handlersChain.RemoveFirst();
-                    return true;
-                } else {
-                    m_state = State.Resolved;
-                    return false;
-                }
-            }
-        }
-
         void AddHandler(ResultHandlerInfo handler) {
             bool invokeRequired = false;
 
-            lock (this) {
-                if (m_state != State.Resolved)
-                    m_handlersChain.AddLast(handler);
-                else
+            lock (m_lock) {
+                m_childrenCount++;
+                if (m_state == PromiseState.Unresolved) {
+                    m_resultHandlers.AddLast(handler);
+                } else
                     invokeRequired = true;
             }
 
@@ -377,21 +448,102 @@ namespace Implab {
         }
 
         void InvokeHandler(ResultHandlerInfo handler) {
-            if (m_error == null) {
-                try {
-                    if (handler.resultHandler != null)
-                        handler.resultHandler(m_result);
-                } catch { }
-            }
-
-            if (m_error != null) {
-                try {
-                    if (handler.errorHandler != null)
-                        handler.errorHandler(m_error);
-                } catch { }
+            switch (m_state) {
+                case PromiseState.Resolved:
+                    try {
+                        if (handler.resultHandler != null)
+                            handler.resultHandler(m_result);
+                    } catch (Exception e) {
+                        try {
+                            if (handler.errorHandler != null)
+                                handler.errorHandler(e);
+                        } catch { }
+                    }
+                    break;
+                case PromiseState.Rejected:
+                    try {
+                        if (handler.errorHandler != null)
+                            handler.errorHandler(m_error);
+                    } catch { }
+                    break;
+                default:
+                    // do nothing
+                    return;
             }
         }
 
+        protected virtual void OnStateChanged() {
+            switch (m_state) {
+                case PromiseState.Resolved:
+                    foreach (var resultHandlerInfo in m_resultHandlers)
+                        try {
+                            if (resultHandlerInfo.resultHandler != null)
+                                resultHandlerInfo.resultHandler(m_result);
+                        } catch (Exception e) {
+                            try {
+                                if (resultHandlerInfo.errorHandler != null)
+                                    resultHandlerInfo.errorHandler(e);
+                            } catch { }
+                        }
+                    break;
+                case PromiseState.Cancelled:
+                    foreach (var cancelHandler in m_cancelHandlers)
+                        cancelHandler();
+                    break;
+                case PromiseState.Rejected:
+                    foreach (var resultHandlerInfo in m_resultHandlers)
+                        try {
+                            if (resultHandlerInfo.errorHandler != null)
+                                resultHandlerInfo.errorHandler(m_error);
+                        } catch { }
+                    break;
+                default:
+                    throw new InvalidOperationException(String.Format("Promise entered an invalid state {0}", m_state));
+            }
+
+            m_resultHandlers = null;
+            m_cancelHandlers = null;
+        }
+
+
+
+        public bool IsExclusive {
+            get {
+                lock (m_lock) {
+                    return m_childrenCount <= 1;
+                }
+            }
+        }
+
+        public PromiseState State {
+            get {
+                lock (m_lock) {
+                    return m_state;
+                }
+            }
+        }
+
+        protected bool Cancel(bool dependencies) {
+            bool result;
+
+            lock (m_lock) {
+                if (m_state == PromiseState.Unresolved) {
+                    m_state = PromiseState.Cancelled;
+                    result = true;
+                } else {
+                    result = false;
+                }
+            }
+
+            if (result)
+                OnStateChanged();
+
+            if (dependencies && m_parent != null && m_parent.IsExclusive) {
+                m_parent.Cancel();
+            }
+
+            return result;
+        }
 
     }
 }
diff --git a/Implab/PromiseState.cs b/Implab/PromiseState.cs
new file mode 100644
--- /dev/null
+++ b/Implab/PromiseState.cs
@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Implab
+{
+    public enum PromiseState
+    {
+        Unresolved,
+        Resolved,
+        Cancelled,
+        Rejected
+    }
+}
diff --git a/Implab/TaskController.cs b/Implab/TaskController.cs
new file mode 100644
--- /dev/null
+++ b/Implab/TaskController.cs
@@ -0,0 +1,132 @@
+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>
+    class TaskController: IProgressNotifier, ITaskController, ICancellable
+    {
+        readonly object m_lock;
+        string m_message;
+
+        float m_current;
+        float m_max;
+
+        bool m_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 Cancelled {
+            get {
+                lock (m_lock)
+                    return m_cancelled;
+            }
+        }
+
+        public bool Cancel() {
+            lock (m_lock) {
+                if (!m_cancelled) {
+                    m_cancelled = true;
+                    return true;
+                } else {
+                    return false;
+                }
+            }
+        }
+
+        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));
+            }
+        }
+    }
+}
diff --git a/Implab/ValueEventArgs.cs b/Implab/ValueEventArgs.cs
new file mode 100644
--- /dev/null
+++ b/Implab/ValueEventArgs.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Implab
+{
+    [Serializable]
+    public class ValueEventArgs<T>: EventArgs
+    {
+        public ValueEventArgs(T value)
+        {
+            this.Value = value;
+        }
+        public T Value
+        {
+            get;
+            private set;
+        }
+    }
+}