##// END OF EJS Templates
implab » ImplabNet
RSS
*refactoring: Promise.Then now returns a new chained promise...
cin -
r6:dfa21d507bc5 default
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,97 +1,97
1 1 using System;
2 2 using System.Collections.Generic;
3 3 using System.Linq;
4 4 using System.Text;
5 5 using System.Timers;
6 6 using System.ComponentModel;
7 7 using System.Diagnostics;
8 8
9 9 namespace Implab.Fx
10 10 {
11 11 public delegate void AnimationStep<T>(T target, int elapsed, int duration);
12 12
13 13 public class Animation<TArg> where TArg: class
14 14 {
15 15 int m_duration;
16 16 int m_delay;
17 17 int m_elapsed;
18 18 int m_prevTicks;
19 19 TArg m_arg;
20 20 ISynchronizeInvoke m_syncronizationObject;
21 21
22 22 public event AnimationStep<TArg> Step;
23 23
24 24 Promise<TArg> m_promise;
25 25
26 26 public Animation(TArg target, int duration, int delay)
27 27 {
28 28 if (duration <= 0)
29 29 throw new ArgumentOutOfRangeException("duration");
30 30 if (delay <= 0)
31 31 throw new ArgumentOutOfRangeException("delay");
32 32
33 33 m_arg = target;
34 34 m_syncronizationObject = target as ISynchronizeInvoke;
35 35 m_duration = duration;
36 36 m_delay = delay;
37 37 m_promise = new Promise<TArg>();
38 38 }
39 39
40 40 public Animation(TArg target)
41 41 : this(target, 500, 30)
42 42 {
43 43 }
44 44
45 45 public TArg Traget
46 46 {
47 47 get { return m_arg; }
48 48 }
49 49
50 50 public Promise<TArg> Play()
51 51 {
52 52 var timer = new Timer(m_delay);
53 53
54 timer.AutoReset = true;
54 timer.AutoReset = false;
55 55 timer.SynchronizingObject = m_syncronizationObject;
56 56 timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);
57 57
58 58 m_prevTicks = Environment.TickCount;
59 59
60 60 timer.Start();
61 61
62 62 return m_promise;
63 63 }
64 64
65 65 void timer_Elapsed(object sender, ElapsedEventArgs args)
66 66 {
67 67 var timer = sender as Timer;
68 68
69 69 var dt = Environment.TickCount - m_prevTicks;
70 70 m_prevTicks = Environment.TickCount;
71 71
72 72 m_elapsed += dt;
73 73
74 74 if (m_elapsed > m_duration)
75 75 m_elapsed = m_duration;
76 76
77 77 try
78 78 {
79 79 var handler = Step;
80 80 if (handler != null)
81 81 handler(m_arg, m_elapsed, m_duration);
82 82 }
83 83 catch (Exception e)
84 84 {
85 85 Trace.TraceError(e.ToString());
86 86 }
87 87
88 88 if (m_elapsed < m_duration)
89 89 timer.Start();
90 90 else
91 91 {
92 92 timer.Dispose();
93 93 m_promise.Resolve(m_arg);
94 94 }
95 95 }
96 96 }
97 97 }
Show file before | Show file after | Hide comments
1 NO CONTENT: modified file, binary diff hidden
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (656 lines changed) Show them Hide them
@@ -1,355 +1,397
1 1 using System;
2 2 using System.Collections.Generic;
3 3 using System.Linq;
4 4 using System.Reflection;
5 5 using System.Text;
6 6 using System.Diagnostics;
7 7 using System.Threading;
8 8
9 9 namespace Implab {
10 10
11 public delegate void ErrorHandler(Exception e);
11 public delegate void ErrorHandler(Exception e);
12
13 public delegate void ResultHandler<T>(T result);
14 public delegate TNew ResultMapper<TSrc, TNew>(TSrc result);
15 public delegate Promise<TNew> ChainedOperation<TSrc, TNew>(TSrc result);
12 16
13 public delegate void ResultHandler<T>(T result);
14 public delegate TNew ResultMapper<TSrc,TNew>(TSrc result);
15 public delegate Promise<TNew> ChainedOperation<TSrc,TNew>(TSrc result);
17 /// <summary>
18 /// Класс для асинхронного получения результатов. Так называемое "обещание".
19 /// </summary>
20 /// <typeparam name="T">Тип получаемого результата</typeparam>
21 /// <remarks>
22 /// <para>Сервис при обращении к его методу дает обещаиние о выполнении операции,
23 /// клиент получив такое обещание может установить ряд обратных вызово для получения
24 /// событий выполнения обещания, тоесть завершения операции и предоставлении результатов.</para>
25 /// <para>
26 /// Обещение может быть как выполнено, так и выполнено с ошибкой. Для подписки на
27 /// данные события клиент должен использовать методы <c>Then</c>.
28 /// </para>
29 /// <para>
30 /// Сервис, в свою очередь, по окончанию выполнения операции (возможно с ошибкой),
31 /// использует методы <c>Resolve</c> либо <c>Reject</c> для оповещения клиетна о
32 /// выполнении обещания.
33 /// </para>
34 /// <para>
35 /// Если сервер успел выполнить обещание еще до того, как клиент на него подписался,
36 /// то в момент подписки клиента будут вызваны соответсвующие события в синхронном
37 /// режиме и клиент будет оповещен в любом случае. Иначе, обработчики добавляются в
38 /// список в порядке подписания и в этом же порядке они будут вызваны при выполнении
39 /// обещания.
40 /// </para>
41 /// <para>
42 /// Обрабатывая результаты обещания можно преобразовывать результаты либо инициировать
43 /// связанные асинхронные операции, которые также возвращают обещания. Для этого следует
44 /// использовать соответствующую форму методе <c>Then</c>.
45 /// </para>
46 /// <para>
47 /// Также хорошим правилом является то, что <c>Resolve</c> и <c>Reject</c> должен вызывать
48 /// только инициатор обещания иначе могут возникнуть противоречия.
49 /// </para>
50 /// </remarks>
51 public class Promise<T> {
16 52
17 /// <summary>
18 /// Класс для асинхронного получения результатов. Так называемое "обещание".
19 /// </summary>
20 /// <typeparam name="T">Тип получаемого результата</typeparam>
21 /// <remarks>
22 /// <para>Сервис при обращении к его методу дает обещаиние о выполнении операции,
23 /// клиент получив такое обещание может установить ряд обратных вызово для получения
24 /// событий выполнения обещания, тоесть завершения операции и предоставлении результатов.</para>
25 /// <para>
26 /// Обещение может быть как выполнено, так и выполнено с ошибкой. Для подписки на
27 /// данные события клиент должен использовать методы <c>Then</c>.
28 /// </para>
29 /// <para>
30 /// Сервис, в свою очередь, по окончанию выполнения операции (возможно с ошибкой),
31 /// использует методы <c>Resolve</c> либо <c>Reject</c> для оповещения клиетна о
32 /// выполнении обещания.
33 /// </para>
34 /// <para>
35 /// Если сервер успел выполнить обещание еще до того, как клиент на него подписался,
36 /// то в момент подписки клиента будут вызваны соответсвующие события в синхронном
37 /// режиме и клиент будет оповещен в любом случае. Иначе, обработчики добавляются в
38 /// список в порядке подписания и в этом же порядке они будут вызваны при выполнении
39 /// обещания.
40 /// </para>
41 /// <para>
42 /// Обрабатывая результаты обещания можно преобразовывать результаты либо инициировать
43 /// связанные асинхронные операции, которые также возвращают обещания. Для этого следует
44 /// использовать соответствующую форму методе <c>Then</c>.
45 /// </para>
46 /// <para>
47 /// Также хорошим правилом является то, что <c>Resolve</c> и <c>Reject</c> должен вызывать
48 /// только инициатор обещания иначе могут возникнуть противоречия.
49 /// </para>
50 /// </remarks>
51 public class Promise<T> {
53 struct ResultHandlerInfo {
54 public ResultHandler<T> resultHandler;
55 public ErrorHandler errorHandler;
56 }
57
58 enum State {
59 Unresolved,
60 Resolving,
61 Resolved,
62 Cancelled
63 }
64
65 LinkedList<ResultHandlerInfo> m_handlersChain = new LinkedList<ResultHandlerInfo>();
66 State m_state;
67 bool m_cancellable;
68 T m_result;
69 Exception m_error;
70
71 public Promise() {
72 m_cancellable = true;
73 }
52 74
53 struct ResultHandlerInfo {
54 public ResultHandler<T> resultHandler;
55 public ErrorHandler errorHandler;
56 }
57
58 enum State {
59 Unresolved,
60 Resolving,
61 Resolved,
62 Cancelled
63 }
75 /// <summary>
76 /// Событие, возникающее при отмене асинхронной операции.
77 /// </summary>
78 /// <description>
79 /// Как правило используется для оповещения объекта, выполняющего асинхронную операцию, о том, что ее следует отменить.
80 /// </description>
81 public event EventHandler Cancelled;
64 82
65 LinkedList<ResultHandlerInfo> m_handlersChain = new LinkedList<ResultHandlerInfo>();
66 State m_state;
67 bool m_cancellable;
68 T m_result;
69 Exception m_error;
83 /// <summary>
84 /// Выполняет обещание, сообщая об успешном выполнении.
85 /// </summary>
86 /// <param name="result">Результат выполнения.</param>
87 /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
88 public void Resolve(T result) {
89 lock (this) {
90 if (m_state == State.Cancelled)
91 return;
92 if (m_state != State.Unresolved)
93 throw new InvalidOperationException("The promise is already resolved");
94 m_result = result;
95 m_state = State.Resolving;
96 }
70 97
71 public Promise() {
72 m_cancellable = true;
73 }
74
75 /// <summary>
76 /// Событие, возникающее при отмене асинхронной операции.
77 /// </summary>
78 /// <description>
79 /// Как правило используется для оповещения объекта, выполняющего асинхронную операцию, о том, что ее следует отменить.
80 /// </description>
81 public event EventHandler Cancelled;
98 ResultHandlerInfo handler;
99 while (FetchNextHandler(out handler))
100 InvokeHandler(handler);
101 }
82 102
83 /// <summary>
84 /// Выполняет обещание, сообщая об успешном выполнении.
85 /// </summary>
86 /// <param name="result">Результат выполнения.</param>
87 /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
88 public void Resolve(T result) {
89 lock (this) {
90 if (m_state == State.Cancelled)
91 return;
92 if (m_state != State.Unresolved)
93 throw new InvalidOperationException("The promise is already resolved");
94 m_result = result;
95 m_state = State.Resolving;
96 }
97
98 ResultHandlerInfo handler;
99 while (FetchNextHandler(out handler))
100 InvokeHandler(handler);
101 }
103 /// <summary>
104 /// Выполняет обещание, сообщая об ошибке
105 /// </summary>
106 /// <param name="error">Исключение возникшее при выполнении операции</param>
107 /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
108 public void Reject(Exception error) {
109 lock (this) {
110 if (m_state == State.Cancelled)
111 return;
112 if (m_state != State.Unresolved)
113 throw new InvalidOperationException("The promise is already resolved");
114 m_error = error;
115 m_state = State.Resolving;
116 }
102 117
103 /// <summary>
104 /// Выполняет обещание, сообщая об ошибке
105 /// </summary>
106 /// <param name="error">Исключение возникшее при выполнении операции</param>
107 /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
108 public void Reject(Exception error) {
109 lock (this) {
110 if (m_state == State.Cancelled)
111 return;
112 if (m_state != State.Unresolved)
113 throw new InvalidOperationException("The promise is already resolved");
114 m_error = error;
115 m_state = State.Resolving;
116 }
118 ResultHandlerInfo handler;
119 while (FetchNextHandler(out handler))
120 InvokeHandler(handler);
121 }
117 122
118 ResultHandlerInfo handler;
119 while (FetchNextHandler(out handler))
120 InvokeHandler(handler);
121 }
123 /// <summary>
124 /// Отменяет операцию, если это возможно.
125 /// </summary>
126 /// <returns><c>true</c> Операция была отменена, обработчики не будут вызваны.<c>false</c> отмена не возможна, поскольку обещание уже выполнено и обработчики отработали.</returns>
127 public bool Cancel() {
128 lock (this) {
129 if (m_state == State.Unresolved && m_cancellable) {
130 m_state = State.Cancelled;
131 EventHandler temp = Cancelled;
132
133 if (temp != null)
134 temp(this, new EventArgs());
135
136 return true;
137 } else
138 return false;
139 }
140 }
122 141
123 /// <summary>
124 /// Отменяет операцию, если это возможно.
125 /// </summary>
126 /// <returns><c>true</c> Операция была отменена, обработчики не будут вызваны.<c>false</c> отмена не возможна, поскольку обещание уже выполнено и обработчики отработали.</returns>
127 public bool Cancel() {
128 lock(this) {
129 if (m_state == State.Unresolved && m_cancellable) {
130 m_state = State.Cancelled;
131 EventHandler temp = Cancelled;
132
133 if (temp != null)
134 temp(this,new EventArgs());
135
136 return true;
137 } else
138 return false;
139 }
140 }
142 /// <summary>
143 /// Добавляет обработчики событий выполнения обещания.
144 /// </summary>
145 /// <param name="success">Обработчик успешного выполнения обещания.
146 /// Данному обработчику будет передан результат выполнения операции.</param>
147 /// <param name="error">Обработчик ошибки. Данный обработчик получит
148 /// исключение возникшее при выполнении операции.</param>
149 /// <returns>Само обещание</returns>
150 public Promise<T> Then(ResultHandler<T> success, ErrorHandler error) {
151 if (success == null && error == null)
152 return this;
153
154 var medium = new Promise<T>();
155
156 var handlerInfo = new ResultHandlerInfo();
157
158 if (success != null)
159 handlerInfo.resultHandler = x => {
160 try {
161 success(x);
162 medium.Resolve(x);
163 } catch (Exception e) {
164 medium.Reject(e);
165 }
166 };
167 else
168 handlerInfo.resultHandler = x => medium.Resolve(x);
141 169
142 /// <summary>
143 /// Добавляет обработчики событий выполнения обещания.
144 /// </summary>
145 /// <param name="success">Обработчик успешного выполнения обещания.
146 /// Данному обработчику будет передан результат выполнения операции.</param>
147 /// <param name="error">Обработчик ошибки. Данный обработчик получит
148 /// исключение возникшее при выполнении операции.</param>
149 /// <returns>Само обещание</returns>
150 public Promise<T> Then(ResultHandler<T> success, ErrorHandler error) {
151 if (success == null && error == null)
152 return this;
170 if (error != null)
171 handlerInfo.errorHandler = x => {
172 try {
173 error(x);
174 } catch { }
175 medium.Reject(x);
176 };
177 else
178 handlerInfo.errorHandler = x => medium.Reject(x);
153 179
154 AddHandler(new ResultHandlerInfo() {
155 resultHandler = success,
156 errorHandler = error
157 });
180 AddHandler(handlerInfo);
158 181
159 return this;
160 }
182 return medium;
183 }
161 184
162 public Promise<T> Then(ResultHandler<T> success) {
163 return Then (success, null);
164 }
185 public Promise<T> Then(ResultHandler<T> success) {
186 return Then(success, null);
187 }
165 188
166 public Promise<T> Anyway(Action handler) {
167 if (handler == null)
168 return this;
169 AddHandler(new ResultHandlerInfo {
170 resultHandler = x => handler(),
171 errorHandler = x => handler()
172 });
189 public Promise<T> Error(ErrorHandler error) {
190 return Then(null, error);
191 }
173 192
174 return this;
175 }
193 public Promise<T> Anyway(Action handler) {
194 if (handler == null)
195 return this;
196
197 var medium = new Promise<T>();
176 198
177 /// <summary>
178 /// Позволяет преобразовать результат выполения операции к новому типу.
179 /// </summary>
180 /// <typeparam name="TNew">Новый тип результата.</typeparam>
181 /// <param name="mapper">Преобразование результата к новому типу.</param>
182 /// <param name="error">Обработчик ошибки. Данный обработчик получит
183 /// исключение возникшее при выполнении операции.</param>
184 /// <returns>Новое обещание, которое будет выполнено при выполнении исходного обещания.</returns>
185 public Promise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler error) {
186 if (mapper == null)
187 throw new ArgumentNullException("mapper");
188
189 // создаем прицепленное обещание
190 Promise<TNew> chained = new Promise<TNew>();
199 AddHandler(new ResultHandlerInfo {
200 resultHandler = x => {
201 try {
202 handler();
203 medium.Resolve(x);
204 } catch (Exception e) {
205 medium.Reject(e);
206 }
207 },
208 errorHandler = x => {
209 try {
210 handler();
211 } catch { }
212 medium.Reject(x);
213 }
214 });
191 215
192 AddHandler(new ResultHandlerInfo() {
193 resultHandler = delegate(T result) {
194 try {
195 // если преобразование выдаст исключение, то сработает reject сцепленного deferred
196 chained.Resolve(mapper(result));
197 } catch (Exception e) {
198 chained.Reject(e);
199 }
200 },
201 errorHandler = delegate(Exception e) {
202 if (error != null)
203 error(e);
204 // в случае ошибки нужно передать исключение дальше по цепочке
205 chained.Reject(e);
206 }
207 });
216 return medium;
217 }
208 218
209 return chained;
210 }
219 /// <summary>
220 /// Позволяет преобразовать результат выполения операции к новому типу.
221 /// </summary>
222 /// <typeparam name="TNew">Новый тип результата.</typeparam>
223 /// <param name="mapper">Преобразование результата к новому типу.</param>
224 /// <param name="error">Обработчик ошибки. Данный обработчик получит
225 /// исключение возникшее при выполнении операции.</param>
226 /// <returns>Новое обещание, которое будет выполнено при выполнении исходного обещания.</returns>
227 public Promise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler error) {
228 if (mapper == null)
229 throw new ArgumentNullException("mapper");
211 230
212 public Promise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper) {
213 return Map (mapper, null);
214 }
231 // создаем прицепленное обещание
232 Promise<TNew> chained = new Promise<TNew>();
215 233
216 /// <summary>
217 /// Сцепляет несколько аснхронных операций. Указанная асинхронная операция будет вызвана после
218 /// выполнения текущей, а результат текущей операции может быть использован для инициализации
219 /// новой операции.
220 /// </summary>
221 /// <typeparam name="TNew">Тип результата указанной асинхронной операции.</typeparam>
222 /// <param name="chained">Асинхронная операция, которая должна будет начаться после выполнения текущей.</param>
223 /// <param name="error">Обработчик ошибки. Данный обработчик получит
224 /// исключение возникшее при выполнении текуещй операции.</param>
225 /// <returns>Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции.</returns>
226 public Promise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained, ErrorHandler error) {
234 AddHandler(new ResultHandlerInfo() {
235 resultHandler = delegate(T result) {
236 try {
237 // если преобразование выдаст исключение, то сработает reject сцепленного deferred
238 chained.Resolve(mapper(result));
239 } catch (Exception e) {
240 chained.Reject(e);
241 }
242 },
243 errorHandler = delegate(Exception e) {
244 if (error != null)
245 error(e);
246 // в случае ошибки нужно передать исключение дальше по цепочке
247 chained.Reject(e);
248 }
249 });
227 250
228 // проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно
229 // создать посредника, к которому будут подвызяваться следующие обработчики.
230 // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы
231 // передать через него результаты работы.
232 Promise<TNew> medium = new Promise<TNew>();
251 return chained;
252 }
253
254 public Promise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper) {
255 return Map(mapper, null);
256 }
233 257
234 AddHandler(new ResultHandlerInfo() {
235 resultHandler = delegate(T result) {
236 try {
237 chained(result).Then(
238 x => medium.Resolve(x),
239 e => medium.Reject(e)
240 );
241 } catch(Exception e) {
242 // если сцепленное действие выдало исключение вместо обещания, то передаем ошибку по цепочке
243 medium.Reject(e);
244 }
245 },
246 errorHandler = delegate(Exception e) {
247 if (error != null)
248 error(e);
249 // в случае ошибки нужно передать исключение дальше по цепочке
250 medium.Reject(e);
251 }
252 });
258 /// <summary>
259 /// Сцепляет несколько аснхронных операций. Указанная асинхронная операция будет вызвана после
260 /// выполнения текущей, а результат текущей операции может быть использован для инициализации
261 /// новой операции.
262 /// </summary>
263 /// <typeparam name="TNew">Тип результата указанной асинхронной операции.</typeparam>
264 /// <param name="chained">Асинхронная операция, которая должна будет начаться после выполнения текущей.</param>
265 /// <param name="error">Обработчик ошибки. Данный обработчик получит
266 /// исключение возникшее при выполнении текуещй операции.</param>
267 /// <returns>Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции.</returns>
268 public Promise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained, ErrorHandler error) {
269
270 // проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно
271 // создать посредника, к которому будут подвызяваться следующие обработчики.
272 // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы
273 // передать через него результаты работы.
274 Promise<TNew> medium = new Promise<TNew>();
253 275
254 return medium;
255 }
256
257 public Promise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained) {
258 return Chain (chained, null);
259 }
276 AddHandler(new ResultHandlerInfo() {
277 resultHandler = delegate(T result) {
278 try {
279 chained(result).Then(
280 x => medium.Resolve(x),
281 e => medium.Reject(e)
282 );
283 } catch (Exception e) {
284 // если сцепленное действие выдало исключение вместо обещания, то передаем ошибку по цепочке
285 medium.Reject(e);
286 }
287 },
288 errorHandler = delegate(Exception e) {
289 if (error != null)
290 error(e);
291 // в случае ошибки нужно передать исключение дальше по цепочке
292 medium.Reject(e);
293 }
294 });
260 295
261 /// <summary>
262 /// Дожидается отложенного обещания и в случае успеха, возвращает
263 /// его, результат, в противном случае бросает исключение.
264 /// </summary>
265 /// <remarks>
266 /// <para>
267 /// Если ожидание обещания было прервано по таймауту, это не значит,
268 /// что обещание было отменено или что-то в этом роде, это только
269 /// означает, что мы его не дождались, однако все зарегистрированные
270 /// обработчики, как были так остались и они будут вызваны, когда
271 /// обещание будет выполнено.
272 /// </para>
273 /// <para>
274 /// Такое поведение вполне оправдано поскольку таймаут может истечь
275 /// в тот момент, когда началась обработка цепочки обработчиков, и
276 /// к тому же текущее обещание может стоять в цепочке обещаний и его
277 /// отклонение может привести к непрогнозируемому результату.
278 /// </para>
279 /// </remarks>
280 /// <param name="timeout">Время ожидания</param>
281 /// <returns>Результат выполнения обещания</returns>
282 public T Join(int timeout) {
283 ManualResetEvent evt = new ManualResetEvent(false);
284 Anyway(() => evt.Set());
296 return medium;
297 }
298
299 public Promise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained) {
300 return Chain(chained, null);
301 }
285 302
286 if (!evt.WaitOne(timeout, true))
287 throw new TimeoutException();
303 /// <summary>
304 /// Дожидается отложенного обещания и в случае успеха, возвращает
305 /// его, результат, в противном случае бросает исключение.
306 /// </summary>
307 /// <remarks>
308 /// <para>
309 /// Если ожидание обещания было прервано по таймауту, это не значит,
310 /// что обещание было отменено или что-то в этом роде, это только
311 /// означает, что мы его не дождались, однако все зарегистрированные
312 /// обработчики, как были так остались и они будут вызваны, когда
313 /// обещание будет выполнено.
314 /// </para>
315 /// <para>
316 /// Такое поведение вполне оправдано поскольку таймаут может истечь
317 /// в тот момент, когда началась обработка цепочки обработчиков, и
318 /// к тому же текущее обещание может стоять в цепочке обещаний и его
319 /// отклонение может привести к непрогнозируемому результату.
320 /// </para>
321 /// </remarks>
322 /// <param name="timeout">Время ожидания</param>
323 /// <returns>Результат выполнения обещания</returns>
324 public T Join(int timeout) {
325 ManualResetEvent evt = new ManualResetEvent(false);
326 Anyway(() => evt.Set());
288 327
289 if (m_error != null)
290 throw new TargetInvocationException( m_error );
291 else
292 return m_result;
293 }
328 if (!evt.WaitOne(timeout, true))
329 throw new TimeoutException();
294 330
295 public T Join() {
296 return Join(Timeout.Infinite);
297 }
331 if (m_error != null)
332 throw new TargetInvocationException(m_error);
333 else
334 return m_result;
335 }
336
337 public T Join() {
338 return Join(Timeout.Infinite);
339 }
298 340
299 /// <summary>
300 /// Данный метод последовательно извлекает обработчики обещания и когда
301 /// их больше не осталось - ставит состояние "разрешено".
302 /// </summary>
303 /// <param name="handler">Информация об обработчике</param>
304 /// <returns>Признак того, что еще остались обработчики в очереди</returns>
305 bool FetchNextHandler(out ResultHandlerInfo handler) {
306 handler = default(ResultHandlerInfo);
341 /// <summary>
342 /// Данный метод последовательно извлекает обработчики обещания и когда
343 /// их больше не осталось - ставит состояние "разрешено".
344 /// </summary>
345 /// <param name="handler">Информация об обработчике</param>
346 /// <returns>Признак того, что еще остались обработчики в очереди</returns>
347 bool FetchNextHandler(out ResultHandlerInfo handler) {
348 handler = default(ResultHandlerInfo);
307 349
308 lock (this) {
309 Debug.Assert(m_state == State.Resolving);
350 lock (this) {
351 Debug.Assert(m_state == State.Resolving);
310 352
311 if (m_handlersChain.Count > 0) {
312 handler = m_handlersChain.First.Value;
313 m_handlersChain.RemoveFirst();
314 return true;
315 } else {
316 m_state = State.Resolved;
317 return false;
318 }
319 }
320 }
353 if (m_handlersChain.Count > 0) {
354 handler = m_handlersChain.First.Value;
355 m_handlersChain.RemoveFirst();
356 return true;
357 } else {
358 m_state = State.Resolved;
359 return false;
360 }
361 }
362 }
321 363
322 void AddHandler(ResultHandlerInfo handler) {
323 bool invokeRequired = false;
364 void AddHandler(ResultHandlerInfo handler) {
365 bool invokeRequired = false;
324 366
325 lock (this) {
326 if (m_state != State.Resolved)
327 m_handlersChain.AddLast(handler);
328 else
329 invokeRequired = true;
330 }
367 lock (this) {
368 if (m_state != State.Resolved)
369 m_handlersChain.AddLast(handler);
370 else
371 invokeRequired = true;
372 }
331 373
332 // обработчики не должны блокировать сам объект
333 if (invokeRequired)
334 InvokeHandler(handler);
335 }
374 // обработчики не должны блокировать сам объект
375 if (invokeRequired)
376 InvokeHandler(handler);
377 }
336 378
337 void InvokeHandler(ResultHandlerInfo handler) {
338 if (m_error == null) {
339 try {
340 if (handler.resultHandler != null)
341 handler.resultHandler(m_result);
342 } catch { }
343 }
379 void InvokeHandler(ResultHandlerInfo handler) {
380 if (m_error == null) {
381 try {
382 if (handler.resultHandler != null)
383 handler.resultHandler(m_result);
384 } catch { }
385 }
344 386
345 if (m_error != null) {
346 try {
347 if (handler.errorHandler !=null)
348 handler.errorHandler(m_error);
349 } catch { }
350 }
351 }
387 if (m_error != null) {
388 try {
389 if (handler.errorHandler != null)
390 handler.errorHandler(m_error);
391 } catch { }
392 }
393 }
352 394
353 395
354 }
396 }
355 397 }
General Comments 0
You need to be logged in to leave comments. Login now