pub/ImplabNet: Implab/Promise.cs annotate

annotate Implab/Promise.cs @ 105:4d308952fd5e v2

minor fixes

author	cin
date	Mon, 10 Nov 2014 10:17:54 +0300
parents	5f10d54b45df
children	d4e38929ce36

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

Mercurial > pub > ImplabNet

annotate Implab/Promise.cs @ 105:4d308952fd5e v2