pub/ImplabNet: Implab/Promise.cs annotate

annotate Implab/Promise.cs @ 101:279e226dffdd v2

code cleanup added EnsureDispatched extension

author	cin
date	Thu, 06 Nov 2014 20:03:19 +0300
parents	8ddf1648eca4
children	5f10d54b45df

rev	line source
2 aa367305156b small fixes cin parents: 1 diff changeset	1 using System;
aa367305156b small fixes cin parents: 1 diff changeset	2 using System.Collections.Generic;
aa367305156b small fixes cin parents: 1 diff changeset	3 using System.Reflection;
aa367305156b small fixes cin parents: 1 diff changeset	4 using System.Threading;
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	5 using Implab.Parallels;
2 aa367305156b small fixes cin parents: 1 diff changeset	6
aa367305156b small fixes cin parents: 1 diff changeset	7 namespace Implab {
aa367305156b small fixes cin parents: 1 diff changeset	8
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	9 /// <summary>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	10 /// Класс для асинхронного получения результатов. Так называемое "обещание".
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	11 /// </summary>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	12 /// <typeparam name="T">Тип получаемого результата</typeparam>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	13 /// <remarks>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	14 /// <para>Сервис при обращении к его методу дает обещаиние о выполнении операции,
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	15 /// клиент получив такое обещание может установить ряд обратных вызово для получения
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	16 /// событий выполнения обещания, тоесть завершения операции и предоставлении результатов.</para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	17 /// <para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	18 /// Обещение может быть как выполнено, так и выполнено с ошибкой. Для подписки на
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	19 /// данные события клиент должен использовать методы <c>Then</c>.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	20 /// </para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	21 /// <para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	22 /// Сервис, в свою очередь, по окончанию выполнения операции (возможно с ошибкой),
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	23 /// использует методы <c>Resolve</c> либо <c>Reject</c> для оповещения клиетна о
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	24 /// выполнении обещания.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	25 /// </para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	26 /// <para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	27 /// Если сервер успел выполнить обещание еще до того, как клиент на него подписался,
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	28 /// то в момент подписки клиента будут вызваны соответсвующие события в синхронном
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	29 /// режиме и клиент будет оповещен в любом случае. Иначе, обработчики добавляются в
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	30 /// список в порядке подписания и в этом же порядке они будут вызваны при выполнении
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	31 /// обещания.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	32 /// </para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	33 /// <para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	34 /// Обрабатывая результаты обещания можно преобразовывать результаты либо инициировать
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	35 /// связанные асинхронные операции, которые также возвращают обещания. Для этого следует
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	36 /// использовать соответствующую форму методе <c>Then</c>.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	37 /// </para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	38 /// <para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	39 /// Также хорошим правилом является то, что <c>Resolve</c> и <c>Reject</c> должен вызывать
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	40 /// только инициатор обещания иначе могут возникнуть противоречия.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	41 /// </para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	42 /// </remarks>
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	43 public class Promise<T> : IPromise<T> {
2 aa367305156b small fixes cin parents: 1 diff changeset	44
28 81708975d6f7 fixes cin parents: 27 diff changeset	45 protected struct HandlerDescriptor {
101 279e226dffdd code cleanup cin parents: 99 diff changeset	46 public Action<T> resultHandler;
279e226dffdd code cleanup cin parents: 99 diff changeset	47 public Func<Exception,T> errorHandler;
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	48 public Action cancellHandler;
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	49 public Promise<T> medium;
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	50
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	51 public void Resolve(T result) {
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	52 if (resultHandler != null) {
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	53 try {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	54 resultHandler(result);
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	55 } catch (Exception e) {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	56 Reject(e);
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	57 return;
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	58 }
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	59 }
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	60 if (medium != null)
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	61 medium.Resolve(result);
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	62 }
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	63
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	64 public void Reject(Exception err) {
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	65 if (errorHandler != null) {
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	66 try {
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	67 var res = errorHandler(err);
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	68 if (medium != null)
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	69 medium.Resolve(res);
99 8ddf1648eca4 fixed TransientPromiseException handling cin parents: 96 diff changeset	70 /*} catch (TransientPromiseException err2) {
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	71 if (medium != null)
99 8ddf1648eca4 fixed TransientPromiseException handling cin parents: 96 diff changeset	72 medium.Reject(err2.InnerException);*/
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	73 } catch (Exception err2) {
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	74 if (medium != null)
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	75 medium.Reject(err2);
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	76 }
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	77 } else if (medium != null)
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	78 medium.Reject(err);
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	79 }
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	80
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	81 public void Cancel() {
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	82 if (cancellHandler != null) {
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	83 try {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	84 cancellHandler();
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	85 } catch (Exception err) {
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	86 Reject(err);
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	87 return;
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	88 }
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	89 }
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	90 if (medium != null)
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	91 medium.Cancel();
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	92 }
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	93 }
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	94
71 1714fd8678ef code cleanup cin parents: 66 diff changeset	95 const int UNRESOLVED_SATE = 0;
1714fd8678ef code cleanup cin parents: 66 diff changeset	96 const int TRANSITIONAL_STATE = 1;
1714fd8678ef code cleanup cin parents: 66 diff changeset	97 const int SUCCEEDED_STATE = 2;
1714fd8678ef code cleanup cin parents: 66 diff changeset	98 const int REJECTED_STATE = 3;
1714fd8678ef code cleanup cin parents: 66 diff changeset	99 const int CANCELLED_STATE = 4;
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	100
101 279e226dffdd code cleanup cin parents: 99 diff changeset	101 int m_childrenCount;
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	102 int m_state;
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	103 T m_result;
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	104 Exception m_error;
9 c82e0dfbb4dd sync cin parents: 7 diff changeset	105
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	106 readonly MTQueue<HandlerDescriptor> m_handlers = new MTQueue<HandlerDescriptor>();
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	107
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	108 public Promise() {
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	109 }
2 aa367305156b small fixes cin parents: 1 diff changeset	110
101 279e226dffdd code cleanup cin parents: 99 diff changeset	111 public Promise(IPromise parent) {
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	112 if (parent != null)
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	113 AddHandler(
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	114 null,
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	115 null,
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	116 () => {
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	117 if (parent.IsExclusive)
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	118 parent.Cancel();
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	119 },
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	120 null
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	121 );
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	122 }
2 aa367305156b small fixes cin parents: 1 diff changeset	123
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	124 bool BeginTransit() {
71 1714fd8678ef code cleanup cin parents: 66 diff changeset	125 return UNRESOLVED_SATE == Interlocked.CompareExchange(ref m_state, TRANSITIONAL_STATE, UNRESOLVED_SATE);
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	126 }
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	127
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	128 void CompleteTransit(int state) {
71 1714fd8678ef code cleanup cin parents: 66 diff changeset	129 if (TRANSITIONAL_STATE != Interlocked.CompareExchange(ref m_state, state, TRANSITIONAL_STATE))
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	130 throw new InvalidOperationException("Can't complete transition when the object isn't in the transitional state");
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	131 }
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	132
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	133 void WaitTransition() {
71 1714fd8678ef code cleanup cin parents: 66 diff changeset	134 while (m_state == TRANSITIONAL_STATE) {
80 4f20870d0816 added memory barriers cin parents: 76 diff changeset	135 Thread.MemoryBarrier();
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	136 }
9bf5b23650c9 refactoring cin parents: 19 diff changeset	137 }
9bf5b23650c9 refactoring cin parents: 19 diff changeset	138
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	139 public bool IsResolved {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	140 get {
80 4f20870d0816 added memory barriers cin parents: 76 diff changeset	141 Thread.MemoryBarrier();
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	142 return m_state > 1;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	143 }
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	144 }
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	145
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	146 public bool IsCancelled {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	147 get {
80 4f20870d0816 added memory barriers cin parents: 76 diff changeset	148 Thread.MemoryBarrier();
71 1714fd8678ef code cleanup cin parents: 66 diff changeset	149 return m_state == CANCELLED_STATE;
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	150 }
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	151 }
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	152
29 768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	153 public Type PromiseType {
768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	154 get { return typeof(T); }
768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	155 }
768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	156
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	157 /// <summary>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	158 /// Выполняет обещание, сообщая об успешном выполнении.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	159 /// </summary>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	160 /// <param name="result">Результат выполнения.</param>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	161 /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	162 public void Resolve(T result) {
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	163 if (BeginTransit()) {
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	164 m_result = result;
71 1714fd8678ef code cleanup cin parents: 66 diff changeset	165 CompleteTransit(SUCCEEDED_STATE);
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	166 OnStateChanged();
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	167 } else {
9bf5b23650c9 refactoring cin parents: 19 diff changeset	168 WaitTransition();
71 1714fd8678ef code cleanup cin parents: 66 diff changeset	169 if (m_state != CANCELLED_STATE)
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	170 throw new InvalidOperationException("The promise is already resolved");
9bf5b23650c9 refactoring cin parents: 19 diff changeset	171 }
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	172 }
2 aa367305156b small fixes cin parents: 1 diff changeset	173
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	174 /// <summary>
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	175 /// Выполняет обещание, сообщая об успешном выполнении. Результатом выполнения будет пустое значения.
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	176 /// </summary>
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	177 /// <remarks>
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	178 /// Данный вариант удобен в случаях, когда интересен факт выполнения операции, нежели полученное значение.
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	179 /// </remarks>
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	180 public void Resolve() {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	181 Resolve(default(T));
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	182 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	183
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	184 /// <summary>
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	185 /// Выполняет обещание, сообщая об ошибке
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	186 /// </summary>
16 5a4b735ba669 sync cin parents: 15 diff changeset	187 /// <remarks>
5a4b735ba669 sync cin parents: 15 diff changeset	188 /// Поскольку обещание должно работать в многопточной среде, при его выполнении сразу несколько потоков
5a4b735ba669 sync cin parents: 15 diff changeset	189 /// могу вернуть ошибку, при этом только первая будет использована в качестве результата, остальные
5a4b735ba669 sync cin parents: 15 diff changeset	190 /// будут проигнорированы.
5a4b735ba669 sync cin parents: 15 diff changeset	191 /// </remarks>
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	192 /// <param name="error">Исключение возникшее при выполнении операции</param>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	193 /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	194 public void Reject(Exception error) {
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	195 if (BeginTransit()) {
99 8ddf1648eca4 fixed TransientPromiseException handling cin parents: 96 diff changeset	196 m_error = error is TransientPromiseException ? error.InnerException : error;
71 1714fd8678ef code cleanup cin parents: 66 diff changeset	197 CompleteTransit(REJECTED_STATE);
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	198 OnStateChanged();
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	199 } else {
9bf5b23650c9 refactoring cin parents: 19 diff changeset	200 WaitTransition();
71 1714fd8678ef code cleanup cin parents: 66 diff changeset	201 if (m_state == SUCCEEDED_STATE)
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	202 throw new InvalidOperationException("The promise is already resolved");
9bf5b23650c9 refactoring cin parents: 19 diff changeset	203 }
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	204 }
2 aa367305156b small fixes cin parents: 1 diff changeset	205
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	206 /// <summary>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	207 /// Отменяет операцию, если это возможно.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	208 /// </summary>
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	209 /// <remarks>Для определения была ли операция отменена следует использовать свойство <see cref="IsCancelled"/>.</remarks>
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	210 public void Cancel() {
101 279e226dffdd code cleanup cin parents: 99 diff changeset	211 if (BeginTransit()) {
71 1714fd8678ef code cleanup cin parents: 66 diff changeset	212 CompleteTransit(CANCELLED_STATE);
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	213 OnStateChanged();
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	214 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	215 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	216
101 279e226dffdd code cleanup cin parents: 99 diff changeset	217 public IPromise<T> Then(Action<T> success, Func<Exception,T> error, Action cancel) {
75 4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	218 if (success == null && error == null && cancel == null)
4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	219 return this;
4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	220
101 279e226dffdd code cleanup cin parents: 99 diff changeset	221 var medium = new Promise<T>(this);
75 4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	222
4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	223 AddHandler(success, error, cancel, medium);
4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	224
4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	225 return medium;
4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	226 }
4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	227
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	228 /// <summary>
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	229 /// Adds new handlers to this promise.
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	230 /// </summary>
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	231 /// <param name="success">The handler of the successfully completed operation.
6ec82bf68c8e refactoring cin parents: 10 diff changeset	232 /// This handler will recieve an operation result as a parameter.</param>
6ec82bf68c8e refactoring cin parents: 10 diff changeset	233 /// <param name="error">Handles an exception that may occur during the operation and returns the value which will be used as the result of the operation.</param>
6ec82bf68c8e refactoring cin parents: 10 diff changeset	234 /// <returns>The new promise chained to this one.</returns>
101 279e226dffdd code cleanup cin parents: 99 diff changeset	235 public IPromise<T> Then(Action<T> success, Func<Exception,T> error) {
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	236 if (success == null && error == null)
6ec82bf68c8e refactoring cin parents: 10 diff changeset	237 return this;
6ec82bf68c8e refactoring cin parents: 10 diff changeset	238
101 279e226dffdd code cleanup cin parents: 99 diff changeset	239 var medium = new Promise<T>(this);
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	240
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	241 AddHandler(success, error, null, medium);
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	242
6ec82bf68c8e refactoring cin parents: 10 diff changeset	243 return medium;
6ec82bf68c8e refactoring cin parents: 10 diff changeset	244 }
6ec82bf68c8e refactoring cin parents: 10 diff changeset	245
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	246
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	247
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	248
101 279e226dffdd code cleanup cin parents: 99 diff changeset	249 public IPromise<T> Then(Action<T> success) {
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	250 if (success == null)
6ec82bf68c8e refactoring cin parents: 10 diff changeset	251 return this;
6ec82bf68c8e refactoring cin parents: 10 diff changeset	252
101 279e226dffdd code cleanup cin parents: 99 diff changeset	253 var medium = new Promise<T>(this);
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	254
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	255 AddHandler(success, null, null, medium);
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	256
6ec82bf68c8e refactoring cin parents: 10 diff changeset	257 return medium;
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	258 }
2 aa367305156b small fixes cin parents: 1 diff changeset	259
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	260 /// <summary>
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	261 /// Последний обработчик в цепочки обещаний.
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	262 /// </summary>
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	263 /// <param name="success"></param>
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	264 /// <param name="error"></param>
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	265 /// <param name="cancel"></param>
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	266 /// <remarks>
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	267 /// <para>
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	268 /// Данный метод не создает связанного с текущим обещания и предназначен для окончания
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	269 /// фсинхронной цепочки.
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	270 /// </para>
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	271 /// <para>
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	272 /// Если данный метод вызвать несколько раз, либо добавить другие обработчики, то цепочка
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	273 /// не будет одиночной <see cref="IsExclusive"/> и, как следствие, будет невозможна отмена
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	274 /// всей цепи обещаний снизу (с самого последнего обещания).
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	275 /// </para>
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	276 /// </remarks>
101 279e226dffdd code cleanup cin parents: 99 diff changeset	277 public void Last(Action<T> success, Action<Exception> error, Action cancel) {
75 4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	278 if (success == null && error == null && cancel == null)
4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	279 return;
4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	280
101 279e226dffdd code cleanup cin parents: 99 diff changeset	281 Func<Exception,T> errorHandler = null;
75 4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	282 if (error != null)
4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	283 errorHandler = err => {
4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	284 error(err);
4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	285 return default(T);
4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	286 };
4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	287 AddHandler(success, errorHandler, cancel, null);
4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	288 }
4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	289
101 279e226dffdd code cleanup cin parents: 99 diff changeset	290 public void Last(Action<T> success, Action<Exception> error) {
75 4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	291 Last(success, error, null);
4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	292 }
4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	293
101 279e226dffdd code cleanup cin parents: 99 diff changeset	294 public void Last(Action<T> success) {
75 4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	295 Last(success, null, null);
4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	296 }
4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	297
101 279e226dffdd code cleanup cin parents: 99 diff changeset	298 public IPromise Error(Action<Exception> error) {
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	299 if (error == null)
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	300 return this;
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	301
101 279e226dffdd code cleanup cin parents: 99 diff changeset	302 var medium = new Promise<T>(this);
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	303
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	304 AddHandler(
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	305 null,
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	306 e => {
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	307 error(e);
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	308 return default(T);
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	309 },
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	310 null,
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	311 medium
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	312 );
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	313
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	314 return medium;
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	315 }
2 aa367305156b small fixes cin parents: 1 diff changeset	316
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	317 /// <summary>
6ec82bf68c8e refactoring cin parents: 10 diff changeset	318 /// Handles error and allows to keep the promise.
6ec82bf68c8e refactoring cin parents: 10 diff changeset	319 /// </summary>
6ec82bf68c8e refactoring cin parents: 10 diff changeset	320 /// <remarks>
6ec82bf68c8e refactoring cin parents: 10 diff changeset	321 /// If the specified handler throws an exception, this exception will be used to reject the promise.
6ec82bf68c8e refactoring cin parents: 10 diff changeset	322 /// </remarks>
6ec82bf68c8e refactoring cin parents: 10 diff changeset	323 /// <param name="handler">The error handler which returns the result of the promise.</param>
6ec82bf68c8e refactoring cin parents: 10 diff changeset	324 /// <returns>New promise.</returns>
101 279e226dffdd code cleanup cin parents: 99 diff changeset	325 public IPromise<T> Error(Func<Exception,T> handler) {
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	326 if (handler == null)
6ec82bf68c8e refactoring cin parents: 10 diff changeset	327 return this;
6ec82bf68c8e refactoring cin parents: 10 diff changeset	328
101 279e226dffdd code cleanup cin parents: 99 diff changeset	329 var medium = new Promise<T>(this);
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	330
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	331 AddHandler(null, handler, null, medium);
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	332
6ec82bf68c8e refactoring cin parents: 10 diff changeset	333 return medium;
6ec82bf68c8e refactoring cin parents: 10 diff changeset	334 }
6ec82bf68c8e refactoring cin parents: 10 diff changeset	335
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	336 /// <summary>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	337 /// Позволяет преобразовать результат выполения операции к новому типу.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	338 /// </summary>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	339 /// <typeparam name="TNew">Новый тип результата.</typeparam>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	340 /// <param name="mapper">Преобразование результата к новому типу.</param>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	341 /// <param name="error">Обработчик ошибки. Данный обработчик получит
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	342 /// исключение возникшее при выполнении операции.</param>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	343 /// <returns>Новое обещание, которое будет выполнено при выполнении исходного обещания.</returns>
96 daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	344 /// <param name = "cancel"></param>
101 279e226dffdd code cleanup cin parents: 99 diff changeset	345 public IPromise<TNew> Then<TNew>(Func<T, TNew> mapper, Func<Exception,TNew> error, Action cancel) {
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	346 Safe.ArgumentNotNull(mapper, "mapper");
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	347
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	348 // создаем прицепленное обещание
101 279e226dffdd code cleanup cin parents: 99 diff changeset	349 var medium = new Promise<TNew>(this);
2 aa367305156b small fixes cin parents: 1 diff changeset	350
101 279e226dffdd code cleanup cin parents: 99 diff changeset	351 Action<T> resultHandler = result => medium.Resolve(mapper(result));
279e226dffdd code cleanup cin parents: 99 diff changeset	352 Func<Exception,T> errorHandler;
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	353 if (error != null)
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	354 errorHandler = e => {
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	355 try {
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	356 medium.Resolve(error(e));
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	357 } catch (Exception e2) {
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	358 // в случае ошибки нужно передать исключение дальше по цепочке
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	359 medium.Reject(e2);
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	360 }
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	361 return default(T);
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	362 };
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	363 else
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	364 errorHandler = e => {
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	365 medium.Reject(e);
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	366 return default(T);
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	367 };
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	368
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	369 Action cancelHandler;
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	370 if (cancel != null)
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	371 cancelHandler = () => {
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	372 cancel();
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	373 medium.Cancel();
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	374 };
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	375 else
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	376 cancelHandler = medium.Cancel;
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	377
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	378
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	379 AddHandler(
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	380 resultHandler,
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	381 errorHandler,
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	382 cancelHandler,
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	383 null
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	384 );
2 aa367305156b small fixes cin parents: 1 diff changeset	385
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	386 return medium;
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	387 }
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	388
101 279e226dffdd code cleanup cin parents: 99 diff changeset	389 public IPromise<TNew> Then<TNew>(Func<T, TNew> mapper, Func<Exception,TNew> error) {
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	390 return Then(mapper, error, null);
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	391 }
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	392
101 279e226dffdd code cleanup cin parents: 99 diff changeset	393 public IPromise<TNew> Then<TNew>(Func<T, TNew> mapper) {
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	394 return Then(mapper, null, null);
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	395 }
2 aa367305156b small fixes cin parents: 1 diff changeset	396
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	397 /// <summary>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	398 /// Сцепляет несколько аснхронных операций. Указанная асинхронная операция будет вызвана после
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	399 /// выполнения текущей, а результат текущей операции может быть использован для инициализации
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	400 /// новой операции.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	401 /// </summary>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	402 /// <typeparam name="TNew">Тип результата указанной асинхронной операции.</typeparam>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	403 /// <param name="chained">Асинхронная операция, которая должна будет начаться после выполнения текущей.</param>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	404 /// <param name="error">Обработчик ошибки. Данный обработчик получит
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	405 /// исключение возникшее при выполнении текуещй операции.</param>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	406 /// <returns>Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции.</returns>
96 daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	407 /// <param name = "cancel"></param>
101 279e226dffdd code cleanup cin parents: 99 diff changeset	408 public IPromise<TNew> Chain<TNew>(Func<T, IPromise<TNew>> chained, Func<Exception,IPromise<TNew>> error, Action cancel) {
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	409
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	410 Safe.ArgumentNotNull(chained, "chained");
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	411
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	412 // проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	413 // создать посредника, к которому будут подвызяваться следующие обработчики.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	414 // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	415 // передать через него результаты работы.
101 279e226dffdd code cleanup cin parents: 99 diff changeset	416 var medium = new Promise<TNew>(this);
2 aa367305156b small fixes cin parents: 1 diff changeset	417
101 279e226dffdd code cleanup cin parents: 99 diff changeset	418 Action<T> resultHandler = delegate(T result) {
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	419 if (medium.IsCancelled)
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	420 return;
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	421
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	422 var promise = chained(result);
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	423
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	424 promise.Last(
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	425 medium.Resolve,
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	426 medium.Reject,
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	427 () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	428 );
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	429
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	430 // notify chained operation that it's not needed anymore
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	431 // порядок вызова Then, Cancelled важен, поскольку от этого
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	432 // зависит IsExclusive
101 279e226dffdd code cleanup cin parents: 99 diff changeset	433 medium.Last(
279e226dffdd code cleanup cin parents: 99 diff changeset	434 null,
279e226dffdd code cleanup cin parents: 99 diff changeset	435 null,
279e226dffdd code cleanup cin parents: 99 diff changeset	436 () => {
279e226dffdd code cleanup cin parents: 99 diff changeset	437 if (promise.IsExclusive)
279e226dffdd code cleanup cin parents: 99 diff changeset	438 promise.Cancel();
279e226dffdd code cleanup cin parents: 99 diff changeset	439 }
279e226dffdd code cleanup cin parents: 99 diff changeset	440 );
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	441 };
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	442
101 279e226dffdd code cleanup cin parents: 99 diff changeset	443 Func<Exception,T> errorHandler;
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	444
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	445 if (error != null)
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	446 errorHandler = delegate(Exception e) {
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	447 try {
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	448 var promise = error(e);
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	449
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	450 promise.Last(
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	451 medium.Resolve,
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	452 medium.Reject,
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	453 () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	454 );
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	455
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	456 // notify chained operation that it's not needed anymore
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	457 // порядок вызова Then, Cancelled важен, поскольку от этого
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	458 // зависит IsExclusive
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	459 medium.Cancelled(() => {
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	460 if (promise.IsExclusive)
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	461 promise.Cancel();
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	462 });
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	463 } catch (Exception e2) {
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	464 medium.Reject(e2);
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	465 }
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	466 return default(T);
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	467 };
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	468 else
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	469 errorHandler = err => {
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	470 medium.Reject(err);
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	471 return default(T);
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	472 };
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	473
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	474
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	475 Action cancelHandler;
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	476 if (cancel != null)
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	477 cancelHandler = () => {
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	478 if (cancel != null)
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	479 cancel();
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	480 medium.Cancel();
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	481 };
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	482 else
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	483 cancelHandler = medium.Cancel;
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	484
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	485 AddHandler(
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	486 resultHandler,
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	487 errorHandler,
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	488 cancelHandler,
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	489 null
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	490 );
2 aa367305156b small fixes cin parents: 1 diff changeset	491
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	492 return medium;
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	493 }
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	494
101 279e226dffdd code cleanup cin parents: 99 diff changeset	495 public IPromise<TNew> Chain<TNew>(Func<T, IPromise<TNew>> chained, Func<Exception,IPromise<TNew>> error) {
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	496 return Chain(chained, error, null);
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	497 }
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	498
101 279e226dffdd code cleanup cin parents: 99 diff changeset	499 public IPromise<TNew> Chain<TNew>(Func<T, IPromise<TNew>> chained) {
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	500 return Chain(chained, null, null);
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	501 }
2 aa367305156b small fixes cin parents: 1 diff changeset	502
26 f0bf98e4d22c refactoring cin parents: 25 diff changeset	503 public IPromise<T> Cancelled(Action handler) {
101 279e226dffdd code cleanup cin parents: 99 diff changeset	504 var medium = new Promise<T>(this);
74 c4140283575c minor fixes cin parents: 72 diff changeset	505 AddHandler(null, null, handler, medium);
c4140283575c minor fixes cin parents: 72 diff changeset	506 return medium;
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	507 }
aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	508
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	509 /// <summary>
9bf5b23650c9 refactoring cin parents: 19 diff changeset	510 /// Adds the specified handler for all cases (success, error, cancel)
9bf5b23650c9 refactoring cin parents: 19 diff changeset	511 /// </summary>
9bf5b23650c9 refactoring cin parents: 19 diff changeset	512 /// <param name="handler">The handler that will be called anyway</param>
9bf5b23650c9 refactoring cin parents: 19 diff changeset	513 /// <returns>self</returns>
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	514 public IPromise<T> Anyway(Action handler) {
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	515 Safe.ArgumentNotNull(handler, "handler");
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	516
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	517 AddHandler(
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	518 x => handler(),
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	519 e => {
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	520 handler();
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	521 throw new TransientPromiseException(e);
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	522 },
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	523 handler,
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	524 null
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	525 );
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	526 return this;
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	527 }
aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	528
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	529 /// <summary>
29 768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	530 /// Преобразует результат обещания к нужному типу
768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	531 /// </summary>
768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	532 /// <typeparam name="T2"></typeparam>
768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	533 /// <returns></returns>
768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	534 public IPromise<T2> Cast<T2>() {
75 4439140706d0 major refactoring, added tasks support cin parents: 74 diff changeset	535 return Then(x => (T2)(object)x, null);
29 768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	536 }
768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	537
768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	538 /// <summary>
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	539 /// Дожидается отложенного обещания и в случае успеха, возвращает
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	540 /// его, результат, в противном случае бросает исключение.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	541 /// </summary>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	542 /// <remarks>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	543 /// <para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	544 /// Если ожидание обещания было прервано по таймауту, это не значит,
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	545 /// что обещание было отменено или что-то в этом роде, это только
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	546 /// означает, что мы его не дождались, однако все зарегистрированные
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	547 /// обработчики, как были так остались и они будут вызваны, когда
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	548 /// обещание будет выполнено.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	549 /// </para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	550 /// <para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	551 /// Такое поведение вполне оправдано поскольку таймаут может истечь
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	552 /// в тот момент, когда началась обработка цепочки обработчиков, и
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	553 /// к тому же текущее обещание может стоять в цепочке обещаний и его
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	554 /// отклонение может привести к непрогнозируемому результату.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	555 /// </para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	556 /// </remarks>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	557 /// <param name="timeout">Время ожидания</param>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	558 /// <returns>Результат выполнения обещания</returns>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	559 public T Join(int timeout) {
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	560 var evt = new ManualResetEvent(false);
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	561 Anyway(() => evt.Set());
2 aa367305156b small fixes cin parents: 1 diff changeset	562
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	563 if (!evt.WaitOne(timeout, true))
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	564 throw new TimeoutException();
2 aa367305156b small fixes cin parents: 1 diff changeset	565
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	566 switch (m_state) {
71 1714fd8678ef code cleanup cin parents: 66 diff changeset	567 case SUCCEEDED_STATE:
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	568 return m_result;
71 1714fd8678ef code cleanup cin parents: 66 diff changeset	569 case CANCELLED_STATE:
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	570 throw new OperationCanceledException();
71 1714fd8678ef code cleanup cin parents: 66 diff changeset	571 case REJECTED_STATE:
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	572 throw new TargetInvocationException(m_error);
aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	573 default:
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	574 throw new ApplicationException(String.Format("Invalid promise state {0}", m_state));
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	575 }
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	576 }
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	577
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	578 public T Join() {
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	579 return Join(Timeout.Infinite);
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	580 }
2 aa367305156b small fixes cin parents: 1 diff changeset	581
101 279e226dffdd code cleanup cin parents: 99 diff changeset	582 void AddHandler(Action<T> success, Func<Exception,T> error, Action cancel, Promise<T> medium) {
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	583 if (success != null \|\| error != null)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	584 Interlocked.Increment(ref m_childrenCount);
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	585
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	586 var handler = new HandlerDescriptor {
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	587 resultHandler = success,
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	588 errorHandler = error,
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	589 cancellHandler = cancel,
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	590 medium = medium
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	591 };
2 aa367305156b small fixes cin parents: 1 diff changeset	592
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	593 bool queued;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	594
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	595 if (!IsResolved) {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	596 m_handlers.Enqueue(handler);
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	597 queued = true;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	598 } else {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	599 // the promise is in resolved state, just invoke the handled with minimum overhead
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	600 queued = false;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	601 InvokeHandler(handler);
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	602 }
2 aa367305156b small fixes cin parents: 1 diff changeset	603
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	604 if (queued && IsResolved && m_handlers.TryDequeue(out handler))
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	605 // if the promise have been resolved while we was adding handler to the queue
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	606 // we can't guarantee that someone is still processing it
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	607 // therefore we will fetch a handler from the queue and execute it
27 a236cd1f0477 fixes cin parents: 26 diff changeset	608 // note that fetched handler may be not the one that we have added
a236cd1f0477 fixes cin parents: 26 diff changeset	609 // even we can fetch no handlers at all :)
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	610 InvokeHandler(handler);
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	611 }
2 aa367305156b small fixes cin parents: 1 diff changeset	612
27 a236cd1f0477 fixes cin parents: 26 diff changeset	613 protected virtual void InvokeHandler(HandlerDescriptor handler) {
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	614 switch (m_state) {
71 1714fd8678ef code cleanup cin parents: 66 diff changeset	615 case SUCCEEDED_STATE:
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	616 handler.Resolve(m_result);
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	617 break;
71 1714fd8678ef code cleanup cin parents: 66 diff changeset	618 case REJECTED_STATE:
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	619 handler.Reject(m_error);
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	620 break;
71 1714fd8678ef code cleanup cin parents: 66 diff changeset	621 case CANCELLED_STATE:
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	622 handler.Cancel();
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	623 break;
aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	624 default:
aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	625 // do nothing
aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	626 return;
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	627 }
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	628 }
2 aa367305156b small fixes cin parents: 1 diff changeset	629
65 653c4e04968b minor changes cin parents: 33 diff changeset	630 void OnStateChanged() {
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	631 HandlerDescriptor handler;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	632 while (m_handlers.TryDequeue(out handler))
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	633 InvokeHandler(handler);
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	634 }
6ec82bf68c8e refactoring cin parents: 10 diff changeset	635
9 c82e0dfbb4dd sync cin parents: 7 diff changeset	636 public bool IsExclusive {
c82e0dfbb4dd sync cin parents: 7 diff changeset	637 get {
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	638 return m_childrenCount <= 1;
9 c82e0dfbb4dd sync cin parents: 7 diff changeset	639 }
c82e0dfbb4dd sync cin parents: 7 diff changeset	640 }
c82e0dfbb4dd sync cin parents: 7 diff changeset	641
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	642 /// <summary>
9bf5b23650c9 refactoring cin parents: 19 diff changeset	643 /// Объединяет несколько обещаний в одно, результатом которого является массив результатов других обещаний.
9bf5b23650c9 refactoring cin parents: 19 diff changeset	644 /// Если хотябы одно из переданных обещаний не будет выполнено, то новое обещение тоже не будет выполнено.
9bf5b23650c9 refactoring cin parents: 19 diff changeset	645 /// При отмене нового обещания, переданные обещания также будут отменены, если никто больше на них не подписан.
9bf5b23650c9 refactoring cin parents: 19 diff changeset	646 /// </summary>
9bf5b23650c9 refactoring cin parents: 19 diff changeset	647 /// <param name="promises">Список обещаний. Если список пустой, то результирующее обещание возвращается уже выполненным.</param>
9bf5b23650c9 refactoring cin parents: 19 diff changeset	648 /// <returns>Обещание объединяющее в себе результат переданных обещаний.</returns>
9bf5b23650c9 refactoring cin parents: 19 diff changeset	649 /// <exception cref="ArgumentNullException"><paramref name="promises"/> не может быть null</exception>
30 2fad2d1f4b03 small refactoring, cleanup. cin parents: 29 diff changeset	650 public static IPromise<T[]> CreateComposite(IList<IPromise<T>> promises) {
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	651 if (promises == null)
9bf5b23650c9 refactoring cin parents: 19 diff changeset	652 throw new ArgumentNullException();
9bf5b23650c9 refactoring cin parents: 19 diff changeset	653
9bf5b23650c9 refactoring cin parents: 19 diff changeset	654 // создаем аккумулятор для результатов и результирующее обещание
9bf5b23650c9 refactoring cin parents: 19 diff changeset	655 var result = new T[promises.Count];
9bf5b23650c9 refactoring cin parents: 19 diff changeset	656 var promise = new Promise<T[]>();
9bf5b23650c9 refactoring cin parents: 19 diff changeset	657
9bf5b23650c9 refactoring cin parents: 19 diff changeset	658 // special case
9bf5b23650c9 refactoring cin parents: 19 diff changeset	659 if (promises.Count == 0) {
9bf5b23650c9 refactoring cin parents: 19 diff changeset	660 promise.Resolve(result);
9bf5b23650c9 refactoring cin parents: 19 diff changeset	661 return promise;
9bf5b23650c9 refactoring cin parents: 19 diff changeset	662 }
9bf5b23650c9 refactoring cin parents: 19 diff changeset	663
9bf5b23650c9 refactoring cin parents: 19 diff changeset	664 int pending = promises.Count;
9bf5b23650c9 refactoring cin parents: 19 diff changeset	665
9bf5b23650c9 refactoring cin parents: 19 diff changeset	666 for (int i = 0; i < promises.Count; i++) {
9bf5b23650c9 refactoring cin parents: 19 diff changeset	667 var dest = i;
9bf5b23650c9 refactoring cin parents: 19 diff changeset	668
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	669 if (promises[i] != null) {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	670 promises[i].Then(
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	671 x => {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	672 result[dest] = x;
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	673 if (Interlocked.Decrement(ref pending) == 0)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	674 promise.Resolve(result);
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	675 },
72 d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	676 e => {
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	677 promise.Reject(e);
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	678 return default(T);
d67b95eddaf4 promises refactoring cin parents: 71 diff changeset	679 }
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	680 );
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	681 } else {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	682 if (Interlocked.Decrement(ref pending) == 0)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	683 promise.Resolve(result);
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	684 }
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	685 }
9bf5b23650c9 refactoring cin parents: 19 diff changeset	686
9bf5b23650c9 refactoring cin parents: 19 diff changeset	687 promise.Cancelled(
9bf5b23650c9 refactoring cin parents: 19 diff changeset	688 () => {
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	689 foreach (var d in promises)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	690 if (d != null && d.IsExclusive)
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	691 d.Cancel();
9bf5b23650c9 refactoring cin parents: 19 diff changeset	692 }
9bf5b23650c9 refactoring cin parents: 19 diff changeset	693 );
9bf5b23650c9 refactoring cin parents: 19 diff changeset	694
9bf5b23650c9 refactoring cin parents: 19 diff changeset	695 return promise;
9bf5b23650c9 refactoring cin parents: 19 diff changeset	696 }
9bf5b23650c9 refactoring cin parents: 19 diff changeset	697
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	698 /// <summary>
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	699 /// Объединяет несколько обещаний в одно. Результирующее обещание будет выполнено при
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	700 /// выполнении всех указанных обещаний. При этом возвращаемые значения первичных обещаний
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	701 /// игнорируются.
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	702 /// </summary>
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	703 /// <param name="promises">Коллекция первичных обещаний, которые будут объеденены в одно.</param>
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	704 /// <returns>Новое обещание, объединяющее в себе переданные.</returns>
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	705 /// <remarks>
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	706 /// Если в коллекции встречаюься <c>null</c>, то они воспринимаются как выполненные обещания.
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	707 /// </remarks>
66 790e8a997d30 Refactoring cin parents: 65 diff changeset	708 public static IPromise CreateComposite(ICollection<IPromise> promises) {
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	709 if (promises == null)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	710 throw new ArgumentNullException();
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	711 if (promises.Count == 0)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	712 return Promise<object>.ResultToPromise(null);
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	713
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	714 int countdown = promises.Count;
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	715
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	716 var result = new Promise<object>();
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	717
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	718 foreach (var d in promises) {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	719 if (d == null) {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	720 if (Interlocked.Decrement(ref countdown) == 0)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	721 result.Resolve(null);
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	722 } else {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	723 d.Then(() => {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	724 if (Interlocked.Decrement(ref countdown) == 0)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	725 result.Resolve(null);
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	726 });
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	727 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	728 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	729
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	730 result.Cancelled(() => {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	731 foreach (var d in promises)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	732 if (d != null && d.IsExclusive)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	733 d.Cancel();
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	734 });
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	735
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	736 return result;
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	737 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	738
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	739 public static Promise<T> ResultToPromise(T result) {
9bf5b23650c9 refactoring cin parents: 19 diff changeset	740 var p = new Promise<T>();
9bf5b23650c9 refactoring cin parents: 19 diff changeset	741 p.Resolve(result);
9bf5b23650c9 refactoring cin parents: 19 diff changeset	742 return p;
9bf5b23650c9 refactoring cin parents: 19 diff changeset	743 }
9bf5b23650c9 refactoring cin parents: 19 diff changeset	744
9bf5b23650c9 refactoring cin parents: 19 diff changeset	745 public static Promise<T> ExceptionToPromise(Exception error) {
9bf5b23650c9 refactoring cin parents: 19 diff changeset	746 if (error == null)
9bf5b23650c9 refactoring cin parents: 19 diff changeset	747 throw new ArgumentNullException();
9bf5b23650c9 refactoring cin parents: 19 diff changeset	748
9bf5b23650c9 refactoring cin parents: 19 diff changeset	749 var p = new Promise<T>();
9bf5b23650c9 refactoring cin parents: 19 diff changeset	750 p.Reject(error);
9bf5b23650c9 refactoring cin parents: 19 diff changeset	751 return p;
9bf5b23650c9 refactoring cin parents: 19 diff changeset	752 }
9bf5b23650c9 refactoring cin parents: 19 diff changeset	753
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	754 #region IPromiseBase explicit implementation
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	755
101 279e226dffdd code cleanup cin parents: 99 diff changeset	756 IPromise IPromise.Then(Action success, Action<Exception> error, Action cancel) {
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	757 return Then(
101 279e226dffdd code cleanup cin parents: 99 diff changeset	758 success != null ? new Action<T>(x => success()) : null,
279e226dffdd code cleanup cin parents: 99 diff changeset	759 error != null ? new Func<Exception,T>(e => {
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	760 error(e);
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	761 return default(T);
96 daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	762 }) : null,
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	763 cancel
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	764 );
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	765 }
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	766
101 279e226dffdd code cleanup cin parents: 99 diff changeset	767 IPromise IPromise.Then(Action success, Action<Exception> error) {
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	768 return Then(
101 279e226dffdd code cleanup cin parents: 99 diff changeset	769 success != null ? new Action<T>(x => success()) : null,
279e226dffdd code cleanup cin parents: 99 diff changeset	770 error != null ? new Func<Exception,T>(e => {
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	771 error(e);
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	772 return default(T);
96 daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	773 }) : null
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	774 );
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	775 }
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	776
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	777 IPromise IPromise.Then(Action success) {
96 daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	778 Safe.ArgumentNotNull(success, "success");
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	779 return Then(x => success());
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	780 }
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	781
101 279e226dffdd code cleanup cin parents: 99 diff changeset	782 IPromise IPromise.Chain(Func<IPromise> chained, Func<Exception,IPromise> error, Action cancel) {
96 daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	783 return ChainNoResult(chained, error, cancel);
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	784 }
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	785
101 279e226dffdd code cleanup cin parents: 99 diff changeset	786 IPromise ChainNoResult(Func<IPromise> chained, Func<Exception,IPromise> error, Action cancel) {
96 daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	787 Safe.ArgumentNotNull(chained, "chained");
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	788
101 279e226dffdd code cleanup cin parents: 99 diff changeset	789 var medium = new Promise<object>(this);
96 daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	790
101 279e226dffdd code cleanup cin parents: 99 diff changeset	791 Action<T> resultHandler = delegate {
96 daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	792 if (medium.IsCancelled)
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	793 return;
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	794
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	795 var promise = chained();
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	796
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	797 promise.Last(
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	798 medium.Resolve,
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	799 medium.Reject,
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	800 () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	801 );
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	802
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	803 // notify chained operation that it's not needed anymore
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	804 // порядок вызова Then, Cancelled важен, поскольку от этого
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	805 // зависит IsExclusive
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	806 medium.Cancelled(() => {
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	807 if (promise.IsExclusive)
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	808 promise.Cancel();
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	809 });
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	810 };
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	811
101 279e226dffdd code cleanup cin parents: 99 diff changeset	812 Func<Exception,T> errorHandler;
96 daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	813
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	814 if (error != null)
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	815 errorHandler = delegate(Exception e) {
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	816 try {
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	817 var promise = error(e);
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	818
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	819 promise.Last(
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	820 medium.Resolve,
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	821 medium.Reject,
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	822 () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	823 );
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	824
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	825 // notify chained operation that it's not needed anymore
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	826 // порядок вызова Then, Cancelled важен, поскольку от этого
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	827 // зависит IsExclusive
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	828 medium.Cancelled(() => {
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	829 if (promise.IsExclusive)
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	830 promise.Cancel();
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	831 });
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	832 } catch (Exception e2) {
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	833 medium.Reject(e2);
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	834 }
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	835 return default(T);
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	836 };
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	837 else
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	838 errorHandler = err => {
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	839 medium.Reject(err);
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	840 return default(T);
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	841 };
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	842
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	843
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	844 Action cancelHandler;
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	845 if (cancel != null)
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	846 cancelHandler = () => {
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	847 if (cancel != null)
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	848 cancel();
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	849 medium.Cancel();
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	850 };
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	851 else
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	852 cancelHandler = medium.Cancel;
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	853
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	854 AddHandler(
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	855 resultHandler,
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	856 errorHandler,
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	857 cancelHandler,
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	858 null
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	859 );
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	860
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	861 return medium;
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	862 }
101 279e226dffdd code cleanup cin parents: 99 diff changeset	863 IPromise IPromise.Chain(Func<IPromise> chained, Func<Exception,IPromise> error) {
96 daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	864 return ChainNoResult(chained, error, null);
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	865 }
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	866 IPromise IPromise.Chain(Func<IPromise> chained) {
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	867 return ChainNoResult(chained, null, null);
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	868 }
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	869
daffa72a1cec Added the chaining method to the non-generic IPromise cin parents: 80 diff changeset	870
101 279e226dffdd code cleanup cin parents: 99 diff changeset	871 void IPromise.Last(Action success, Action<Exception> error, Action cancel) {
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	872 Last(x => success(), error, cancel);
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	873 }
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	874
101 279e226dffdd code cleanup cin parents: 99 diff changeset	875 void IPromise.Last(Action success, Action<Exception> error) {
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	876 Last(x => success(), error, null);
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	877 }
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	878
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	879 void IPromise.Last(Action success) {
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	880 Last(x => success(), null, null);
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	881 }
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	882
101 279e226dffdd code cleanup cin parents: 99 diff changeset	883 IPromise IPromise.Error(Action<Exception> error) {
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	884 return Error(error);
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	885 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	886
76 c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	887 IPromise IPromise.Anyway(Action handler) {
c761fc982e1d Refactoring of the IPromise<T> interface cin parents: 75 diff changeset	888 return Anyway(handler);
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	889 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	890
66 790e8a997d30 Refactoring cin parents: 65 diff changeset	891 IPromise IPromise.Cancelled(Action handler) {
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	892 return Cancelled(handler);
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	893 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	894
66 790e8a997d30 Refactoring cin parents: 65 diff changeset	895 void IPromise.Join() {
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	896 Join();
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	897 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	898
66 790e8a997d30 Refactoring cin parents: 65 diff changeset	899 void IPromise.Join(int timeout) {
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	900 Join(timeout);
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	901 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	902
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	903 #endregion
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	904
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	905
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	906
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	907 }
2 aa367305156b small fixes cin parents: 1 diff changeset	908 }

Mercurial > pub > ImplabNet

annotate Implab/Promise.cs @ 101:279e226dffdd v2