Mercurial > pub > ImplabNet

annotate Implab/Promise.cs @ 97:b11c7e9d93bc v2

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