implab/ImplabNet Commit - r145:706fccb85524

RC: cancellation support for promises + tests

cin -

r145:706fccb85524 v2

parent child

Context file:

r145:706fccb85524

Expand all files

Implab.Test/CancelationTests.cs created 644 +144 0

@@ -0,0 +1,144
	1	using System;
	2	using Implab.Parallels;
	3
	4	#if MONO
	5
	6	using NUnit.Framework;
	7	using TestClassAttribute = NUnit.Framework.TestFixtureAttribute;
	8	using TestMethodAttribute = NUnit.Framework.TestAttribute;
	9
	10	#else
	11
	12	using Microsoft.VisualStudio.TestTools.UnitTesting;
	13
	14	#endif
	15
	16	namespace Implab.Test {
	17	[TestClass]
	18	public class CancelationTests {
	19
	20	[TestMethod]
	21	public void PromiseCancelTest() {
	22	var p = new Promise();
	23	bool requested = false;
	24	var reason = new Exception("Test");
	25
	26	// request cancelation
	27	p.Cancel(reason);
	28
	29	Assert.IsTrue(p.IsCancellationRequested);
	30	Assert.AreSame(reason, p.CancellationReason);
	31	Assert.IsFalse(p.IsCancelled);
	32
	33	p.CancellationRequested(r => {
	34	Assert.AreSame(reason, r);
	35	requested = true;
	36	});
	37
	38	Assert.IsTrue(requested);
	39
	40	// cancel the promise
	41	Assert.IsTrue(p.CancelOperationIfRequested());
	42	Assert.IsTrue(p.IsCancelled);
	43	Assert.AreSame(reason, p.Error);
	44	}
	45
	46	[TestMethod]
	47	public void CancelActionBeforeStartTask() {
	48	bool run = false;
	49	var task = new ActionTask(() => {
	50	run = true;
	51	}, null, null);
	52
	53	// request cancelation
	54	task.Cancel();
	55	Assert.IsTrue(task.IsCancelled);
	56	task.Resolve();
	57	Assert.IsFalse(run);
	58	}
	59
	60	[TestMethod]
	61	public void CancelActionAfterTaskStarted() {
	62	var finish = new Signal();
	63	var started = new Signal();
	64
	65	var task = new ActionTask(() => {
	66	started.Set();
	67	finish.Wait();
	68	}, null, null);
	69
	70	AsyncPool.RunThread(() => {
	71	task.Resolve();
	72	});
	73
	74	started.Wait(1000);
	75
	76	task.Cancel();
	77	Assert.IsTrue(task.IsCancellationRequested);
	78	Assert.IsFalse(task.IsCancelled);
	79	Assert.IsFalse(task.IsResolved);
	80
	81	finish.Set();
	82	task.Join(1000);
	83
	84	}
	85
	86	[TestMethod]
	87	public void CancelTaskChainFromBottom() {
	88	var check1 = new Signal();
	89	var requested = false;
	90	var p1 = AsyncPool.RunThread(token => {
	91	token.CancellationRequested(reason => requested = true);
	92	check1.Wait();
	93	token.CancelOperationIfRequested();
	94	});
	95
	96	var p2 = p1.Then(() => {
	97	});
	98
	99	Assert.IsFalse(p1.IsResolved);
	100	Assert.IsFalse(p2.IsResolved);
	101
	102	p2.Cancel();
	103
	104	Assert.IsFalse(p2.IsCancelled);
	105	Assert.IsFalse(p1.IsCancelled);
	106	Assert.IsTrue(requested);
	107
	108	check1.Set();
	109
	110	try {
	111	p2.Join(1000);
	112	Assert.Fail("The chain isn't cancelled");
	113	} catch(OperationCanceledException){
	114	}
	115
	116	Assert.IsTrue(p1.IsCancelled);
	117	Assert.IsTrue(p2.IsCancelled);
	118	}
	119
	120
	121
	122	[TestMethod]
	123	public void CancellableAsyncTask() {
	124	var finish = new Signal();
	125	var started = new Signal();
	126
	127	var p = AsyncPool.RunThread(token => {
	128	token.CancellationRequested(r => finish.Set());
	129	started.Set();
	130	finish.Wait();
	131	Assert.IsTrue(token.CancelOperationIfRequested());
	132	});
	133
	134	started.Wait(1000);
	135	Assert.IsFalse(p.IsResolved);
	136	p.Cancel();
	137	try {
	138	p.Join(1000);
	139	} catch (OperationCanceledException) {
	140	}
	141	}
	142	}
	143	}
	144

Implab/ActionChainTask.cs created 644 +23 0

@@ -0,0 +1,23
	1	using System;
	2
	3	namespace Implab {
	4	public class ActionChainTask : ActionChainTaskBase, IDeferred {
	5	readonly Func<IPromise> m_task;
	6
	7	public ActionChainTask(Func<IPromise> task, Func<Exception, IPromise> error, Func<Exception, IPromise> cancel) : base(error,cancel) {
	8	m_task = task;
	9	}
	10
	11	public void Resolve() {
	12	if (m_task != null && LockCancelation()) {
	13	try {
	14	Observe(m_task());
	15	} catch(Exception err) {
	16	HandleErrorInternal(err);
	17	}
	18	}
	19	}
	20
	21	}
	22	}
	23

Implab/ActionChainTaskBase.cs created 644 +62 0

@@ -0,0 +1,62
	1	using System;
	2	using System.Threading;
	3
	4	namespace Implab {
	5	public class ActionChainTaskBase : AbstractPromise {
	6	readonly Func<Exception, IPromise> m_error;
	7	readonly Func<Exception, IPromise> m_cancel;
	8
	9	int m_cancelationLock;
	10
	11	protected ActionChainTaskBase( Func<Exception, IPromise> error, Func<Exception, IPromise> cancel) {
	12	m_error = error;
	13	m_cancel = cancel;
	14	}
	15
	16	public void Reject(Exception error) {
	17	if (LockCancelation())
	18	HandleErrorInternal(error);
	19	}
	20
	21
	22
	23	public override void CancelOperation(Exception reason) {
	24	if (m_cancel != null && LockCancelation()) {
	25	try {
	26	Observe(m_cancel(reason));
	27	} catch(Exception err) {
	28	HandleErrorInternal(err);
	29	}
	30	}
	31
	32	}
	33
	34	protected void HandleErrorInternal(Exception error) {
	35	if (m_error != null) {
	36	try {
	37	Observe(m_error(error));
	38	} catch(Exception err) {
	39	SetError(err);
	40	}
	41	} else {
	42	SetError(error);
	43	}
	44	}
	45
	46	protected void Observe(IPromise operation) {
	47	if (operation == null)
	48	throw new NullReferenceException("The task returned null promise");
	49
	50	// pass operation results to the current promise
	51	operation.On(SetResult, SetError, SetCancelled);
	52
	53	// pass the cancelation request
	54	CancellationRequested(operation.Cancel);
	55	}
	56
	57	protected bool LockCancelation() {
	58	return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
	59	}
	60	}
	61	}
	62

Implab/ActionChainTaskT.cs created 644 +23 0

@@ -0,0 +1,23
	1	using System;
	2
	3	namespace Implab {
	4	public class ActionChainTask<T> : ActionChainTaskBase, IDeferred<T> {
	5	readonly Func<T, IPromise> m_task;
	6
	7	public ActionChainTask(Func<T, IPromise> task, Func<Exception, IPromise> error, Func<Exception, IPromise> cancel) : base(error,cancel) {
	8	m_task = task;
	9	}
	10
	11	public void Resolve(T value) {
	12	if (m_task != null && LockCancelation()) {
	13	try {
	14	Observe(m_task(value));
	15	} catch(Exception err) {
	16	HandleErrorInternal(err);
	17	}
	18	}
	19	}
	20
	21	}
	22	}
	23

Implab/ActionTask.cs created 644 +22 0

@@ -0,0 +1,22
	1	using System;
	2
	3	namespace Implab {
	4	public class ActionTask : ActionTaskBase, IDeferred {
	5	readonly Action m_task;
	6	public ActionTask(Action task, Action<Exception> error, Action<Exception> cancel) : base(error,cancel) {
	7	m_task = task;
	8	}
	9
	10	public void Resolve() {
	11	if (m_task != null && LockCancelation()) {
	12	try {
	13	m_task();
	14	SetResult();
	15	} catch(Exception err) {
	16	HandleErrorInternal(err);
	17	}
	18	}
	19	}
	20	}
	21	}
	22

