Mercurial > pub > ImplabNet

annotate Implab/Promise.cs @ 80:4f20870d0816 v2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
added memory barriers
author cin
date Fri, 26 Sep 2014 03:32:34 +0400
parents c761fc982e1d
children daffa72a1cec
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>
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
354 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
355 Safe.ArgumentNotNull(mapper, "mapper");
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
356
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 var medium = new Promise<TNew>(this, true);
2
aa367305156b small fixes
cin
parents: 1
diff changeset
359
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
360 ResultHandler<T> resultHandler = result => medium.Resolve(mapper(result));
72
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
361 ErrorHandler<T> errorHandler;
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
362 if (error != null)
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
363 errorHandler = e => {
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
364 try {
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
365 medium.Resolve(error(e));
72
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
366 } catch (Exception e2) {
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
367 // в случае ошибки нужно передать исключение дальше по цепочке
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
368 medium.Reject(e2);
72
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
369 }
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
370 return default(T);
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
371 };
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
372 else
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
373 errorHandler = e => {
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
374 medium.Reject(e);
72
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
375 return default(T);
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
376 };
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
377
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
378 Action cancelHandler;
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
379 if (cancel != null)
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
380 cancelHandler = () => {
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
381 cancel();
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
382 medium.Cancel();
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
383 };
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
384 else
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
385 cancelHandler = medium.Cancel;
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
386
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
387
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
388 AddHandler(
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
389 resultHandler,
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
390 errorHandler,
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
391 cancelHandler,
72
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
392 null
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
393 );
2
aa367305156b small fixes
cin
parents: 1
diff changeset
394
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
395 return medium;
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
396 }
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 public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler<TNew> error) {
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
399 return Then(mapper, error, null);
6
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
400 }
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
401
75
4439140706d0 major refactoring, added tasks support
cin
parents: 74
diff changeset
402 public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper) {
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
403 return Then(mapper, null, null);
6
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
404 }
2
aa367305156b small fixes
cin
parents: 1
diff changeset
405
6
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
406 /// <summary>
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
407 /// Сцепляет несколько аснхронных операций. Указанная асинхронная операция будет вызвана после
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 /// </summary>
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
411 /// <typeparam name="TNew">Тип результата указанной асинхронной операции.</typeparam>
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
412 /// <param name="chained">Асинхронная операция, которая должна будет начаться после выполнения текущей.</param>
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
413 /// <param name="error">Обработчик ошибки. Данный обработчик получит
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
414 /// исключение возникшее при выполнении текуещй операции.</param>
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
415 /// <returns>Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции.</returns>
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
416 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
417
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
418 Safe.ArgumentNotNull(chained, "chained");
6
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
419
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
420 // проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно
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 // передать через него результаты работы.
10
aa33d0bb8c0c implemeted new cancellable promises concept
cin
parents: 9
diff changeset
424 var medium = new Promise<TNew>(this, true);
2
aa367305156b small fixes
cin
parents: 1
diff changeset
425
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
426 ResultHandler<T> resultHandler = delegate(T result) {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
427 if (medium.IsCancelled)
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
428 return;
10
aa33d0bb8c0c implemeted new cancellable promises concept
cin
parents: 9
diff changeset
429
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
430 var promise = chained(result);
10
aa33d0bb8c0c implemeted new cancellable promises concept
cin
parents: 9
diff changeset
431
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
432 promise.Last(
72
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
433 medium.Resolve,
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
434 medium.Reject,
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
435 () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
436 );
33
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
437
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
438 // 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
439 // порядок вызова Then, Cancelled важен, поскольку от этого
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
440 // зависит IsExclusive
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
441 medium.Cancelled(() => {
72
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
442 if (promise.IsExclusive)
33
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
443 promise.Cancel();
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
444 });
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
445 };
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
446
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
447 ErrorHandler<T> errorHandler;
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
448
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
449 if (error != null)
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
450 errorHandler = delegate(Exception e) {
72
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
451 try {
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
452 var promise = error(e);
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
453
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
454 promise.Last(
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
455 medium.Resolve,
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
456 medium.Reject,
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
457 () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
458 );
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
459
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
460 // notify chained operation that it's not needed anymore
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
461 // порядок вызова Then, Cancelled важен, поскольку от этого
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
462 // зависит IsExclusive
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
463 medium.Cancelled(() => {
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
464 if (promise.IsExclusive)
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
465 promise.Cancel();
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
466 });
72
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
467 } catch (Exception e2) {
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
468 medium.Reject(e2);
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
469 }
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
470 return default(T);
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
471 };
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
472 else
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
473 errorHandler = err => {
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
474 medium.Reject(err);
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
475 return default(T);
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
476 };
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
477
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 Action cancelHandler;
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
480 if (cancel != null)
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
481 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 cancel();
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
484 medium.Cancel();
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
485 };
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
486 else
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
487 cancelHandler = medium.Cancel;
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
488
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
489 AddHandler(
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
490 resultHandler,
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
491 errorHandler,
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
492 cancelHandler,
72
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
493 null
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
494 );
2
aa367305156b small fixes
cin
parents: 1
diff changeset
495
6
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
496 return medium;
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
497 }
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
498
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
499 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
500 return Chain(chained, error, null);
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
501 }
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
502
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
503 public IPromise<TNew> Chain<TNew>(ResultMapper<T, IPromise<TNew>> chained) {
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
504 return Chain(chained, null, null);
6
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
505 }
2
aa367305156b small fixes
cin
parents: 1
diff changeset
506
26
f0bf98e4d22c refactoring
cin
parents: 25
diff changeset
507 public IPromise<T> Cancelled(Action handler) {
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
508 var medium = new Promise<T>(this,true);
74
c4140283575c minor fixes
cin
parents: 72
diff changeset
509 AddHandler(null, null, handler, medium);
c4140283575c minor fixes
cin
parents: 72
diff changeset
510 return medium;
10
aa33d0bb8c0c implemeted new cancellable promises concept
cin
parents: 9
diff changeset
511 }
aa33d0bb8c0c implemeted new cancellable promises concept
cin
parents: 9
diff changeset
512
25
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
513 /// <summary>
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
514 /// Adds the specified handler for all cases (success, error, cancel)
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
515 /// </summary>
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
516 /// <param name="handler">The handler that will be called anyway</param>
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
517 /// <returns>self</returns>
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
518 public IPromise<T> Anyway(Action handler) {
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
519 Safe.ArgumentNotNull(handler, "handler");
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
520
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
521 AddHandler(
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
522 x => handler(),
72
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
523 e => {
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
524 handler();
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
525 throw new TransientPromiseException(e);
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
526 },
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
527 handler,
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
528 null
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
529 );
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
530 return this;
10
aa33d0bb8c0c implemeted new cancellable promises concept
cin
parents: 9
diff changeset
531 }
aa33d0bb8c0c implemeted new cancellable promises concept
cin
parents: 9
diff changeset
532
6
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
533 /// <summary>
29
768f7deeb55b Added a casting method for promises.
cin
parents: 28
diff changeset
534 /// Преобразует результат обещания к нужному типу
768f7deeb55b Added a casting method for promises.
cin
parents: 28
diff changeset
535 /// </summary>
768f7deeb55b Added a casting method for promises.
cin
parents: 28
diff changeset
536 /// <typeparam name="T2"></typeparam>
768f7deeb55b Added a casting method for promises.
cin
parents: 28
diff changeset
537 /// <returns></returns>
768f7deeb55b Added a casting method for promises.
cin
parents: 28
diff changeset
538 public IPromise<T2> Cast<T2>() {
75
4439140706d0 major refactoring, added tasks support
cin
parents: 74
diff changeset
539 return Then(x => (T2)(object)x, null);
29
768f7deeb55b Added a casting method for promises.
cin
parents: 28
diff changeset
540 }
768f7deeb55b Added a casting method for promises.
cin
parents: 28
diff changeset
541
768f7deeb55b Added a casting method for promises.
cin
parents: 28
diff changeset
542 /// <summary>
6
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
543 /// Дожидается отложенного обещания и в случае успеха, возвращает
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
544 /// его, результат, в противном случае бросает исключение.
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
545 /// </summary>
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
546 /// <remarks>
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
547 /// <para>
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
548 /// Если ожидание обещания было прервано по таймауту, это не значит,
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
549 /// что обещание было отменено или что-то в этом роде, это только
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 /// </para>
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
554 /// <para>
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
555 /// Такое поведение вполне оправдано поскольку таймаут может истечь
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
556 /// в тот момент, когда началась обработка цепочки обработчиков, и
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 /// </para>
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
560 /// </remarks>
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
561 /// <param name="timeout">Время ожидания</param>
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
562 /// <returns>Результат выполнения обещания</returns>
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
563 public T Join(int timeout) {
10
aa33d0bb8c0c implemeted new cancellable promises concept
cin
parents: 9
diff changeset
564 var evt = new ManualResetEvent(false);
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
565 Anyway(() => evt.Set());
2
aa367305156b small fixes
cin
parents: 1
diff changeset
566
6
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
567 if (!evt.WaitOne(timeout, true))
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
568 throw new TimeoutException();
2
aa367305156b small fixes
cin
parents: 1
diff changeset
569
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
570 switch (m_state) {
71
1714fd8678ef code cleanup
cin
parents: 66
diff changeset
571 case SUCCEEDED_STATE:
10
aa33d0bb8c0c implemeted new cancellable promises concept
cin
parents: 9
diff changeset
572 return m_result;
71
1714fd8678ef code cleanup
cin
parents: 66
diff changeset
573 case CANCELLED_STATE:
10
aa33d0bb8c0c implemeted new cancellable promises concept
cin
parents: 9
diff changeset
574 throw new OperationCanceledException();
71
1714fd8678ef code cleanup
cin
parents: 66
diff changeset
575 case REJECTED_STATE:
10
aa33d0bb8c0c implemeted new cancellable promises concept
cin
parents: 9
diff changeset
576 throw new TargetInvocationException(m_error);
aa33d0bb8c0c implemeted new cancellable promises concept
cin
parents: 9
diff changeset
577 default:
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
578 throw new ApplicationException(String.Format("Invalid promise state {0}", m_state));
10
aa33d0bb8c0c implemeted new cancellable promises concept
cin
parents: 9
diff changeset
579 }
6
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
580 }
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
581
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
582 public T Join() {
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
583 return Join(Timeout.Infinite);
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
584 }
2
aa367305156b small fixes
cin
parents: 1
diff changeset
585
72
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
586 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
587 if (success != null || error != null)
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
588 Interlocked.Increment(ref m_childrenCount);
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
589
72
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
590 var handler = new HandlerDescriptor {
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
591 resultHandler = success,
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
592 errorHandler = error,
72
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
593 cancellHandler = cancel,
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
594 medium = medium
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
595 };
2
aa367305156b small fixes
cin
parents: 1
diff changeset
596
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
597 bool queued;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
598
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
599 if (!IsResolved) {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
600 m_handlers.Enqueue(handler);
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
601 queued = true;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
602 } else {
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
603 // 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
604 queued = false;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
605 InvokeHandler(handler);
6
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
606 }
2
aa367305156b small fixes
cin
parents: 1
diff changeset
607
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
608 if (queued && IsResolved && m_handlers.TryDequeue(out handler))
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
609 // 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
610 // 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
611 // therefore we will fetch a handler from the queue and execute it
27
cin
parents: 26
diff changeset
612 // note that fetched handler may be not the one that we have added
cin
parents: 26
diff changeset
613 // even we can fetch no handlers at all :)
6
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
614 InvokeHandler(handler);
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
615 }
2
aa367305156b small fixes
cin
parents: 1
diff changeset
616
27
cin
parents: 26
diff changeset
617 protected virtual void InvokeHandler(HandlerDescriptor handler) {
10
aa33d0bb8c0c implemeted new cancellable promises concept
cin
parents: 9
diff changeset
618 switch (m_state) {
71
1714fd8678ef code cleanup
cin
parents: 66
diff changeset
619 case SUCCEEDED_STATE:
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
620 handler.Resolve(m_result);
10
aa33d0bb8c0c implemeted new cancellable promises concept
cin
parents: 9
diff changeset
621 break;
71
1714fd8678ef code cleanup
cin
parents: 66
diff changeset
622 case REJECTED_STATE:
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
623 handler.Reject(m_error);
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
624 break;
71
1714fd8678ef code cleanup
cin
parents: 66
diff changeset
625 case CANCELLED_STATE:
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
626 handler.Cancel();
10
aa33d0bb8c0c implemeted new cancellable promises concept
cin
parents: 9
diff changeset
627 break;
aa33d0bb8c0c implemeted new cancellable promises concept
cin
parents: 9
diff changeset
628 default:
aa33d0bb8c0c implemeted new cancellable promises concept
cin
parents: 9
diff changeset
629 // do nothing
aa33d0bb8c0c implemeted new cancellable promises concept
cin
parents: 9
diff changeset
630 return;
6
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
631 }
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
632 }
2
aa367305156b small fixes
cin
parents: 1
diff changeset
633
65
653c4e04968b minor changes
cin
parents: 33
diff changeset
634 void OnStateChanged() {
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
635 HandlerDescriptor handler;
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
636 while (m_handlers.TryDequeue(out handler))
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
637 InvokeHandler(handler);
11
6ec82bf68c8e refactoring
cin
parents: 10
diff changeset
638 }
6ec82bf68c8e refactoring
cin
parents: 10
diff changeset
639
9
cin
parents: 7
diff changeset
640 public bool IsExclusive {
cin
parents: 7
diff changeset
641 get {
19
e3935fdf59a2 Promise is rewritten to use interlocked operations instead of locks
cin
parents: 16
diff changeset
642 return m_childrenCount <= 1;
9
cin
parents: 7
diff changeset
643 }
cin
parents: 7
diff changeset
644 }
cin
parents: 7
diff changeset
645
25
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
646 /// <summary>
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
647 /// Объединяет несколько обещаний в одно, результатом которого является массив результатов других обещаний.
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
648 /// Если хотябы одно из переданных обещаний не будет выполнено, то новое обещение тоже не будет выполнено.
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
649 /// При отмене нового обещания, переданные обещания также будут отменены, если никто больше на них не подписан.
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
650 /// </summary>
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
651 /// <param name="promises">Список обещаний. Если список пустой, то результирующее обещание возвращается уже выполненным.</param>
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
652 /// <returns>Обещание объединяющее в себе результат переданных обещаний.</returns>
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
653 /// <exception cref="ArgumentNullException"><paramref name="promises"/> не может быть null</exception>
30
2fad2d1f4b03 small refactoring, cleanup.
cin
parents: 29
diff changeset
654 public static IPromise<T[]> CreateComposite(IList<IPromise<T>> promises) {
25
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
655 if (promises == null)
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
656 throw new ArgumentNullException();
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
657
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
658 // создаем аккумулятор для результатов и результирующее обещание
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
659 var result = new T[promises.Count];
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
660 var promise = new Promise<T[]>();
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
661
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
662 // special case
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
663 if (promises.Count == 0) {
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
664 promise.Resolve(result);
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
665 return promise;
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
666 }
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
667
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
668 int pending = promises.Count;
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
669
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
670 for (int i = 0; i < promises.Count; i++) {
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
671 var dest = i;
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
672
33
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
673 if (promises[i] != null) {
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
674 promises[i].Then(
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
675 x => {
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
676 result[dest] = x;
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
677 if (Interlocked.Decrement(ref pending) == 0)
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
678 promise.Resolve(result);
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
679 },
72
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
680 e => {
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
681 promise.Reject(e);
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
682 return default(T);
d67b95eddaf4 promises refactoring
cin
parents: 71
diff changeset
683 }
33
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
684 );
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
685 } else {
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
686 if (Interlocked.Decrement(ref pending) == 0)
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
687 promise.Resolve(result);
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
688 }
25
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
689 }
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
690
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
691 promise.Cancelled(
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
692 () => {
33
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
693 foreach (var d in promises)
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
694 if (d != null && d.IsExclusive)
25
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
695 d.Cancel();
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
696 }
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
697 );
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
698
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
699 return promise;
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
700 }
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
701
33
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
702 /// <summary>
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
703 /// Объединяет несколько обещаний в одно. Результирующее обещание будет выполнено при
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
704 /// выполнении всех указанных обещаний. При этом возвращаемые значения первичных обещаний
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
705 /// игнорируются.
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
706 /// </summary>
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
707 /// <param name="promises">Коллекция первичных обещаний, которые будут объеденены в одно.</param>
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
708 /// <returns>Новое обещание, объединяющее в себе переданные.</returns>
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
709 /// <remarks>
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
710 /// Если в коллекции встречаюься <c>null</c>, то они воспринимаются как выполненные обещания.
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
711 /// </remarks>
66
790e8a997d30 Refactoring
cin
parents: 65
diff changeset
712 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
713 if (promises == null)
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
714 throw new ArgumentNullException();
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
715 if (promises.Count == 0)
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
716 return Promise<object>.ResultToPromise(null);
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
717
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
718 int countdown = promises.Count;
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 var result = new Promise<object>();
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 foreach (var d in promises) {
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
723 if (d == null) {
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
724 if (Interlocked.Decrement(ref countdown) == 0)
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
725 result.Resolve(null);
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
726 } else {
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
727 d.Then(() => {
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
728 if (Interlocked.Decrement(ref countdown) == 0)
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
729 result.Resolve(null);
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
730 });
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
731 }
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 result.Cancelled(() => {
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
735 foreach (var d in promises)
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
736 if (d != null && d.IsExclusive)
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
737 d.Cancel();
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
738 });
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
739
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
740 return result;
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
25
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
743 public static Promise<T> ResultToPromise(T result) {
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
744 var p = new Promise<T>();
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
745 p.Resolve(result);
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
746 return p;
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
747 }
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
748
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
749 public static Promise<T> ExceptionToPromise(Exception error) {
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
750 if (error == null)
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
751 throw new ArgumentNullException();
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
752
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
753 var p = new Promise<T>();
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
754 p.Reject(error);
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
755 return p;
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
756 }
9bf5b23650c9 refactoring
cin
parents: 19
diff changeset
757
33
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
758 #region IPromiseBase explicit implementation
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
759
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
760 IPromise IPromise.Then(Action success, ErrorHandler error, Action cancel) {
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
761 return Then(
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
762 x => success(),
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
763 e => {
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
764 error(e);
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
765 return default(T);
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
766 },
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
767 cancel
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
768 );
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
769 }
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 IPromise IPromise.Then(Action success, ErrorHandler error) {
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
772 return Then(
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
773 x => success(),
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
774 e => {
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
775 error(e);
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
776 return default(T);
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
777 }
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
778 );
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
779 }
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 IPromise IPromise.Then(Action success) {
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
782 return Then(x => success());
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
783 }
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
784
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
785 void IPromise.Last(Action success, ErrorHandler error, Action cancel) {
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
786 Last(x => success(), error, cancel);
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
787 }
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
788
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
789 void IPromise.Last(Action success, ErrorHandler error) {
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
790 Last(x => success(), error, null);
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
791 }
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
792
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
793 void IPromise.Last(Action success) {
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
794 Last(x => success(), null, null);
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
795 }
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
796
66
790e8a997d30 Refactoring
cin
parents: 65
diff changeset
797 IPromise IPromise.Error(ErrorHandler error) {
33
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
798 return Error(error);
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
799 }
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
800
76
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
801 IPromise IPromise.Anyway(Action handler) {
c761fc982e1d Refactoring of the IPromise<T> interface
cin
parents: 75
diff changeset
802 return Anyway(handler);
33
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
803 }
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
804
66
790e8a997d30 Refactoring
cin
parents: 65
diff changeset
805 IPromise IPromise.Cancelled(Action handler) {
33
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
806 return Cancelled(handler);
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
807 }
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
808
66
790e8a997d30 Refactoring
cin
parents: 65
diff changeset
809 void IPromise.Join() {
33
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
810 Join();
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
811 }
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
812
66
790e8a997d30 Refactoring
cin
parents: 65
diff changeset
813 void IPromise.Join(int timeout) {
33
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
814 Join(timeout);
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
815 }
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
816
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
817 #endregion
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
818
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
819
b255e4aeef17 removed the reference to the parent from the promise object this allows
cin
parents: 32
diff changeset
820
6
dfa21d507bc5 *refactoring: Promise.Then now returns a new chained promise
cin
parents: 2
diff changeset
821 }
2
aa367305156b small fixes
cin
parents: 1
diff changeset
822 }