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