pub/ImplabNet: Implab/Promise.cs annotate

annotate Implab/Promise.cs @ 66:790e8a997d30

Refactoring

author	cin
date	Thu, 14 Aug 2014 18:08:09 +0400
parents	653c4e04968b
children	1714fd8678ef

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.Diagnostics;
aa367305156b small fixes cin parents: 1 diff changeset	5 using System.Threading;
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	6 using Implab.Parallels;
2 aa367305156b small fixes cin parents: 1 diff changeset	7
aa367305156b small fixes cin parents: 1 diff changeset	8 namespace Implab {
aa367305156b small fixes cin parents: 1 diff changeset	9
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	10 public delegate void ErrorHandler(Exception e);
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	11 public delegate T ErrorHandler<out T>(Exception e);
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	12 public delegate void ResultHandler<in T>(T result);
aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	13 public delegate TNew ResultMapper<in TSrc, out TNew>(TSrc result);
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	14 public delegate IPromise<TNew> ChainedOperation<in TSrc, TNew>(TSrc result);
2 aa367305156b small fixes cin parents: 1 diff changeset	15
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	16 /// <summary>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	17 /// Класс для асинхронного получения результатов. Так называемое "обещание".
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	18 /// </summary>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	19 /// <typeparam name="T">Тип получаемого результата</typeparam>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	20 /// <remarks>
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 /// событий выполнения обещания, тоесть завершения операции и предоставлении результатов.</para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	24 /// <para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	25 /// Обещение может быть как выполнено, так и выполнено с ошибкой. Для подписки на
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	26 /// данные события клиент должен использовать методы <c>Then</c>.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	27 /// </para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	28 /// <para>
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 /// использует методы <c>Resolve</c> либо <c>Reject</c> для оповещения клиетна о
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 /// режиме и клиент будет оповещен в любом случае. Иначе, обработчики добавляются в
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	37 /// список в порядке подписания и в этом же порядке они будут вызваны при выполнении
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	38 /// обещания.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	39 /// </para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	40 /// <para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	41 /// Обрабатывая результаты обещания можно преобразовывать результаты либо инициировать
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	42 /// связанные асинхронные операции, которые также возвращают обещания. Для этого следует
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	43 /// использовать соответствующую форму методе <c>Then</c>.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	44 /// </para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	45 /// <para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	46 /// Также хорошим правилом является то, что <c>Resolve</c> и <c>Reject</c> должен вызывать
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	47 /// только инициатор обещания иначе могут возникнуть противоречия.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	48 /// </para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	49 /// </remarks>
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	50 public class Promise<T> : IPromise<T> {
2 aa367305156b small fixes cin parents: 1 diff changeset	51
28 81708975d6f7 fixes cin parents: 27 diff changeset	52 protected struct HandlerDescriptor {
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	53 public ResultHandler<T> resultHandler;
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	54 public ErrorHandler errorHandler;
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	55 public Action cancellHandler;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	56
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	57 public void Resolve(T result) {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	58 if (resultHandler != null)
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	59 try {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	60 resultHandler(result);
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	61 } catch (Exception e) {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	62 Reject(e);
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 }
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	65
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	66 public void Reject(Exception err) {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	67 if (errorHandler != null)
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	68 try {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	69 errorHandler(err);
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	70 } catch {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	71 }
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	72 }
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	73
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	74 public void Cancel() {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	75 if (cancellHandler != null)
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	76 try {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	77 cancellHandler();
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	78 } catch {
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 }
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	81 }
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	82
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	83 const int UnresolvedSate = 0;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	84 const int TransitionalState = 1;
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	85 const int SucceededState = 2;
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	86 const int RejectedState = 3;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	87 const int CancelledState = 4;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	88
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	89 readonly bool m_cancellable;
9 c82e0dfbb4dd sync cin parents: 7 diff changeset	90
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	91 int m_childrenCount = 0;
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	92 int m_state;
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	93 T m_result;
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	94 Exception m_error;
9 c82e0dfbb4dd sync cin parents: 7 diff changeset	95
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	96 readonly MTQueue<HandlerDescriptor> m_handlers = new MTQueue<HandlerDescriptor>();
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	97
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	98 public Promise() {
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	99 m_cancellable = true;
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	100 }
2 aa367305156b small fixes cin parents: 1 diff changeset	101
66 790e8a997d30 Refactoring cin parents: 65 diff changeset	102 public Promise(IPromise parent, bool cancellable) {
7 7ea9363fef6c inital progress handling cin parents: 6 diff changeset	103 m_cancellable = cancellable;
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	104 if (parent != null)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	105 AddHandler(
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	106 null,
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	107 null,
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	108 () => {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	109 if (parent.IsExclusive)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	110 parent.Cancel();
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	111 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	112 );
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	113 }
2 aa367305156b small fixes cin parents: 1 diff changeset	114
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	115 bool BeginTransit() {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	116 return UnresolvedSate == Interlocked.CompareExchange(ref m_state, TransitionalState, UnresolvedSate);
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	117 }
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	118
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	119 void CompleteTransit(int state) {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	120 if (TransitionalState != Interlocked.CompareExchange(ref m_state, state, TransitionalState))
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	121 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	122 }
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	123
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	124 void WaitTransition() {
9bf5b23650c9 refactoring cin parents: 19 diff changeset	125 while (m_state == TransitionalState) {
9bf5b23650c9 refactoring cin parents: 19 diff changeset	126 /* noop */
9bf5b23650c9 refactoring cin parents: 19 diff changeset	127 }
9bf5b23650c9 refactoring cin parents: 19 diff changeset	128 }
9bf5b23650c9 refactoring cin parents: 19 diff changeset	129
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	130 public bool IsResolved {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	131 get {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	132 return m_state > 1;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	133 }
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	134 }
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	135
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	136 public bool IsCancelled {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	137 get {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	138 return m_state == CancelledState;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	139 }
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	140 }
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	141
29 768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	142 public Type PromiseType {
768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	143 get { return typeof(T); }
768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	144 }
768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	145
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	146 /// <summary>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	147 /// Выполняет обещание, сообщая об успешном выполнении.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	148 /// </summary>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	149 /// <param name="result">Результат выполнения.</param>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	150 /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	151 public void Resolve(T result) {
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	152 if (BeginTransit()) {
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	153 m_result = result;
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	154 CompleteTransit(SucceededState);
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	155 OnStateChanged();
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	156 } else {
9bf5b23650c9 refactoring cin parents: 19 diff changeset	157 WaitTransition();
9bf5b23650c9 refactoring cin parents: 19 diff changeset	158 if (m_state != CancelledState)
9bf5b23650c9 refactoring cin parents: 19 diff changeset	159 throw new InvalidOperationException("The promise is already resolved");
9bf5b23650c9 refactoring cin parents: 19 diff changeset	160 }
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	161 }
2 aa367305156b small fixes cin parents: 1 diff changeset	162
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	163 /// <summary>
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	164 /// Выполняет обещание, сообщая об успешном выполнении. Результатом выполнения будет пустое значения.
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	165 /// </summary>
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	166 /// <remarks>
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	167 /// Данный вариант удобен в случаях, когда интересен факт выполнения операции, нежели полученное значение.
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	168 /// </remarks>
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	169 public void Resolve() {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	170 Resolve(default(T));
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	171 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	172
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	173 /// <summary>
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	174 /// Выполняет обещание, сообщая об ошибке
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	175 /// </summary>
16 5a4b735ba669 sync cin parents: 15 diff changeset	176 /// <remarks>
5a4b735ba669 sync cin parents: 15 diff changeset	177 /// Поскольку обещание должно работать в многопточной среде, при его выполнении сразу несколько потоков
5a4b735ba669 sync cin parents: 15 diff changeset	178 /// могу вернуть ошибку, при этом только первая будет использована в качестве результата, остальные
5a4b735ba669 sync cin parents: 15 diff changeset	179 /// будут проигнорированы.
5a4b735ba669 sync cin parents: 15 diff changeset	180 /// </remarks>
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	181 /// <param name="error">Исключение возникшее при выполнении операции</param>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	182 /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	183 public void Reject(Exception error) {
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	184 if (BeginTransit()) {
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	185 m_error = error;
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	186 CompleteTransit(RejectedState);
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	187 OnStateChanged();
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	188 } else {
9bf5b23650c9 refactoring cin parents: 19 diff changeset	189 WaitTransition();
9bf5b23650c9 refactoring cin parents: 19 diff changeset	190 if (m_state == SucceededState)
9bf5b23650c9 refactoring cin parents: 19 diff changeset	191 throw new InvalidOperationException("The promise is already resolved");
9bf5b23650c9 refactoring cin parents: 19 diff changeset	192 }
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	193 }
2 aa367305156b small fixes cin parents: 1 diff changeset	194
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	195 /// <summary>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	196 /// Отменяет операцию, если это возможно.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	197 /// </summary>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	198 /// <returns><c>true</c> Операция была отменена, обработчики не будут вызваны.<c>false</c> отмена не возможна, поскольку обещание уже выполнено и обработчики отработали.</returns>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	199 public bool Cancel() {
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	200 if (BeginTransit()) {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	201 CompleteTransit(CancelledState);
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	202 OnStateChanged();
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	203 return true;
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	204 } else {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	205 return false;
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	206 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	207 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	208
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	209 // сделано для возвращаемого типа void
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	210 protected void InternalCancel() {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	211 Cancel();
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	212 }
2 aa367305156b small fixes cin parents: 1 diff changeset	213
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	214 /// <summary>
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	215 /// Adds new handlers to this promise.
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	216 /// </summary>
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	217 /// <param name="success">The handler of the successfully completed operation.
6ec82bf68c8e refactoring cin parents: 10 diff changeset	218 /// This handler will recieve an operation result as a parameter.</param>
6ec82bf68c8e refactoring cin parents: 10 diff changeset	219 /// <param name="error">Handles an exception that may occur during the operation.</param>
6ec82bf68c8e refactoring cin parents: 10 diff changeset	220 /// <returns>The new promise chained to this one.</returns>
26 f0bf98e4d22c refactoring cin parents: 25 diff changeset	221 public IPromise<T> Then(ResultHandler<T> success, ErrorHandler error) {
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	222 if (success == null && error == null)
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	223 return this;
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	224
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	225 var medium = new Promise<T>(this, true);
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	226
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	227 ResultHandler<T> resultHandler;
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	228 if (success != null)
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	229 resultHandler = x => {
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	230 success(x);
aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	231 medium.Resolve(x);
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	232 };
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	233 else
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	234 resultHandler = medium.Resolve;
2 aa367305156b small fixes cin parents: 1 diff changeset	235
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	236 ErrorHandler errorHandler;
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	237 if (error != null)
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	238 errorHandler = x => {
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	239 // несмотря на то, что обработчик ошибки вызывается безопасно,
9bf5b23650c9 refactoring cin parents: 19 diff changeset	240 // т.е. возникшие в нем ошибки будут подавлены, нам нужно
9bf5b23650c9 refactoring cin parents: 19 diff changeset	241 // гарантировать, что ошибка будет передана дальше по цепочке обещаний
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	242 try {
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	243 error(x);
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	244 } catch { }
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	245 medium.Reject(x);
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	246 };
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	247 else
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	248 errorHandler = medium.Reject;
2 aa367305156b small fixes cin parents: 1 diff changeset	249
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	250 AddHandler(resultHandler, errorHandler, medium.InternalCancel);
2 aa367305156b small fixes cin parents: 1 diff changeset	251
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	252 return medium;
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	253 }
2 aa367305156b small fixes cin parents: 1 diff changeset	254
66 790e8a997d30 Refactoring cin parents: 65 diff changeset	255 public IPromise Then(Action success, ErrorHandler error) {
26 f0bf98e4d22c refactoring cin parents: 25 diff changeset	256 return Then(x => success(), error);
f0bf98e4d22c refactoring cin parents: 25 diff changeset	257 }
f0bf98e4d22c refactoring cin parents: 25 diff changeset	258
66 790e8a997d30 Refactoring cin parents: 65 diff changeset	259 public IPromise Then(Action success) {
32 8eca2652d2ff fixed: StackOverflow in IPromiseBase.Then(handler) cin parents: 30 diff changeset	260 return Then(x => success());
26 f0bf98e4d22c refactoring cin parents: 25 diff changeset	261 }
f0bf98e4d22c refactoring cin parents: 25 diff changeset	262
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	263 /// <summary>
6ec82bf68c8e refactoring cin parents: 10 diff changeset	264 /// Adds new handlers to this promise.
6ec82bf68c8e refactoring cin parents: 10 diff changeset	265 /// </summary>
6ec82bf68c8e refactoring cin parents: 10 diff changeset	266 /// <param name="success">The handler of the successfully completed operation.
6ec82bf68c8e refactoring cin parents: 10 diff changeset	267 /// This handler will recieve an operation result as a parameter.</param>
6ec82bf68c8e refactoring cin parents: 10 diff changeset	268 /// <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	269 /// <returns>The new promise chained to this one.</returns>
26 f0bf98e4d22c refactoring cin parents: 25 diff changeset	270 public IPromise<T> Then(ResultHandler<T> success, ErrorHandler<T> error) {
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	271 if (success == null && error == null)
6ec82bf68c8e refactoring cin parents: 10 diff changeset	272 return this;
6ec82bf68c8e refactoring cin parents: 10 diff changeset	273
6ec82bf68c8e refactoring cin parents: 10 diff changeset	274 var medium = new Promise<T>(this, true);
6ec82bf68c8e refactoring cin parents: 10 diff changeset	275
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	276 ResultHandler<T> resultHandler;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	277 ErrorHandler errorHandler;
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	278
6ec82bf68c8e refactoring cin parents: 10 diff changeset	279 if (success != null)
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	280 resultHandler = x => {
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	281 success(x);
6ec82bf68c8e refactoring cin parents: 10 diff changeset	282 medium.Resolve(x);
6ec82bf68c8e refactoring cin parents: 10 diff changeset	283 };
6ec82bf68c8e refactoring cin parents: 10 diff changeset	284 else
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	285 resultHandler = medium.Resolve;
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	286
6ec82bf68c8e refactoring cin parents: 10 diff changeset	287 if (error != null)
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	288 errorHandler = x => {
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	289 try {
6ec82bf68c8e refactoring cin parents: 10 diff changeset	290 medium.Resolve(error(x));
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	291 } catch (Exception e) {
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	292 medium.Reject(e);
9bf5b23650c9 refactoring cin parents: 19 diff changeset	293 }
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	294 };
6ec82bf68c8e refactoring cin parents: 10 diff changeset	295 else
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	296 errorHandler = medium.Reject;
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	297
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	298 AddHandler(resultHandler, errorHandler, medium.InternalCancel);
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	299
6ec82bf68c8e refactoring cin parents: 10 diff changeset	300 return medium;
6ec82bf68c8e refactoring cin parents: 10 diff changeset	301 }
6ec82bf68c8e refactoring cin parents: 10 diff changeset	302
6ec82bf68c8e refactoring cin parents: 10 diff changeset	303
26 f0bf98e4d22c refactoring cin parents: 25 diff changeset	304 public IPromise<T> Then(ResultHandler<T> success) {
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	305 if (success == null)
6ec82bf68c8e refactoring cin parents: 10 diff changeset	306 return this;
6ec82bf68c8e refactoring cin parents: 10 diff changeset	307
6ec82bf68c8e refactoring cin parents: 10 diff changeset	308 var medium = new Promise<T>(this, true);
6ec82bf68c8e refactoring cin parents: 10 diff changeset	309
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	310 ResultHandler<T> resultHandler;
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	311
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	312 if (success != null)
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	313 resultHandler = x => {
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	314 success(x);
6ec82bf68c8e refactoring cin parents: 10 diff changeset	315 medium.Resolve(x);
6ec82bf68c8e refactoring cin parents: 10 diff changeset	316 };
6ec82bf68c8e refactoring cin parents: 10 diff changeset	317 else
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	318 resultHandler = medium.Resolve;
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	319
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	320 AddHandler(resultHandler, medium.Reject, medium.InternalCancel);
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	321
6ec82bf68c8e refactoring cin parents: 10 diff changeset	322 return medium;
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	323 }
2 aa367305156b small fixes cin parents: 1 diff changeset	324
26 f0bf98e4d22c refactoring cin parents: 25 diff changeset	325 public IPromise<T> Error(ErrorHandler error) {
f0bf98e4d22c refactoring cin parents: 25 diff changeset	326 return Then((ResultHandler<T>)null, error);
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	327 }
2 aa367305156b small fixes cin parents: 1 diff changeset	328
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	329 /// <summary>
6ec82bf68c8e refactoring cin parents: 10 diff changeset	330 /// Handles error and allows to keep the promise.
6ec82bf68c8e refactoring cin parents: 10 diff changeset	331 /// </summary>
6ec82bf68c8e refactoring cin parents: 10 diff changeset	332 /// <remarks>
6ec82bf68c8e refactoring cin parents: 10 diff changeset	333 /// If the specified handler throws an exception, this exception will be used to reject the promise.
6ec82bf68c8e refactoring cin parents: 10 diff changeset	334 /// </remarks>
6ec82bf68c8e refactoring cin parents: 10 diff changeset	335 /// <param name="handler">The error handler which returns the result of the promise.</param>
6ec82bf68c8e refactoring cin parents: 10 diff changeset	336 /// <returns>New promise.</returns>
26 f0bf98e4d22c refactoring cin parents: 25 diff changeset	337 public IPromise<T> Error(ErrorHandler<T> handler) {
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	338 if (handler == null)
6ec82bf68c8e refactoring cin parents: 10 diff changeset	339 return this;
6ec82bf68c8e refactoring cin parents: 10 diff changeset	340
6ec82bf68c8e refactoring cin parents: 10 diff changeset	341 var medium = new Promise<T>(this, true);
6ec82bf68c8e refactoring cin parents: 10 diff changeset	342
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	343 AddHandler(
27 a236cd1f0477 fixes cin parents: 26 diff changeset	344 x => medium.Resolve(x),
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	345 e => {
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	346 try {
6ec82bf68c8e refactoring cin parents: 10 diff changeset	347 medium.Resolve(handler(e));
6ec82bf68c8e refactoring cin parents: 10 diff changeset	348 } catch (Exception e2) {
6ec82bf68c8e refactoring cin parents: 10 diff changeset	349 medium.Reject(e2);
6ec82bf68c8e refactoring cin parents: 10 diff changeset	350 }
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	351 },
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	352 medium.InternalCancel
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	353 );
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	354
6ec82bf68c8e refactoring cin parents: 10 diff changeset	355 return medium;
6ec82bf68c8e refactoring cin parents: 10 diff changeset	356 }
6ec82bf68c8e refactoring cin parents: 10 diff changeset	357
26 f0bf98e4d22c refactoring cin parents: 25 diff changeset	358 public IPromise<T> Anyway(Action handler) {
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	359 if (handler == null)
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	360 return this;
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	361
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	362 var medium = new Promise<T>(this,true);
2 aa367305156b small fixes cin parents: 1 diff changeset	363
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	364 AddHandler(
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	365 x => {
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	366 // to avoid handler being called multiple times we handle exception by ourselfs
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	367 try {
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	368 handler();
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	369 medium.Resolve(x);
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	370 } catch (Exception e) {
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	371 medium.Reject(e);
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	372 }
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	373 },
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	374
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	375 e => {
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	376 try {
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	377 handler();
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	378 } catch { }
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	379 medium.Reject(e);
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	380 },
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	381
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	382 medium.InternalCancel
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	383 );
2 aa367305156b small fixes cin parents: 1 diff changeset	384
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	385 return medium;
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	386 }
2 aa367305156b small fixes cin parents: 1 diff changeset	387
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	388 /// <summary>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	389 /// Позволяет преобразовать результат выполения операции к новому типу.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	390 /// </summary>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	391 /// <typeparam name="TNew">Новый тип результата.</typeparam>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	392 /// <param name="mapper">Преобразование результата к новому типу.</param>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	393 /// <param name="error">Обработчик ошибки. Данный обработчик получит
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	394 /// исключение возникшее при выполнении операции.</param>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	395 /// <returns>Новое обещание, которое будет выполнено при выполнении исходного обещания.</returns>
26 f0bf98e4d22c refactoring cin parents: 25 diff changeset	396 public IPromise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler error) {
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	397 if (mapper == null)
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	398 throw new ArgumentNullException("mapper");
2 aa367305156b small fixes cin parents: 1 diff changeset	399
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	400 // создаем прицепленное обещание
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	401 var chained = new Promise<TNew>(this,true);
2 aa367305156b small fixes cin parents: 1 diff changeset	402
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	403 ResultHandler<T> resultHandler = result => chained.Resolve(mapper(result));
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	404 ErrorHandler errorHandler = delegate(Exception e) {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	405 if (error != null)
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	406 try {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	407 error(e);
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	408 } catch { }
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	409 // в случае ошибки нужно передать исключение дальше по цепочке
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	410 chained.Reject(e);
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	411 };
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	412
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	413
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	414 AddHandler(
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	415 resultHandler,
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	416 errorHandler,
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	417 chained.InternalCancel
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	418 );
2 aa367305156b small fixes cin parents: 1 diff changeset	419
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	420 return chained;
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	421 }
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	422
26 f0bf98e4d22c refactoring cin parents: 25 diff changeset	423 public IPromise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper) {
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	424 return Map(mapper, null);
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	425 }
2 aa367305156b small fixes cin parents: 1 diff changeset	426
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	427 /// <summary>
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 /// </summary>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	432 /// <typeparam name="TNew">Тип результата указанной асинхронной операции.</typeparam>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	433 /// <param name="chained">Асинхронная операция, которая должна будет начаться после выполнения текущей.</param>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	434 /// <param name="error">Обработчик ошибки. Данный обработчик получит
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	435 /// исключение возникшее при выполнении текуещй операции.</param>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	436 /// <returns>Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции.</returns>
26 f0bf98e4d22c refactoring cin parents: 25 diff changeset	437 public IPromise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained, ErrorHandler error) {
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	438
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	439 // проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	440 // создать посредника, к которому будут подвызяваться следующие обработчики.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	441 // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	442 // передать через него результаты работы.
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	443 var medium = new Promise<TNew>(this, true);
2 aa367305156b small fixes cin parents: 1 diff changeset	444
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	445 ResultHandler<T> resultHandler = delegate(T result) {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	446 if (medium.IsCancelled)
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	447 return;
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	448
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	449 var promise = chained(result);
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	450
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	451 promise.Then(
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	452 x => medium.Resolve(x),
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	453 e => medium.Reject(e)
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	454 );
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	455
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	456 // 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	457 // порядок вызова Then, Cancelled важен, поскольку от этого
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	458 // зависит IsExclusive
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	459 medium.Cancelled(() => {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	460 if(promise.IsExclusive)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	461 promise.Cancel();
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	462 });
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	463
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	464 // внешняя отмена связанной операции рассматривается как ошибка
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	465 promise.Cancelled(() => medium.Reject(new OperationCanceledException()));
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	466 };
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	467
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	468 ErrorHandler errorHandler = delegate(Exception e) {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	469 if (error != null)
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	470 error(e);
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	471 // в случае ошибки нужно передать исключение дальше по цепочке
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	472 medium.Reject(e);
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	473 };
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	474
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	475 AddHandler(
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	476 resultHandler,
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	477 errorHandler,
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	478 medium.InternalCancel
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	479 );
2 aa367305156b small fixes cin parents: 1 diff changeset	480
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	481 return medium;
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	482 }
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	483
26 f0bf98e4d22c refactoring cin parents: 25 diff changeset	484 public IPromise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained) {
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	485 return Chain(chained, null);
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	486 }
2 aa367305156b small fixes cin parents: 1 diff changeset	487
26 f0bf98e4d22c refactoring cin parents: 25 diff changeset	488 public IPromise<T> Cancelled(Action handler) {
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	489 AddHandler(null, null, handler);
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	490 return this;
aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	491 }
aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	492
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	493 /// <summary>
9bf5b23650c9 refactoring cin parents: 19 diff changeset	494 /// Adds the specified handler for all cases (success, error, cancel)
9bf5b23650c9 refactoring cin parents: 19 diff changeset	495 /// </summary>
9bf5b23650c9 refactoring cin parents: 19 diff changeset	496 /// <param name="handler">The handler that will be called anyway</param>
9bf5b23650c9 refactoring cin parents: 19 diff changeset	497 /// <returns>self</returns>
26 f0bf98e4d22c refactoring cin parents: 25 diff changeset	498 public IPromise<T> Finally(Action handler) {
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	499 if (handler == null)
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	500 throw new ArgumentNullException("handler");
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 x => handler(),
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	503 e => handler(),
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	504 handler
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	505 );
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	506 return this;
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	507 }
aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	508
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	509 /// <summary>
29 768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	510 /// Преобразует результат обещания к нужному типу
768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	511 /// </summary>
768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	512 /// <typeparam name="T2"></typeparam>
768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	513 /// <returns></returns>
768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	514 public IPromise<T2> Cast<T2>() {
768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	515 return Map(x => (T2)(object)x, null);
768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	516 }
768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	517
768f7deeb55b Added a casting method for promises. cin parents: 28 diff changeset	518 /// <summary>
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	519 /// Дожидается отложенного обещания и в случае успеха, возвращает
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	520 /// его, результат, в противном случае бросает исключение.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	521 /// </summary>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	522 /// <remarks>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	523 /// <para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	524 /// Если ожидание обещания было прервано по таймауту, это не значит,
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	525 /// что обещание было отменено или что-то в этом роде, это только
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	526 /// означает, что мы его не дождались, однако все зарегистрированные
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	527 /// обработчики, как были так остались и они будут вызваны, когда
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	528 /// обещание будет выполнено.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	529 /// </para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	530 /// <para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	531 /// Такое поведение вполне оправдано поскольку таймаут может истечь
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	532 /// в тот момент, когда началась обработка цепочки обработчиков, и
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	533 /// к тому же текущее обещание может стоять в цепочке обещаний и его
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	534 /// отклонение может привести к непрогнозируемому результату.
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	535 /// </para>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	536 /// </remarks>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	537 /// <param name="timeout">Время ожидания</param>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	538 /// <returns>Результат выполнения обещания</returns>
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	539 public T Join(int timeout) {
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	540 var evt = new ManualResetEvent(false);
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	541 Anyway(() => evt.Set());
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	542 Cancelled(() => evt.Set());
2 aa367305156b small fixes cin parents: 1 diff changeset	543
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	544 if (!evt.WaitOne(timeout, true))
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	545 throw new TimeoutException();
2 aa367305156b small fixes cin parents: 1 diff changeset	546
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	547 switch (m_state) {
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	548 case SucceededState:
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	549 return m_result;
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	550 case CancelledState:
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	551 throw new OperationCanceledException();
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	552 case RejectedState:
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	553 throw new TargetInvocationException(m_error);
aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	554 default:
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	555 throw new ApplicationException(String.Format("Invalid promise state {0}", m_state));
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	556 }
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	557 }
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	558
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	559 public T Join() {
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	560 return Join(Timeout.Infinite);
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	561 }
2 aa367305156b small fixes cin parents: 1 diff changeset	562
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	563 void AddHandler(ResultHandler<T> success, ErrorHandler error, Action cancel) {
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	564 if (success != null \|\| error != null)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	565 Interlocked.Increment(ref m_childrenCount);
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	566
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	567 HandlerDescriptor handler = new HandlerDescriptor {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	568 resultHandler = success,
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	569 errorHandler = error,
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	570 cancellHandler = cancel
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	571 };
2 aa367305156b small fixes cin parents: 1 diff changeset	572
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	573 bool queued;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	574
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	575 if (!IsResolved) {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	576 m_handlers.Enqueue(handler);
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	577 queued = true;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	578 } else {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	579 // 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	580 queued = false;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	581 InvokeHandler(handler);
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	582 }
2 aa367305156b small fixes cin parents: 1 diff changeset	583
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	584 if (queued && IsResolved && m_handlers.TryDequeue(out handler))
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	585 // 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	586 // 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	587 // therefore we will fetch a handler from the queue and execute it
27 a236cd1f0477 fixes cin parents: 26 diff changeset	588 // note that fetched handler may be not the one that we have added
a236cd1f0477 fixes cin parents: 26 diff changeset	589 // even we can fetch no handlers at all :)
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	590 InvokeHandler(handler);
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	591 }
2 aa367305156b small fixes cin parents: 1 diff changeset	592
27 a236cd1f0477 fixes cin parents: 26 diff changeset	593 protected virtual void InvokeHandler(HandlerDescriptor handler) {
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	594 switch (m_state) {
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	595 case SucceededState:
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	596 handler.Resolve(m_result);
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	597 break;
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	598 case RejectedState:
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	599 handler.Reject(m_error);
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	600 break;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	601 case CancelledState:
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	602 handler.Cancel();
10 aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	603 break;
aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	604 default:
aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	605 // do nothing
aa33d0bb8c0c implemeted new cancellable promises concept cin parents: 9 diff changeset	606 return;
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	607 }
dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	608 }
2 aa367305156b small fixes cin parents: 1 diff changeset	609
65 653c4e04968b minor changes cin parents: 33 diff changeset	610 void OnStateChanged() {
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	611 HandlerDescriptor handler;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	612 while (m_handlers.TryDequeue(out handler))
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	613 InvokeHandler(handler);
11 6ec82bf68c8e refactoring cin parents: 10 diff changeset	614 }
6ec82bf68c8e refactoring cin parents: 10 diff changeset	615
9 c82e0dfbb4dd sync cin parents: 7 diff changeset	616 public bool IsExclusive {
c82e0dfbb4dd sync cin parents: 7 diff changeset	617 get {
19 e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks cin parents: 16 diff changeset	618 return m_childrenCount <= 1;
9 c82e0dfbb4dd sync cin parents: 7 diff changeset	619 }
c82e0dfbb4dd sync cin parents: 7 diff changeset	620 }
c82e0dfbb4dd sync cin parents: 7 diff changeset	621
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	622 /// <summary>
9bf5b23650c9 refactoring cin parents: 19 diff changeset	623 /// Объединяет несколько обещаний в одно, результатом которого является массив результатов других обещаний.
9bf5b23650c9 refactoring cin parents: 19 diff changeset	624 /// Если хотябы одно из переданных обещаний не будет выполнено, то новое обещение тоже не будет выполнено.
9bf5b23650c9 refactoring cin parents: 19 diff changeset	625 /// При отмене нового обещания, переданные обещания также будут отменены, если никто больше на них не подписан.
9bf5b23650c9 refactoring cin parents: 19 diff changeset	626 /// </summary>
9bf5b23650c9 refactoring cin parents: 19 diff changeset	627 /// <param name="promises">Список обещаний. Если список пустой, то результирующее обещание возвращается уже выполненным.</param>
9bf5b23650c9 refactoring cin parents: 19 diff changeset	628 /// <returns>Обещание объединяющее в себе результат переданных обещаний.</returns>
9bf5b23650c9 refactoring cin parents: 19 diff changeset	629 /// <exception cref="ArgumentNullException"><paramref name="promises"/> не может быть null</exception>
30 2fad2d1f4b03 small refactoring, cleanup. cin parents: 29 diff changeset	630 public static IPromise<T[]> CreateComposite(IList<IPromise<T>> promises) {
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	631 if (promises == null)
9bf5b23650c9 refactoring cin parents: 19 diff changeset	632 throw new ArgumentNullException();
9bf5b23650c9 refactoring cin parents: 19 diff changeset	633
9bf5b23650c9 refactoring cin parents: 19 diff changeset	634 // создаем аккумулятор для результатов и результирующее обещание
9bf5b23650c9 refactoring cin parents: 19 diff changeset	635 var result = new T[promises.Count];
9bf5b23650c9 refactoring cin parents: 19 diff changeset	636 var promise = new Promise<T[]>();
9bf5b23650c9 refactoring cin parents: 19 diff changeset	637
9bf5b23650c9 refactoring cin parents: 19 diff changeset	638 // special case
9bf5b23650c9 refactoring cin parents: 19 diff changeset	639 if (promises.Count == 0) {
9bf5b23650c9 refactoring cin parents: 19 diff changeset	640 promise.Resolve(result);
9bf5b23650c9 refactoring cin parents: 19 diff changeset	641 return promise;
9bf5b23650c9 refactoring cin parents: 19 diff changeset	642 }
9bf5b23650c9 refactoring cin parents: 19 diff changeset	643
9bf5b23650c9 refactoring cin parents: 19 diff changeset	644 int pending = promises.Count;
9bf5b23650c9 refactoring cin parents: 19 diff changeset	645
9bf5b23650c9 refactoring cin parents: 19 diff changeset	646 for (int i = 0; i < promises.Count; i++) {
9bf5b23650c9 refactoring cin parents: 19 diff changeset	647 var dest = i;
9bf5b23650c9 refactoring cin parents: 19 diff changeset	648
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	649 if (promises[i] != null) {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	650 promises[i].Then(
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	651 x => {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	652 result[dest] = x;
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	653 if (Interlocked.Decrement(ref pending) == 0)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	654 promise.Resolve(result);
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	655 },
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	656 e => promise.Reject(e)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	657 );
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	658 } else {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	659 if (Interlocked.Decrement(ref pending) == 0)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	660 promise.Resolve(result);
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	661 }
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	662 }
9bf5b23650c9 refactoring cin parents: 19 diff changeset	663
9bf5b23650c9 refactoring cin parents: 19 diff changeset	664 promise.Cancelled(
9bf5b23650c9 refactoring cin parents: 19 diff changeset	665 () => {
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	666 foreach (var d in promises)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	667 if (d != null && d.IsExclusive)
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	668 d.Cancel();
9bf5b23650c9 refactoring cin parents: 19 diff changeset	669 }
9bf5b23650c9 refactoring cin parents: 19 diff changeset	670 );
9bf5b23650c9 refactoring cin parents: 19 diff changeset	671
9bf5b23650c9 refactoring cin parents: 19 diff changeset	672 return promise;
9bf5b23650c9 refactoring cin parents: 19 diff changeset	673 }
9bf5b23650c9 refactoring cin parents: 19 diff changeset	674
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	675 /// <summary>
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	676 /// Объединяет несколько обещаний в одно. Результирующее обещание будет выполнено при
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	677 /// выполнении всех указанных обещаний. При этом возвращаемые значения первичных обещаний
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	678 /// игнорируются.
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	679 /// </summary>
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	680 /// <param name="promises">Коллекция первичных обещаний, которые будут объеденены в одно.</param>
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	681 /// <returns>Новое обещание, объединяющее в себе переданные.</returns>
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	682 /// <remarks>
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	683 /// Если в коллекции встречаюься <c>null</c>, то они воспринимаются как выполненные обещания.
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	684 /// </remarks>
66 790e8a997d30 Refactoring cin parents: 65 diff changeset	685 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	686 if (promises == null)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	687 throw new ArgumentNullException();
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	688 if (promises.Count == 0)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	689 return Promise<object>.ResultToPromise(null);
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	690
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	691 int countdown = promises.Count;
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	692
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	693 var result = new Promise<object>();
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	694
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	695 foreach (var d in promises) {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	696 if (d == null) {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	697 if (Interlocked.Decrement(ref countdown) == 0)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	698 result.Resolve(null);
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	699 } else {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	700 d.Then(() => {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	701 if (Interlocked.Decrement(ref countdown) == 0)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	702 result.Resolve(null);
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	703 });
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	704 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	705 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	706
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	707 result.Cancelled(() => {
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	708 foreach (var d in promises)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	709 if (d != null && d.IsExclusive)
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	710 d.Cancel();
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	711 });
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	712
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	713 return result;
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	714 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	715
25 9bf5b23650c9 refactoring cin parents: 19 diff changeset	716 public static Promise<T> ResultToPromise(T result) {
9bf5b23650c9 refactoring cin parents: 19 diff changeset	717 var p = new Promise<T>();
9bf5b23650c9 refactoring cin parents: 19 diff changeset	718 p.Resolve(result);
9bf5b23650c9 refactoring cin parents: 19 diff changeset	719 return p;
9bf5b23650c9 refactoring cin parents: 19 diff changeset	720 }
9bf5b23650c9 refactoring cin parents: 19 diff changeset	721
9bf5b23650c9 refactoring cin parents: 19 diff changeset	722 public static Promise<T> ExceptionToPromise(Exception error) {
9bf5b23650c9 refactoring cin parents: 19 diff changeset	723 if (error == null)
9bf5b23650c9 refactoring cin parents: 19 diff changeset	724 throw new ArgumentNullException();
9bf5b23650c9 refactoring cin parents: 19 diff changeset	725
9bf5b23650c9 refactoring cin parents: 19 diff changeset	726 var p = new Promise<T>();
9bf5b23650c9 refactoring cin parents: 19 diff changeset	727 p.Reject(error);
9bf5b23650c9 refactoring cin parents: 19 diff changeset	728 return p;
9bf5b23650c9 refactoring cin parents: 19 diff changeset	729 }
9bf5b23650c9 refactoring cin parents: 19 diff changeset	730
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	731 #region IPromiseBase explicit implementation
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	732
66 790e8a997d30 Refactoring cin parents: 65 diff changeset	733 IPromise IPromise.Error(ErrorHandler error) {
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	734 return Error(error);
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	735 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	736
66 790e8a997d30 Refactoring cin parents: 65 diff changeset	737 IPromise IPromise.Anyway(Action handler) {
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	738 return Anyway(handler);
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	739 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	740
66 790e8a997d30 Refactoring cin parents: 65 diff changeset	741 IPromise IPromise.Finally(Action handler) {
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	742 return Finally(handler);
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	743 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	744
66 790e8a997d30 Refactoring cin parents: 65 diff changeset	745 IPromise IPromise.Cancelled(Action handler) {
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	746 return Cancelled(handler);
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
66 790e8a997d30 Refactoring cin parents: 65 diff changeset	749 void IPromise.Join() {
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	750 Join();
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	751 }
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	752
66 790e8a997d30 Refactoring cin parents: 65 diff changeset	753 void IPromise.Join(int timeout) {
33 b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	754 Join(timeout);
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 #endregion
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
b255e4aeef17 removed the reference to the parent from the promise object this allows cin parents: 32 diff changeset	760
6 dfa21d507bc5 refactoring: Promise.Then now returns a new chained promise cin* parents: 2 diff changeset	761 }
2 aa367305156b small fixes cin parents: 1 diff changeset	762 }

Mercurial > pub > ImplabNet

annotate Implab/Promise.cs @ 66:790e8a997d30