Implab/ActionTaskBase.cs created 644 +55 0

@@ -0,0 +1,55
	1	using System;
	2	using System.Threading;
	3
	4	namespace Implab {
	5	public class ActionTaskBase : AbstractPromise {
	6	readonly Action<Exception> m_cancel;
	7	readonly Action<Exception> m_error;
	8
	9	int m_cancelationLock;
	10
	11	protected ActionTaskBase( Action<Exception> error, Action<Exception> cancel) {
	12	m_error = error;
	13	m_cancel = cancel;
	14	}
	15
	16	public void Reject(Exception error) {
	17	Safe.ArgumentNotNull(error, "error");
	18	if (LockCancelation())
	19	HandleErrorInternal(error);
	20	}
	21
	22	protected void HandleErrorInternal(Exception error) {
	23	if (m_error != null) {
	24	try {
	25	m_error(error);
	26	SetResult();
	27	} catch(Exception err) {
	28	SetError(err);
	29	}
	30	} else {
	31	SetError(error);
	32	}
	33	}
	34
	35	public override void CancelOperation(Exception reason) {
	36	if (LockCancelation()) {
	37	if (m_cancel != null) {
	38	try {
	39	m_cancel(reason);
	40	SetResult();
	41	} catch (Exception err) {
	42	HandleErrorInternal(err);
	43	}
	44	} else {
	45	SetCancelled(reason);
	46	}
	47	}
	48	}
	49
	50	protected bool LockCancelation() {
	51	return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
	52	}
	53	}
	54	}
	55

Implab/ActionTaskT.cs created 644 +22 0

@@ -0,0 +1,22
	1	using System;
	2
	3	namespace Implab {
	4	public class ActionTask<T> : ActionTaskBase, IDeferred<T> {
	5	readonly Action<T> m_task;
	6	public ActionTask(Action<T> task, Action<Exception> error, Action<Exception> cancel) : base(error,cancel) {
	7	m_task = task;
	8	}
	9
	10	public void Resolve(T value) {
	11	if (m_task != null && LockCancelation()) {
	12	try {
	13	m_task(value);
	14	SetResult();
	15	} catch(Exception err) {
	16	HandleErrorInternal(err);
	17	}
	18	}
	19	}
	20	}
	21	}
	22

Implab/FuncChainTask.cs created 644 +21 0

@@ -0,0 +1,21
	1	using System;
	2
	3	namespace Implab {
	4	public class FuncChainTask<TResult> : FuncChainTaskBase<TResult>, IDeferred {
	5	readonly Func<IPromise<TResult>> m_task;
	6
	7	public FuncChainTask(Func<IPromise<TResult>> task, Func<Exception, IPromise<TResult>> error, Func<Exception, IPromise<TResult>> cancel) : base(error, cancel){
	8	m_task = task;
	9	}
	10
	11	public void Resolve() {
	12	if (m_task != null && LockCancelation()) {
	13	try {
	14	Observe(m_task());
	15	} catch (Exception err) {
	16	HandleErrorInternal(err);
	17	}
	18	}
	19	}
	20	}
	21	} No newline at end of file

Implab/FuncChainTaskBase.cs created 644 +60 0

@@ -0,0 +1,60
	1	using System;
	2	using System.Threading;
	3
	4	namespace Implab {
	5	public class FuncChainTaskBase<TResult> : AbstractPromise<TResult> {
	6	readonly Func<Exception, IPromise<TResult>> m_error;
	7	readonly Func<Exception, IPromise<TResult>> m_cancel;
	8
	9	int m_cancelationLock;
	10
	11	protected FuncChainTaskBase( Func<Exception, IPromise<TResult>> error, Func<Exception, IPromise<TResult>> cancel) {
	12	m_error = error;
	13	m_cancel = cancel;
	14	}
	15
	16	public void Reject(Exception error) {
	17	if (LockCancelation())
	18	HandleErrorInternal(error);
	19	}
	20
	21	public override void CancelOperation(Exception reason) {
	22	if (m_cancel != null && LockCancelation()) {
	23	try {
	24	Observe(m_cancel(reason));
	25	} catch(Exception err) {
	26	HandleErrorInternal(err);
	27	}
	28	}
	29
	30	}
	31
	32	protected void HandleErrorInternal(Exception error) {
	33	if (m_error != null) {
	34	try {
	35	Observe(m_error(error));
	36	} catch(Exception err) {
	37	SetError(err);
	38	}
	39	} else {
	40	SetError(error);
	41	}
	42	}
	43
	44	protected void Observe(IPromise<TResult> operation) {
	45	if (operation == null)
	46	throw new NullReferenceException("The task returned null promise");
	47
	48	// pass operation results to the current promise
	49	operation.On(SetResult, SetError, SetCancelled);
	50
	51	// pass the cancelation request
	52	CancellationRequested(operation.Cancel);
	53	}
	54
	55	protected bool LockCancelation() {
	56	return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
	57	}
	58	}
	59	}
	60

Implab/FuncChainTaskT.cs created 644 +21 0

@@ -0,0 +1,21
	1	using System;
	2
	3	namespace Implab {
	4	public class FuncChainTask<TArg,TResult> : FuncChainTaskBase<TResult>, IDeferred<TArg> {
	5	readonly Func<TArg, IPromise<TResult>> m_task;
	6
	7	public FuncChainTask(Func<TArg, IPromise<TResult>> task, Func<Exception, IPromise<TResult>> error, Func<Exception, IPromise<TResult>> cancel) : base(error, cancel){
	8	m_task = task;
	9	}
	10
	11	public void Resolve(TArg value) {
	12	if (m_task != null && LockCancelation()) {
	13	try {
	14	Observe(m_task(value));
	15	} catch (Exception err) {
	16	HandleErrorInternal(err);
	17	}
	18	}
	19	}
	20	}
	21	} No newline at end of file

Implab/ICancellationToken.cs created 644 +36 0

@@ -0,0 +1,36
	1	using System;
	2
	3	namespace Implab {
	4	public interface ICancellationToken {
	5	/// <summary>
	6	/// Indicates wherther the cancellation was requested.
	7	/// </summary>
	8	bool IsCancellationRequested { get ; }
	9
	10	/// <summary>
	11	/// The reason why the operation should be cancelled.
	12	/// </summary>
	13	Exception CancellationReason { get ; }
	14
	15	/// <summary>
	16	/// Accepts if requested.
	17	/// </summary>
	18	/// <returns><c>true</c>, if if requested was accepted, <c>false</c> otherwise.</returns>
	19	bool CancelOperationIfRequested();
	20
	21	/// <summary>
	22	/// Sets the token to cancelled state.
	23	/// </summary>
	24	/// <param name="reason">The reason why the operation was cancelled.</param>
	25	void CancelOperation(Exception reason);
	26
	27	/// <summary>
	28	/// Adds the listener for the cancellation request, is the cancellation was requested the <paramref name="handler"/>
	29	/// is executed immediatelly.
	30	/// </summary>
	31	/// <param name="handler">The handler which will be executed if the cancel occurs.</param>
	32	void CancellationRequested(Action<Exception> handler);
	33
	34	}
	35	}
	36

Implab/SuccessPromise.cs created 644 +111 0

@@ -0,0 +1,111
	1	using System;
	2
	3	namespace Implab {
	4	public class SuccessPromise : IPromise {
	5	#region IPromise implementation
	6
	7	public IPromise On(Action success, Action<Exception> error, Action<Exception> cancel) {
	8	if (success != null) {
	9	try {
	10	success();
	11	} catch(Exception err) {
	12	if (error != null) {
	13	try {
	14	error(err);
	15	// Analysis disable once EmptyGeneralCatchClause
	16	} catch {
	17	}
	18	}
	19	}
	20	}
	21	return this;
	22	}
	23
	24	public IPromise On(Action success, Action<Exception> error) {
	25	if (success != null) {
	26	try {
	27	success();
	28	} catch(Exception err) {
	29	if (error != null) {
	30	try {
	31	error(err);
	32	// Analysis disable once EmptyGeneralCatchClause
	33	} catch {
	34	}
	35	}
	36	}
	37	}
	38	return this;
	39	}
	40
	41	public IPromise On(Action success) {
	42	if (success != null) {
	43	try {
	44	success();
	45	// Analysis disable once EmptyGeneralCatchClause
	46	} catch {
	47	}
	48	}
	49	return this;
	50	}
	51
	52	public IPromise On(Action handler, PromiseEventType events) {
	53	if (handler != null && events.HasFlag(PromiseEventType.Success)) {
	54	try {
	55	handler();
	56	// Analysis disable once EmptyGeneralCatchClause
	57	} catch {
	58	}
	59	}
	60	return this;
	61	}
	62
	63	public IPromise<T> Cast<T>() {
	64	throw new InvalidCastException();
	65	}
	66
	67	public void Join() {
	68	}
	69
	70	public void Join(int timeout) {
	71	}
	72
	73	public Type PromiseType {
	74	get {
	75	return typeof(void);
	76	}
	77	}
	78
	79	public bool IsResolved {
	80	get {
	81	return true;
	82	}
	83	}
	84
	85	public bool IsCancelled {
	86	get {
	87	return false;
	88	}
	89	}
	90
	91	public Exception Error {
	92	get {
	93	return null;
	94	}
	95	}
	96
	97	#endregion
	98
	99	#region ICancellable implementation
	100
	101	public void Cancel() {
	102	}
	103
	104	public void Cancel(Exception reason) {
	105	}
	106
	107	#endregion
	108
	109	}
	110	}
	111

