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