Implab/SuccessPromiseT.cs created 644 +177 0

@@ -0,0 +1,177
	1	using System;
	2
	3	namespace Implab {
	4	public class SuccessPromise<T> : IPromise<T> {
	5	readonly T m_value;
	6
	7	public SuccessPromise(T value){
	8	m_value = value;
	9	}
	10
	11	public IPromise<T> On(Action<T> success, Action<Exception> error, Action<Exception> cancel) {
	12	if (success != null) {
	13	try {
	14	success(m_value);
	15	} catch(Exception err) {
	16	if (error != null) {
	17	try {
	18	error(err);
	19	// Analysis disable once EmptyGeneralCatchClause
	20	} catch {
	21	}
	22	}
	23	}
	24	}
	25	return this;
	26	}
	27
	28	public IPromise<T> On(Action<T> success, Action<Exception> error) {
	29	if (success != null) {
	30	try {
	31	success(m_value);
	32	} catch(Exception err) {
	33	if (error != null) {
	34	try {
	35	error(err);
	36	// Analysis disable once EmptyGeneralCatchClause
	37	} catch {
	38	}
	39	}
	40	}
	41	}
	42	return this;
	43	}
	44
	45	public IPromise<T> On(Action<T> success) {
	46	if (success != null) {
	47	try {
	48	success(m_value);
	49	// Analysis disable once EmptyGeneralCatchClause
	50	} catch {
	51	}
	52	}
	53	return this;
	54	}
	55
	56	public T Join() {
	57	return m_value;
	58	}
	59
	60	public T Join(int timeout) {
	61	return m_value;
	62	}
	63
	64	public IPromise<T> On(Action success, Action<Exception> error, Action<Exception> cancel) {
	65	if (success != null) {
	66	try {
	67	success();
	68	} catch(Exception err) {
	69	if (error != null) {
	70	try {
	71	error(err);
	72	// Analysis disable once EmptyGeneralCatchClause
	73	} catch {
	74	}
	75	}
	76	}
	77	}
	78	return this;
	79	}
	80
	81	public IPromise<T> On(Action success, Action<Exception> error) {
	82	if (success != null) {
	83	try {
	84	success();
	85	} catch(Exception err) {
	86	if (error != null) {
	87	try {
	88	error(err);
	89	// Analysis disable once EmptyGeneralCatchClause
	90	} catch {
	91	}
	92	}
	93	}
	94	}
	95	return this;
	96	}
	97
	98	public IPromise<T> On(Action success) {
	99	if (success != null) {
	100	try {
	101	success();
	102	// Analysis disable once EmptyGeneralCatchClause
	103	} catch {
	104	}
	105	}
	106	return this;
	107	}
	108
	109	public IPromise<T> On(Action handler, PromiseEventType events) {
	110	if (handler != null && events.HasFlag(PromiseEventType.Success)) {
	111	try {
	112	handler();
	113	// Analysis disable once EmptyGeneralCatchClause
	114	} catch {
	115	}
	116	}
	117	return this;
	118	}
	119
	120	IPromise IPromise.On(Action success, Action<Exception> error, Action<Exception> cancel) {
	121	return On(success, error, cancel);
	122	}
	123
	124	IPromise IPromise.On(Action success, Action<Exception> error) {
	125	return On(success, error);
	126	}
	127
	128	IPromise IPromise.On(Action success) {
	129	return On(success);
	130	}
	131
	132	IPromise IPromise.On(Action handler, PromiseEventType events) {
	133	return On(handler, events);
	134	}
	135
	136	public IPromise<T2> Cast<T2>() {
	137	return new SuccessPromise<T2>((T2)(object)m_value);
	138	}
	139
	140	void IPromise.Join() {
	141	}
	142
	143	void IPromise.Join(int timeout) {
	144	}
	145
	146	public Type PromiseType {
	147	get {
	148	return typeof(T);
	149	}
	150	}
	151
	152	public bool IsResolved {
	153	get {
	154	return true;
	155	}
	156	}
	157
	158	public bool IsCancelled {
	159	get {
	160	return false;
	161	}
	162	}
	163
	164	public Exception Error {
	165	get {
	166	return null;
	167	}
	168	}
	169
	170	public void Cancel() {
	171	}
	172
	173	public void Cancel(Exception reason) {
	174	}
	175	}
	176	}
	177

Implab.Fx/ControlBoundPromise.cs +6 -6

             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) {
+                    protected override void SignalSuccess(Promise<T>.HandlerDescriptor handler) {
                         if (m_target.InvokeRequired)
-                            m_target.BeginInvoke(new Action<IDeferred<T>>(base.SignalSuccess), handler);
+                            m_target.BeginInvoke(new Action<Promise<T>.HandlerDescriptor>(base.SignalSuccess), handler);
                         else
                             base.SignalSuccess(handler);
                     }
-                    protected override void SignalCancelled(IDeferred<T> handler, Exception reason) {
+                    protected override void SignalCancelled(Promise<T>.HandlerDescriptor handler, Exception reason) {
                         if (m_target.InvokeRequired)
-                            m_target.BeginInvoke(new Action<IDeferred<T>,Exception>(base.SignalCancelled), handler, reason);
+                            m_target.BeginInvoke(new Action<Promise<T>.HandlerDescriptor,Exception>(base.SignalCancelled), handler, reason);
                         else
                             base.SignalCancelled(handler, reason);
                     }
-                    protected override void SignalError(IDeferred<T> handler, Exception error) {
+                    protected override void SignalError(Promise<T>.HandlerDescriptor handler, Exception error) {
                         if (m_target.InvokeRequired)
-                            m_target.BeginInvoke(new Action<IDeferred<T>,Exception>(base.SignalError), handler, error);
+                            m_target.BeginInvoke(new Action<Promise<T>.HandlerDescriptor,Exception>(base.SignalError), handler, error);
                         else
                             base.SignalError(handler, error);
                     }
                 }
             }

Implab.Test/AsyncTests.cs +4 -4

             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;
+            using TestMethodAttribute = NUnit.Framework.TestAttribute;
             #else
             using Microsoft.VisualStudio.TestTools.UnitTesting;
             #endif
             namespace Implab.Test {
                 [TestClass]
                 public class AsyncTests {
                     [TestMethod]
                     public void ResolveTest() {
                         int res = -1;
                         var p = new Promise<int>();
                         p.Then(x => res = x);
                         p.Resolve(100);
                         Assert.AreEqual(100, res);
                     }
                     [TestMethod]
                     public void RejectTest() {
                         int res = -1;
                         Exception err = null;
                         var p = new Promise<int>();
                         p.Then(
                             x => res = x,
                             e => {
                                 err = e;
                                 return -2;
                             }
                         );
                         p.Reject(new ApplicationException("error"));
                         Assert.AreEqual(res, -1);
                         Assert.AreEqual(err.Message, "error");
                     }
                     [TestMethod]
                     public void CancelExceptionTest() {
                         var p = new Promise<bool>();
-                        p.Cancel();
+                        p.CancelOperation(null);
                         var p2 = p.Then(x => x, null, reason => {
                             throw new ApplicationException("CANCELLED");
                         });
                         try {
                             p2.Join();
                             Assert.Fail();
                         } catch (ApplicationException err) {
                             Assert.AreEqual("CANCELLED", err.InnerException.Message);
                         }
                     }
                     [TestMethod]
                     public void ContinueOnCancelTest() {
                         var p = new Promise<bool>();
-                        p.Cancel();
+                        p.CancelOperation(null);
                         var p2 = p
-                            .Then<bool>(x => x, null, reason => {
+                            .Then(x => x, null, reason => {
                                 throw new ApplicationException("CANCELLED");
                             })
                             .Then(x => x, e => true);
                         Assert.AreEqual(true, p2.Join());
                     }
                     [TestMethod]
                     public void JoinSuccessTest() {
                         var p = new Promise<int>();
                         p.Resolve(100);
                         Assert.AreEqual(p.Join(), 100);
                     }
                     [TestMethod]
                     public void JoinFailTest() {
                         var p = new Promise<int>();
                         p.Reject(new ApplicationException("failed"));
                         try {
                             p.Join();
                             throw new ApplicationException("WRONG!");
                         } catch (TargetInvocationException err) {
                             Assert.AreEqual(err.InnerException.Message, "failed");
                         } catch {
                             Assert.Fail("Got wrong excaption");
                         }
                     }
                     [TestMethod]
                     public void MapTest() {
                         var p = new Promise<int>();
                         var p2 = p.Then(x => x.ToString());
                         p.Resolve(100);
                         Assert.AreEqual(p2.Join(), "100");
                     }
                     [TestMethod]
                     public void FixErrorTest() {
                         var p = new Promise<int>();
                         var p2 = p.Then(x => x, e => 101);
                         p.Reject(new Exception());
                         Assert.AreEqual(p2.Join(), 101);
                     }
                     [TestMethod]
                     public void ChainTest() {
                         var p1 = new Promise<int>();
                         var p3 = p1.Chain(x => {
                             var p2 = new Promise<string>();
                             p2.Resolve(x.ToString());
                             return p2;
                         });
                         p1.Resolve(100);
                         Assert.AreEqual(p3.Join(), "100");
                     }
                     [TestMethod]
                     public void ChainFailTest() {
                         var p1 = new Promise<int>();
                         var p3 = p1.Chain(x => {
                             var p2 = new Promise<string>();
                             p2.Reject(new Exception("DIE!!!"));
                             return p2;
                         });
                         p1.Resolve(100);
                         Assert.IsTrue(p3.IsResolved);
                     }
                     [TestMethod]
                     public void PoolTest() {
                         var pid = Thread.CurrentThread.ManagedThreadId;
                         var p = AsyncPool.Invoke(() => Thread.CurrentThread.ManagedThreadId);
                         Assert.AreNotEqual(pid, p.Join());
                     }
                     [TestMethod]
                     public void WorkerPoolSizeTest() {
                         var pool = new WorkerPool(5, 10, 1);
                         Assert.AreEqual(5, pool.PoolSize);
                         pool.Invoke(() => { Thread.Sleep(100000000); return 10; });
                         pool.Invoke(() => { Thread.Sleep(100000000); return 10; });
                         pool.Invoke(() => { Thread.Sleep(100000000); return 10; });
                         Assert.AreEqual(5, pool.PoolSize);
                         for (int i = 0; i < 100; i++)
                             pool.Invoke(() => { Thread.Sleep(100000000); return 10; });
                         Thread.Sleep(200);
                         Assert.AreEqual(10, pool.PoolSize);
                         pool.Dispose();
                     }
                     [TestMethod]
                     public void WorkerPoolCorrectTest() {
                         var pool = new WorkerPool(0,1000,100);
                         const int iterations = 1000;
                         int pending = iterations;
                         var stop = new ManualResetEvent(false);
                         var count = 0;
                         for (int i = 0; i < iterations; i++) {
                             pool
                                 .Invoke(() => 1)
                                 .Then(x => Interlocked.Add(ref count, x))
                                 .Then(x => Math.Log10(x))
                                 .On(() => {
                                     Interlocked.Decrement(ref pending);
                                     if (pending == 0)
                                         stop.Set();
                                 }, PromiseEventType.All);
                         }
                         stop.WaitOne();
                         Assert.AreEqual(iterations, count);
                         Console.WriteLine("Max threads: {0}", pool.MaxRunningThreads);
                         pool.Dispose();
                     }
                     [TestMethod]
                     public void WorkerPoolDisposeTest() {
                         var pool = new WorkerPool(5, 20);
                         Assert.AreEqual(5, pool.PoolSize);
                         pool.Dispose();
                         Thread.Sleep(500);
                         Assert.AreEqual(0, pool.PoolSize);
                         pool.Dispose();
                     }
                     [TestMethod]
                     public void MTQueueTest() {
                         var queue = new MTQueue<int>();
                         int res;
                         queue.Enqueue(10);
                         Assert.IsTrue(queue.TryDequeue(out res));
                         Assert.AreEqual(10, res);
                         Assert.IsFalse(queue.TryDequeue(out res));
                         for (int i = 0; i < 1000; i++)
                             queue.Enqueue(i);
                         for (int i = 0; i < 1000; i++) {
                             queue.TryDequeue(out res);
                             Assert.AreEqual(i, res);
                         }
                         int writers = 0;
                         int readers = 0;
                         var stop = new ManualResetEvent(false);
                         int total = 0;
                         const int itemsPerWriter = 10000;
                         const int writersCount = 10;
                         for (int i = 0; i < writersCount; i++) {
                             Interlocked.Increment(ref writers);
                             AsyncPool
                                 .RunThread(() => {
                                     for (int ii = 0; ii < itemsPerWriter; ii++) {
                                         queue.Enqueue(1);
                                     }
                                     return 1;
                                 })
                                 .On(() => Interlocked.Decrement(ref writers), PromiseEventType.All);
                         }
                         for (int i = 0; i < 10; i++) {
                             Interlocked.Increment(ref readers);
                             AsyncPool
                                 .RunThread(() => {
                                     int t;
                                     do {
                                         while (queue.TryDequeue(out t))
                                             Interlocked.Add(ref total, t);
                                     } while (writers > 0);
                                     return 1;
                                 })
                                 .On(() => {
                                     Interlocked.Decrement(ref readers);
                                     if (readers == 0)
                                         stop.Set();
                                 }, PromiseEventType.All);
                         }
                         stop.WaitOne();
                         Assert.AreEqual(100000, total);
                     }
                     [TestMethod]
                     public void AsyncQueueTest() {
                         var queue = new AsyncQueue<int>();
                         int res;
                         queue.Enqueue(10);
                         Assert.IsTrue(queue.TryDequeue(out res));
                         Assert.AreEqual(10, res);
                         Assert.IsFalse(queue.TryDequeue(out res));
                         for (int i = 0; i < 1000; i++)
                             queue.Enqueue(i);
                         for (int i = 0; i < 1000; i++) {
                             queue.TryDequeue(out res);
                             Assert.AreEqual(i, res);
                         }
                         const int count = 10000000;
                         int res1 = 0, res2 = 0;
                         var t1 = Environment.TickCount;
                         AsyncPool.RunThread(
                             () => {
                                 for (var i = 0; i < count; i++)
                                     queue.Enqueue(1);
                                 Console.WriteLine("done writer #1: {0} ms", Environment.TickCount - t1);
                             },
                             () => {
                                 for (var i = 0; i < count; i++)
                                     queue.Enqueue(2);
                                 Console.WriteLine("done writer #2: {0} ms", Environment.TickCount - t1);
                             },
                             () => {
                                 int temp;
                                 int i = 0;
                                 while (i < count)
                                     if (queue.TryDequeue(out temp)) {
                                         i++;
                                         res1 += temp;
                                     }
                                 Console.WriteLine("done reader #1: {0} ms", Environment.TickCount - t1);
                             },
                             () => {
                                 int temp;
                                 int i = 0;
                                 while (i < count)
                                     if (queue.TryDequeue(out temp)) {
                                         i++;
                                         res2 += temp;
                                     }
                                 Console.WriteLine("done reader #2: {0} ms", Environment.TickCount - t1);
                             }
                         )
                             .Bundle()
                             .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
                                     .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.Test/Implab.Test.mono.csproj +1 0

             <?xml version="1.0" encoding="utf-8"?>
             <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
               <PropertyGroup>
                 <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
                 <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
                 <ProductVersion>8.0.30703</ProductVersion>
                 <SchemaVersion>2.0</SchemaVersion>
                 <ProjectGuid>{2BD05F84-E067-4B87-9477-FDC2676A21C6}</ProjectGuid>
                 <OutputType>Library</OutputType>
                 <RootNamespace>Implab.Test</RootNamespace>
                 <AssemblyName>Implab.Test</AssemblyName>
                 <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>DEBUG;MONO</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
                 <DefineConstants>MONO</DefineConstants>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug 4.5|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>DEBUG;TRACE;NET_4_5;MONO</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release 4.5|AnyCPU' ">
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <DefineConstants>NET_4_5;MONO</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <ItemGroup>
                 <Reference Include="System" />
                 <Reference Include="nunit.framework" />
               </ItemGroup>
               <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
               <ItemGroup>
                 <Compile Include="AsyncTests.cs" />
                 <Compile Include="PromiseHelper.cs" />
                 <Compile Include="Properties\AssemblyInfo.cs" />
+                <Compile Include="CancelationTests.cs" />
               </ItemGroup>
               <ItemGroup>
                 <ProjectReference Include="..\Implab\Implab.csproj">
                   <Project>{F550F1F8-8746-4AD0-9614-855F4C4B7F05}</Project>
                   <Name>Implab</Name>
                 </ProjectReference>
               </ItemGroup>
             </Project>

Implab/AbstractEvent.cs +14 -11

             using System;
             using Implab.Parallels;
             using System.Threading;
             using System.Reflection;
             namespace Implab {
-                public abstract class AbstractEvent<THandler> : ICancelationToken, ICancellable {
+                public abstract class AbstractEvent<THandler> : ICancellationToken, ICancellable {
                     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 CANCEL_NOT_REQUESTED = 0;
                     const int CANCEL_REQUESTING = 1;
                     const int CANCEL_REQUESTED = 2;
                     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;
                     int m_cancelRequest;
                     Exception m_cancelationReason;
                     MTQueue<Action<Exception>> m_cancelationHandlers;
                     #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()) {
                             if (error is OperationCanceledException) {
                                 CompleteTransit(CANCELLED_STATE);
                                 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(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, 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], m_error);
                             }
                             hp = m_handlerPointer;
                             slot = hp +1 ;
                         }
                         if (m_extraHandlers != null) {
                             THandler handler;
                             while (m_extraHandlers.TryDequeue(out handler))
                                 SignalCancelled(handler, m_error);
                         }
                     }
                     #endregion
                     protected abstract Signal GetResolveSignal();
                     #region synchronization traits
                     protected void WaitResult(int timeout) {
                         if (!IsResolved)
                             GetResolveSignal().Wait(timeout);
                         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, 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 bool IsResolved {
                         get {
                             Thread.MemoryBarrier();
                             return m_state > 1;
                         }
                     }
                     public bool IsCancelled {
                         get {
                             Thread.MemoryBarrier();
                             return m_state == CANCELLED_STATE;
                         }
                     }
                     #endregion
                     public Exception Error {
                         get {
                             return m_error;
                         }
                     }
-                    public bool AcceptIfRequested() {
+                    public bool CancelOperationIfRequested() {
-                        if (IsCancelRequested)
+                        if (IsCancellationRequested) {
-                            CancelOperation(CancelReason);
+                            CancelOperation(CancellationReason);
+                            return true;
+                        }
+                        return false;
                     }
                     public virtual void CancelOperation(Exception reason) {
                         SetCancelled(reason);
                     }
-                    public void CancelationRequested(Action<Exception> handler) {
+                    public void CancellationRequested(Action<Exception> handler) {
                         Safe.ArgumentNotNull(handler, "handler");
-                        if (IsCancelRequested)
+                        if (IsCancellationRequested)
-                            handler(CancelReason);
+                            handler(CancellationReason);
                         if (m_cancelationHandlers == null)
                             Interlocked.CompareExchange(ref m_cancelationHandlers, new MTQueue<Action<Exception>>(), null);
                         m_cancelationHandlers.Enqueue(handler);
-                        if (IsCancelRequested && m_cancelationHandlers.TryDequeue(out handler))
+                        if (IsCancellationRequested && m_cancelationHandlers.TryDequeue(out handler))
                             // TryDeque implies MemoryBarrier()
                             handler(m_cancelationReason);
                     }
-                    public bool IsCancelRequested {
+                    public bool IsCancellationRequested {
                         get {
                             do {
                                 if (m_cancelRequest == CANCEL_NOT_REQUESTED)
                                     return false;
                                 if (m_cancelRequest == CANCEL_REQUESTED)
                                     return true;
                                 Thread.MemoryBarrier();
                             } while(true);
                         }
                     }
-                    public Exception CancelReason {
+                    public Exception CancellationReason {
                         get {
                             do {
                                 Thread.MemoryBarrier();
                             } while(m_cancelRequest == CANCEL_REQUESTING);
                             return m_cancelationReason;
                         }
                     }
                     #region ICancellable implementation
                     public void Cancel() {
                         Cancel(null);
                     }
                     public void Cancel(Exception reason) {
-                        if (CANCEL_NOT_REQUESTED == Interlocked.CompareExchange(ref m_cancelRequest, CANCEL_REQUESTING)) {
+                        if (CANCEL_NOT_REQUESTED == Interlocked.CompareExchange(ref m_cancelRequest, CANCEL_REQUESTING, CANCEL_NOT_REQUESTED)) {
                             m_cancelationReason = reason;
                             m_cancelRequest = CANCEL_REQUESTED;
                             if (m_cancelationHandlers != null) {
                                 Action<Exception> handler;
                                 while (m_cancelationHandlers.TryDequeue(out handler))
                                     handler(m_cancelationReason);
                             }
                         }
                     }
                     #endregion
                 }
             }

Implab/AbstractPromise.cs +6 -4

             using System;
             using Implab.Parallels;
             namespace Implab {
                 public abstract class AbstractPromise : AbstractEvent<AbstractPromise.HandlerDescriptor>, IPromise {
                     public struct HandlerDescriptor {
                         readonly Action m_handler;
                         readonly Action<Exception> m_error;
                         readonly Action<Exception> m_cancel;
                         readonly PromiseEventType m_mask;
                         public HandlerDescriptor(Action success, Action<Exception> error, Action<Exception> cancel) {
                             m_handler = success;
                             m_error = error;
                             m_cancel = cancel;
                             m_mask = PromiseEventType.Success;
                         }
                         public HandlerDescriptor(Action handler, PromiseEventType mask) {
                             m_handler = handler;
+                            m_error = null;
+                            m_cancel = null;
                             m_mask = mask;
                         }
                         public void SignalSuccess() {
-                            if (m_mask & PromiseEventType.Success && m_handler != null) {
+                            if ((m_mask & PromiseEventType.Success) != 0 && m_handler != null) {
                                 try {
                                     m_handler();
                                 } catch (Exception err) {
                                     // avoid calling handler twice in case of error
                                     if (m_error != null)
                                         SignalError(err);
                                 }
                             }
                         }
                         public void SignalError(Exception err) {
                             if (m_error != null) {
                                 try {
                                     m_error(err);
                                     // Analysis disable once EmptyGeneralCatchClause
                                 } catch {
                                 }
-                            } else if (m_mask & PromiseEventType.Error && m_handler != null) {
+                            } else if ((m_mask & PromiseEventType.Error ) != 0 && m_handler != null) {
                                 try {
                                     m_handler();
                                     // Analysis disable once EmptyGeneralCatchClause
                                 } catch {
                                 }
                             }
                         }
                         public void SignalCancel(Exception reason) {
                             if (m_cancel != null) {
                                 try {
                                     m_cancel(reason);
                                 } catch (Exception err) {
                                     SignalError(err);
                                 }
-                            } else if (m_mask & PromiseEventType.Cancelled && m_handler != null) {
+                            } else if ( (m_mask & PromiseEventType.Cancelled) != 0 && m_handler != null) {
                                 try {
                                     m_handler();
                                     // Analysis disable once EmptyGeneralCatchClause
                                 } catch {
                                 }
                             }
                         }
                     }
                     #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, Exception reason) {
                         handler.SignalCancel(reason);
                     }
                     protected override Signal GetResolveSignal() {
                         var signal = new Signal();
                         On(signal.Set, PromiseEventType.All);
+                        return signal;
                     }
                     #endregion
                     public Type PromiseType {
                         get {
                             return typeof(void);
                         }
                     }
                     public IPromise On(Action success, Action<Exception> error, Action<Exception> cancel) {
                         AddHandler(new HandlerDescriptor(success, error, cancel));
                         return this;
                     }
                     public IPromise On(Action success, Action<Exception> error) {
                         AddHandler(new HandlerDescriptor(success, error, null));
                         return this;
                     }
                     public IPromise On(Action success) {
                         AddHandler(new HandlerDescriptor(success, null, null));
                         return this;
                     }
                     public IPromise On(Action handler, PromiseEventType events) {
                         AddHandler(new HandlerDescriptor(handler,events));
                         return this;
                     }
                     public IPromise<T> Cast<T>() {
                         throw new InvalidCastException();
                     }
                     public void Join() {
                         WaitResult(-1);
                     }
                     public void Join(int timeout) {
                         WaitResult(timeout);
                     }
                     protected void SetResult() {
                         BeginSetResult();
                         EndSetResult();
                     }
                 }
             }

Implab/AbstractPromiseT.cs +24 -7

             using System;
             using Implab.Parallels;
             namespace Implab {
                 public abstract class AbstractPromise<T> : AbstractEvent<AbstractPromise<T>.HandlerDescriptor>, IPromise<T> {
                     public struct HandlerDescriptor {
                         readonly Action m_handler;
                         readonly Action<T> m_success;
                         readonly Action<Exception> m_error;
                         readonly Action<Exception> m_cancel;
                         readonly PromiseEventType m_mask;
                         public HandlerDescriptor(Action<T> success, Action<Exception> error, Action<Exception> cancel) {
                             m_success = success;
                             m_error = error;
                             m_cancel = cancel;
+                            m_handler = null;
+                            m_mask = 0;
                         }
                         public HandlerDescriptor(Action success, Action<Exception> error, Action<Exception> cancel) {
                             m_handler = success;
+                            m_success = null;
                             m_error = error;
                             m_cancel = cancel;
                             m_mask = PromiseEventType.Success;
                         }
                         public HandlerDescriptor(Action handler, PromiseEventType mask) {
                             m_handler = handler;
                             m_mask = mask;
+                            m_success = null;
+                            m_error = null;
+                            m_cancel = null;
                         }
                         public void SignalSuccess(T result) {
                             if (m_success != null) {
                                 try {
                                     m_success(result);
                                 } catch(Exception err) {
                                     SignalError(err);
                                 }
-                            } else if (m_mask & PromiseEventType.Success && m_handler != null) {
+                            } else if ((m_mask & PromiseEventType.Success) != 0 && m_handler != null) {
                                 try {
                                     m_handler();
                                 } catch(Exception err) {
                                     // avoid calling handler twice in case of error
                                     if (m_error != null)
                                         SignalError(err);
                                 }
                             }
                         }
                         public void SignalError(Exception err) {
                             if (m_error != null) {
                                 try {
                                     m_error(err);
                                     // Analysis disable once EmptyGeneralCatchClause
                                 } catch {
                                 }
-                            } else if (m_mask & PromiseEventType.Error && m_handler != null) {
+                            } else if ((m_mask & PromiseEventType.Error) != 0 && m_handler != null) {
                                 try {
                                     m_handler();
                                     // Analysis disable once EmptyGeneralCatchClause
                                 } catch {
                                 }
                             }
                         }
                         public void SignalCancel(Exception reason) {
                             if (m_cancel != null) {
                                 try {
                                     m_cancel(reason);
                                 } catch (Exception err) {
                                     SignalError(err);
                                 }
-                            } else if (m_mask & PromiseEventType.Cancelled && m_handler != null) {
+                            } else if ((m_mask & PromiseEventType.Cancelled) != 0 && m_handler != null) {
                                 try {
                                     m_handler();
                                     // Analysis disable once EmptyGeneralCatchClause
                                 } catch {
                                 }
                             }
                         }
                     }
                     public Type PromiseType {
                         get {
                             return typeof(T);
                         }
                     }
-                    public new T Join() {
+                    public T Join() {
                         WaitResult(-1);
                         return m_result;
                     }
-                    public new T Join(int timeout) {
+                    public T Join(int timeout) {
                         WaitResult(timeout);
                         return m_result;
                     }
+                    void IPromise.Join() {
+                        WaitResult(-1);
+                    }
+                    void IPromise.Join(int timeout) {
+                        WaitResult(timeout);
+                    }
                     public IPromise<T> On(Action<T> success, Action<Exception> error, Action<Exception> cancel) {
                         AddHandler(new HandlerDescriptor(success, error, cancel));
                         return this;
                     }
                     public IPromise<T> On(Action<T> success, Action<Exception> error) {
                         AddHandler(new HandlerDescriptor(success, error, null));
                         return this;
                     }
                     public IPromise<T> On(Action<T> success) {
                         AddHandler(new HandlerDescriptor(success, null, null));
                         return this;
                     }
                     public IPromise<T> On(Action handler, PromiseEventType events) {
                         AddHandler(new HandlerDescriptor(handler, events));
                         return this;
                     }
                     public IPromise<T> On(Action success, Action<Exception> error, Action<Exception> cancel) {
                         AddHandler(new HandlerDescriptor(success, error, cancel));
                         return this;
                     }
                     public IPromise<T> On(Action success, Action<Exception> error) {
                         AddHandler(new HandlerDescriptor(success, error, null));
                         return this;
                     }
                     public IPromise<T> On(Action success) {
                         AddHandler(new HandlerDescriptor(success, null, null));
                         return this;
                     }
                     IPromise IPromise.On(Action success, Action<Exception> error, Action<Exception> cancel) {
                         AddHandler(new HandlerDescriptor(success, error, cancel));
                         return this;
                     }
                     IPromise IPromise.On(Action success, Action<Exception> error) {
                         AddHandler(new HandlerDescriptor(success, error, null));
                         return this;
                     }
                     IPromise IPromise.On(Action success) {
                         AddHandler(new HandlerDescriptor(success, null, null));
                         return this;
                     }
+                    IPromise IPromise.On(Action handler, PromiseEventType events) {
+                        AddHandler(new HandlerDescriptor(handler, events));
+                        return this;
+                    }
                     public IPromise<T2> Cast<T2>() {
                         return (IPromise<T2>)this;
                     }
                     #region implemented abstract members of AbstractPromise
                     protected override Signal GetResolveSignal() {
                         var signal = new Signal();
                         AddHandler(new HandlerDescriptor(signal.Set, PromiseEventType.All));
                         return signal;
                     }
                     protected override void SignalSuccess(HandlerDescriptor handler) {
                         handler.SignalSuccess(m_result);
                     }
                     protected override void SignalError(HandlerDescriptor handler, Exception error) {
                         handler.SignalError(error);
                     }
                     protected override void SignalCancelled(HandlerDescriptor handler, Exception reason) {
                         handler.SignalCancel(reason);
                     }
                     #endregion
                     T m_result;
                     protected void SetResult(T value) {
                         if (BeginSetResult()) {
                             m_result = value;
                             EndSetResult();
                         }
                     }
                 }
             }

Implab/IDeferred.cs +1 -1

             using System;
             namespace Implab {
                 /// <summary>
                 /// Deferred result, usually used by asynchronous services as the service part of the promise.
                 /// </summary>
-                public interface IDeferred : ICancelationToken {
+                public interface IDeferred : ICancellationToken {
                     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/IDeferredT.cs +1 -1

             using System;
             namespace Implab {
-                public interface IDeferred<T> : ICancelationToken {
+                public interface IDeferred<in T> : ICancellationToken {
                     void Resolve(T value);
                     void Reject(Exception error);
                 }
             }

Implab/ITaskController.cs 0 -3

             using System;
-            using System.Collections.Generic;
-            using System.Linq;
-            using System.Text;
             namespace Implab {
                 public interface ITaskController: IProgressHandler, ICancellable {
                     bool IsCancelled {
                         get;
                     }
                     event EventHandler Cancelled;
                 }
             }

Implab/Implab.csproj +12 -2

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

Implab/Parallels/ArrayTraits.cs +1 -1

             using Implab.Diagnostics;
             using System;
             using System.Diagnostics;
             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>();
                         readonly LogicalOperation m_logicalOperation;
                         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_logicalOperation = TraceContext.Instance.CurrentOperation;
                             m_next = 0;
                             m_source = source;
                             m_pending = source.Length;
                             m_action = action;
                             m_promise.On(Dispose, PromiseEventType.All);
                             InitPool();
                         }
                         public Promise<int> Promise {
                             get {
                                 return m_promise;
                             }
                         }
                         protected override void Worker() {
                             TraceContext.Instance.EnterLogicalOperation(m_logicalOperation, false);
                             try {
                                 base.Worker();
                             } finally {
                                 TraceContext.Instance.Leave();
                             }
                         }
                         protected override bool TryDequeue(out int unit) {
                             unit = Interlocked.Increment(ref m_next) - 1;
                             return unit < m_source.Length;
                         }
                         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[]>();
                         readonly LogicalOperation m_logicalOperation;
                         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_logicalOperation = TraceContext.Instance.CurrentOperation;
                             m_promise.On(Dispose, PromiseEventType.All);
                             InitPool();
                         }
                         public Promise<TDst[]> Promise {
                             get {
                                 return m_promise;
                             }
                         }
                         protected override void Worker() {
                             TraceContext.Instance.EnterLogicalOperation(m_logicalOperation,false);
                             try {
                                 base.Worker();
                             } finally {
                                 TraceContext.Instance.Leave();
                             }
                         }
                         protected override bool TryDequeue(out int unit) {
                             unit = Interlocked.Increment(ref m_next) - 1;
                             return unit < m_source.Length;
                         }
                         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 IPromise<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 IPromise<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 IPromise<TDst[]> ChainedMap<TSrc, TDst>(this TSrc[] source, Func<TSrc, IPromise<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","Threads number must be greater then zero");
                         if (source.Length == 0)
-                            return Promise<TDst[]>.ResultToPromise(new TDst[0]);
+                            return Promise<TDst[]>.FromResult(new TDst[0]);
                         var promise = new Promise<TDst[]>();
                         var res = new TDst[source.Length];
                         var pending = source.Length;
                         object locker = new object();
                         int slots = threads;
                         // Analysis disable AccessToDisposedClosure
                         AsyncPool.RunThread<int>(() => {
                             for (int i = 0; i < source.Length; i++) {
                                 if(promise.IsResolved)
                                     break; // stop processing in case of error or cancellation
                                 var idx = i;
                                 if (Interlocked.Decrement(ref slots) < 0) {
                                     lock(locker) {
                                         while(slots < 0)
                                             Monitor.Wait(locker);
                                     }
                                 }
                                 try {
                                     transform(source[i])
                                         .On( x => {
                                             Interlocked.Increment(ref slots);
                                             lock (locker) {
                                                 Monitor.Pulse(locker);
                                             }
                                         })
                                         .On(
                                             x => {
                                                 res[idx] = x;
                                                 var left = Interlocked.Decrement(ref pending);
                                                 if (left == 0)
                                                     promise.Resolve(res);
                                             },
                                             promise.Reject
                                         );
                                 } catch (Exception e) {
                                     promise.Reject(e);
                                 }
                             }
                             return 0;
                         });
                         return promise;
                     }
                 }
             }

Implab/Parallels/AsyncPool.cs +69 0

             using Implab.Diagnostics;
             using System;
             using System.Threading;
             using System.Linq;
             namespace Implab.Parallels {
             	/// <summary>
             	/// Класс для распаралеливания задач.
             	/// </summary>
             	/// <remarks>
             	/// Используя данный класс и лямда выражения можно распараллелить
             	/// вычисления, для этого используется концепция обещаний.
             	/// </remarks>
             	public static class AsyncPool {
             		public static IPromise<T> Invoke<T>(Func<T> func) {
             			var p = new Promise<T>();
                         var caller = TraceContext.Instance.CurrentOperation;
             			ThreadPool.QueueUserWorkItem(param => {
                             TraceContext.Instance.EnterLogicalOperation(caller,false);
             				try {
             					p.Resolve(func());
             				} catch(Exception e) {
             					p.Reject(e);
                             } finally {
                                 TraceContext.Instance.Leave();
                             }
             			});
             			return p;
             		}
+                    public static IPromise<T> Invoke<T>(Func<ICancellationToken, T> func) {
+                        var p = new Promise<T>();
+                        var caller = TraceContext.Instance.CurrentOperation;
+                        ThreadPool.QueueUserWorkItem(param => {
+                            TraceContext.Instance.EnterLogicalOperation(caller,false);
+                            try {
+                                p.Resolve(func(p));
+                            } catch(Exception e) {
+                                p.Reject(e);
+                            } finally {
+                                TraceContext.Instance.Leave();
+                            }
+                        });
+                        return p;
+                    }
                     public static IPromise<T> RunThread<T>(Func<T> func) {
                         var p = new Promise<T>();
                         var caller = TraceContext.Instance.CurrentOperation;
                         var worker = new Thread(() => {
                             TraceContext.Instance.EnterLogicalOperation(caller,false);
                             try {
                                 p.Resolve(func());
                             } catch (Exception e) {
                                 p.Reject(e);
                             } finally {
                                 TraceContext.Instance.Leave();
                             }
                         });
                         worker.IsBackground = true;
                         worker.Start();
                         return p;
                     }
+                    public static IPromise<T> RunThread<T>(Func<ICancellationToken, T> func) {
+                        var p = new Promise<T>();
+                        var caller = TraceContext.Instance.CurrentOperation;
+                        var worker = new Thread(() => {
+                            TraceContext.Instance.EnterLogicalOperation(caller,false);
+                            try {
+                                p.Resolve(func(p));
+                            } catch (Exception e) {
+                                p.Reject(e);
+                            } finally {
+                                TraceContext.Instance.Leave();
+                            }
+                        });
+                        worker.IsBackground = true;
+                        worker.Start();
+                        return p;
+                    }
                     public static IPromise RunThread(Action func) {
                         var p = new Promise();
                         var caller = TraceContext.Instance.CurrentOperation;
                         var worker = new Thread(() => {
                             TraceContext.Instance.EnterLogicalOperation(caller,false);
                             try {
                                 func();
                                 p.Resolve();
                             } catch (Exception e) {
                                 p.Reject(e);
                             } finally {
                                 TraceContext.Instance.Leave();
                             }
                         });
                         worker.IsBackground = true;
                         worker.Start();
                         return p;
                     }
+                    public static IPromise RunThread(Action<ICancellationToken> func) {
+                        var p = new Promise();
+                        var caller = TraceContext.Instance.CurrentOperation;
+                        var worker = new Thread(() => {
+                            TraceContext.Instance.EnterLogicalOperation(caller,false);
+                            try {
+                                func(p);
+                                p.Resolve();
+                            } catch (Exception e) {
+                                p.Reject(e);
+                            } finally {
+                                TraceContext.Instance.Leave();
+                            }
+                        });
+                        worker.IsBackground = true;
+                        worker.Start();
+                        return p;
+                    }
                     public static IPromise[] RunThread(params Action[] func) {
                         return func.Select(f => RunThread(f)).ToArray();
                     }
+                    public static IPromise[] RunThread(params Action<ICancellationToken>[] func) {
+                        return func.Select(f => RunThread(f)).ToArray();
+                    }
                     public static IPromise<T>[] RunThread<T>(params Func<T>[] func) {
                         return func.Select(f => RunThread(f)).ToArray();
                     }
+                    public static IPromise<T>[] RunThread<T>(params Func<ICancellationToken, T>[] func) {
+                        return func.Select(f => RunThread(f)).ToArray();
+                    }
             	}
             }

Implab/PromiseExtensions.cs +110 0

             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(() => 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.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.Cancel(
                                             new Exception("The dependency promise is cancelled", reason)
                                         );
                                 }
                             );
                             i++;
                         }
                         return medium;
                     }
+                    public static IPromise Then(this IPromise that, Action success, Action<Exception> error, Action<Exception> cancel) {
+                        Safe.ArgumentNotNull(that, "that");
+                        var d = new ActionTask(success, error, cancel);
+                        that.On(d.Resolve, d.Reject, d.CancelOperation);
+                        if (success != null)
+                            d.CancellationRequested(that.Cancel);
+                        return d;
+                    }
+                    public static IPromise Then(this IPromise that, Action success, Action<Exception> error) {
+                        return Then(that, success, error, null);
+                    }
+                    public static IPromise Then(this IPromise that, Action success) {
+                        return Then(that, success, null, null);
+                    }
+                    public static IPromise<T> Then<T>(this IPromise that, Func<T> success, Func<Exception, T> error, Func<Exception, T> cancel) {
+                        Safe.ArgumentNotNull(that, "that");
+                        var d = new FuncTask<T>(success, error, cancel);
+                        that.On(d.Resolve, d.Reject, d.CancelOperation);
+                        if (success != null)
+                            d.CancellationRequested(that.Cancel);
+                        return d;
+                    }
+                    public static IPromise<T> Then<T>(this IPromise that, Func<T> success, Func<Exception, T> error) {
+                        return Then(that, success, error, null);
+                    }
+                    public static IPromise<T> Then<T>(this IPromise that, Func<T> success) {
+                        return Then(that, success, null, null);
+                    }
+                    public static IPromise<T2> Then<T, T2>(this IPromise<T> that, Func<T, T2> success, Func<Exception, T2> error, Func<Exception, T2> cancel) {
+                        Safe.ArgumentNotNull(that, "that");
+                        var d = new FuncTask<T,T2>(success, error, cancel);
+                        that.On(d.Resolve, d.Reject, d.CancelOperation);
+                        if (success != null)
+                            d.CancellationRequested(that.Cancel);
+                        return d;
+                    }
+                    public static IPromise<T2> Then<T, T2>(this IPromise<T> that, Func<T, T2> success, Func<Exception, T2> error) {
+                        return Then(that, success, error, null);
+                    }
+                    public static IPromise<T2> Then<T, T2>(this IPromise<T> that, Func<T, T2> success) {
+                        return Then(that, success, null, null);
+                    }
+                    #region chain traits
+                    public static IPromise Chain(this IPromise that, Func<IPromise> success, Func<Exception,IPromise> error, Func<Exception,IPromise> cancel) {
+                        Safe.ArgumentNotNull(that, "that");
+                        var d = new ActionChainTask(success, error, cancel);
+                        that.On(d.Resolve, d.Reject, d.CancelOperation);
+                        if (success != null)
+                            d.CancellationRequested(that.Cancel);
+                        return d;
+                    }
+                    public static IPromise Chain(this IPromise that, Func<IPromise> success, Func<Exception,IPromise> error) {
+                        return Chain(that, success, error, null);
+                    }
+                    public static IPromise Chain(this IPromise that, Func<IPromise> success) {
+                        return Chain(that, success, null, null);
+                    }
+                    public static IPromise<T> Chain<T>(this IPromise that, Func<IPromise<T>> success, Func<Exception, IPromise<T>> error, Func<Exception, IPromise<T>> cancel) {
+                        Safe.ArgumentNotNull(that, "that");
+                        var d = new FuncChainTask<T>(success, error, cancel);
+                        that.On(d.Resolve, d.Reject, d.CancelOperation);
+                        if (success != null)
+                            d.CancellationRequested(that.Cancel);
+                        return d;
+                    }
+                    public static IPromise<T> Chain<T>(this IPromise that, Func<IPromise<T>> success, Func<Exception, IPromise<T>> error) {
+                        return Chain(that, success, error, null);
+                    }
+                    public static IPromise<T> Chain<T>(this IPromise that, Func<IPromise<T>> success) {
+                        return Chain(that, success, null, null);
+                    }
+                    public static IPromise<T2> Chain<T, T2>(this IPromise<T> that, Func<T, IPromise<T2>> success, Func<Exception, IPromise<T2>> error, Func<Exception, IPromise<T2>> cancel) {
+                        Safe.ArgumentNotNull(that, "that");
+                        var d = new FuncChainTask<T,T2>(success, error, cancel);
+                        that.On(d.Resolve, d.Reject, d.CancelOperation);
+                        if (success != null)
+                            d.CancellationRequested(that.Cancel);
+                        return d;
+                    }
+                    public static IPromise<T2> Chain<T, T2>(this IPromise<T> that, Func<T, IPromise<T2>> success, Func<Exception, IPromise<T2>> error) {
+                        return Chain(that, success, error, null);
+                    }
+                    public static IPromise<T2> Chain<T, T2>(this IPromise<T> that, Func<T, IPromise<T2>> success) {
+                        return Chain(that, success, null, null);
+                    }
+                    #endregion
                     #if NET_4_5
                     public static Task<T> GetTask<T>(this IPromise<T> that) {
                         Safe.ArgumentNotNull(that, "that");
                         var tcs = new TaskCompletionSource<T>();
                         that.On(tcs.SetResult, tcs.SetException, r => tcs.SetCanceled());
                         return tcs.Task;
                     }
                     #endif
                 }
             }

Implab/Safe.cs +2 -2

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

Implab/SyncContextPromise.cs +3 -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) {
+                    protected override void SignalSuccess(Promise<T>.HandlerDescriptor handler) {
                         m_context.Post(x => base.SignalSuccess(handler), null);
                     }
-                    protected override void SignalError(IDeferred<T> handler, Exception error) {
+                    protected override void SignalError(Promise<T>.HandlerDescriptor handler, Exception error) {
                         m_context.Post(x => base.SignalError(handler, error), null);
                     }
-                    protected override void SignalCancelled(IDeferred<T> handler, Exception reason) {
+                    protected override void SignalCancelled(Promise<T>.HandlerDescriptor handler, Exception reason) {
                         m_context.Post(x => base.SignalCancelled(handler, reason), null);
                     }
                 }
             }

MonoPlay/Program.cs +15 -68

@@ -1,93 +1,40
1	using System;	1	using System;
2	using Implab.Diagnostics;	2	using Implab.Diagnostics;
3	using Implab.Parallels;	3	using Implab.Parallels;
4	using Implab;	4	using Implab;
5	using System.Collections.Generic;	5	using System.Collections.Generic;
6	using System.Collections.Concurrent;	6	using System.Collections.Concurrent;
7	using System.Threading;	7	using System.Threading;
8		8
9	namespace MonoPlay {	9	namespace MonoPlay {
10	class MainClass {	10	class MainClass {
		11
		12
11	public static void Main(string[] args) {	13	public static void Main(string[] args) {
12	if (args == null)	14	if (args == null)
13	throw new ArgumentNullException("args");	15	throw new ArgumentNullException("args");
14		16
15	var t1 = Environment.TickCount;	17	var t1 = Environment.TickCount;
16		18
17	~~const~~ int ~~reads~~ = 100000;	19	for (int i = 0; i < 10000000; i++) {
18	const int writes = 1000;	20
19	const int readThreads = 8;	21	var p = new Promise<int>();
20	const int writeThreads = 0;	22	p.On(HandleResult);
21		23	p.Resolve(i);
22	var l = new SharedLock();	24	}
23	var st = new HashSet<int>();
24
25	Action reader1 = () => {
26	for (int i =0; i < reads; i++) {
27	try {
28	l.LockShared();
29	st.Contains(i % 1000);
30	Thread.Sleep(0);
31	} finally {
32	l.Release();
33	}
34	}
35	};
36
37	Action reader2 = () => {
38	for(var i = 0; i < reads; i++)
39	lock(st) {
40	st.Contains(i % 1000);
41	Thread.Sleep(0);
42	}
43	};
44
45	Action writer1 = () => {
46	var rnd = new Random(Environment.TickCount);
47	for (int i = 0; i < writes; i++) {
48	try {
49	l.LockExclusive();
50	st.Add(rnd.Next(1000));
51	//Thread.Sleep(1);
52	} finally {
53	l.Release();
54	}
55	}
56	};
57
58	Action writer2 = () => {
59	var rnd = new Random(Environment.TickCount);
60	for (int i = 0; i < writes; i++) {
61	lock (st) {
62	st.Add(rnd.Next(1000));
63	//Thread.Sleep(1);
64	}
65	}
66	};
67
68
69
70	var readers = new IPromise[readThreads];
71	for (int i = 0; i < readThreads; i++)
72	readers[i] = AsyncPool.RunThread(reader2);
73
74	var writers = new IPromise[writeThreads];
75	for (int i = 0; i < writeThreads; i++)
76	writers[i] = AsyncPool.RunThread(writer1);
77
78
79	new [] {
80	readers.Bundle().On(() => Console.WriteLine("readers complete in {0} ms", Environment.TickCount - t1)),
81	writers.Bundle().On(() => Console.WriteLine("writers complete in {0} ms", Environment.TickCount - t1))
82	}.Bundle().Join();
83
84
85		25
86	var t2 = Environment.TickCount;	26	var t2 = Environment.TickCount;
87	Console.WriteLine("done: {0} ms, {1:.00} Mb, {2} GC", t2 - t1, GC.GetTotalMemory(false) / (1024*1024), GC.CollectionCount(0) );	27	Console.WriteLine("done: {0} ms, {1:.00} Mb, {2} GC", t2 - t1, GC.GetTotalMemory(false) / (1024*1024), GC.CollectionCount(0) );
88		28
89	}	29	}
90		30
		31	static void HandleAction ()
		32	{
		33
		34	}
91		35
		36	static void HandleResult(int x) {
		37
		38	}
92	}	39	}
93	}	40	}

Implab/ChainTask.cs removed 0 -54

NO CONTENT: file was removed

Implab/ICancelationToken.cs removed 0 -36

NO CONTENT: file was removed

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