implab/ImplabNet Commit - r99:8ddf1648eca4

1

using System;

1

using System;

2

using System.Collections.Generic;

2

using System.Collections.Generic;

3

using System.Reflection;

3

using System.Reflection;

4

using System.Diagnostics;

4

using System.Diagnostics;

5

using System.Threading;

5

using System.Threading;

6

using Implab.Parallels;

6

using Implab.Parallels;

7

8

namespace Implab {

8

namespace Implab {

9

10

public delegate void ErrorHandler(Exception e);

10

public delegate void ErrorHandler(Exception e);

11

public delegate T ErrorHandler<out T>(Exception e);

11

public delegate T ErrorHandler<out T>(Exception e);

12

public delegate void ResultHandler<in T>(T result);

12

public delegate void ResultHandler<in T>(T result);

13

public delegate TNew ResultMapper<in TSrc,out TNew>(TSrc result);

13

public delegate TNew ResultMapper<in TSrc,out TNew>(TSrc result);

14

15

/// <summary>

15

/// <summary>

16

/// Класс для асинхронного получения результатов. Так называемое "обещание".

16

/// Класс для асинхронного получения результатов. Так называемое "обещание".

17

/// </summary>

17

/// </summary>

18

/// <typeparam name="T">Тип получаемого результата</typeparam>

18

/// <typeparam name="T">Тип получаемого результата</typeparam>

19

/// <remarks>

19

/// <remarks>

20

/// <para>Сервис при обращении к его методу дает обещаиние о выполнении операции,

20

/// <para>Сервис при обращении к его методу дает обещаиние о выполнении операции,

21

/// клиент получив такое обещание может установить ряд обратных вызово для получения

21

/// клиент получив такое обещание может установить ряд обратных вызово для получения

22

/// событий выполнения обещания, тоесть завершения операции и предоставлении результатов.</para>

22

/// событий выполнения обещания, тоесть завершения операции и предоставлении результатов.</para>

23

/// <para>

23

/// <para>

24

/// Обещение может быть как выполнено, так и выполнено с ошибкой. Для подписки на

24

/// Обещение может быть как выполнено, так и выполнено с ошибкой. Для подписки на

25

/// данные события клиент должен использовать методы <c>Then</c>.

25

/// данные события клиент должен использовать методы <c>Then</c>.

26

/// </para>

26

/// </para>

27

/// <para>

27

/// <para>

28

/// Сервис, в свою очередь, по окончанию выполнения операции (возможно с ошибкой),

28

/// Сервис, в свою очередь, по окончанию выполнения операции (возможно с ошибкой),

29

/// использует методы <c>Resolve</c> либо <c>Reject</c> для оповещения клиетна о

29

/// использует методы <c>Resolve</c> либо <c>Reject</c> для оповещения клиетна о

30

/// выполнении обещания.

30

/// выполнении обещания.

31

/// </para>

31

/// </para>

32

/// <para>

32

/// <para>

33

/// Если сервер успел выполнить обещание еще до того, как клиент на него подписался,

33

/// Если сервер успел выполнить обещание еще до того, как клиент на него подписался,

34

/// то в момент подписки клиента будут вызваны соответсвующие события в синхронном

34

/// то в момент подписки клиента будут вызваны соответсвующие события в синхронном

35

/// режиме и клиент будет оповещен в любом случае. Иначе, обработчики добавляются в

35

/// режиме и клиент будет оповещен в любом случае. Иначе, обработчики добавляются в

36

/// список в порядке подписания и в этом же порядке они будут вызваны при выполнении

36

/// список в порядке подписания и в этом же порядке они будут вызваны при выполнении

37

/// обещания.

37

/// обещания.

38

/// </para>

38

/// </para>

39

/// <para>

39

/// <para>

40

/// Обрабатывая результаты обещания можно преобразовывать результаты либо инициировать

40

/// Обрабатывая результаты обещания можно преобразовывать результаты либо инициировать

41

/// связанные асинхронные операции, которые также возвращают обещания. Для этого следует

41

/// связанные асинхронные операции, которые также возвращают обещания. Для этого следует

42

/// использовать соответствующую форму методе <c>Then</c>.

42

/// использовать соответствующую форму методе <c>Then</c>.

43

/// </para>

43

/// </para>

44

/// <para>

44

/// <para>

45

/// Также хорошим правилом является то, что <c>Resolve</c> и <c>Reject</c> должен вызывать

45

/// Также хорошим правилом является то, что <c>Resolve</c> и <c>Reject</c> должен вызывать

46

/// только инициатор обещания иначе могут возникнуть противоречия.

46

/// только инициатор обещания иначе могут возникнуть противоречия.

47

/// </para>

47

/// </para>

48

/// </remarks>

48

/// </remarks>

49

public class Promise<T> : IPromise<T> {

49

public class Promise<T> : IPromise<T> {

50

51

protected struct HandlerDescriptor {

51

protected struct HandlerDescriptor {

52

public ResultHandler<T> resultHandler;

52

public ResultHandler<T> resultHandler;

53

public ErrorHandler<T> errorHandler;

53

public ErrorHandler<T> errorHandler;

54

public Action cancellHandler;

54

public Action cancellHandler;

55

public Promise<T> medium;

55

public Promise<T> medium;

56

57

public void Resolve(T result) {

57

public void Resolve(T result) {

58

if (resultHandler != null) {

58

if (resultHandler != null) {

59

try {

59

try {

60

resultHandler(result);

60

resultHandler(result);

61

} catch (Exception e) {

61

} catch (Exception e) {

62

Reject(e);

62

Reject(e);

63

return;

63

return;

64

}

64

}

65

}

65

}

66

if (medium != null)

66

if (medium != null)

67

medium.Resolve(result);

67

medium.Resolve(result);

68

}

68

}

69

70

public void Reject(Exception err) {

70

public void Reject(Exception err) {

71

if (errorHandler != null) {

71

if (errorHandler != null) {

72

try {

72

try {

73

var res = errorHandler(err);

73

var res = errorHandler(err);

74

if (medium != null)

74

if (medium != null)

75

medium.Resolve(res);

75

medium.Resolve(res);

76

} catch (TransientPromiseException err2) {

76

/*} catch (TransientPromiseException err2) {

77

if (medium != null)

77

if (medium != null)

78

~~medium~~.~~Reject~~(~~err2~~.~~InnerException~~);

78

medium.Reject(err2.InnerException);*/

79

} catch (Exception err2) {

79

} catch (Exception err2) {

80

if (medium != null)

80

if (medium != null)

81

medium.Reject(err2);

81

medium.Reject(err2);

82

}

82

}

83

} else if (medium != null)

83

} else if (medium != null)

84

medium.Reject(err);

84

medium.Reject(err);

85

}

85

}

86

87

public void Cancel() {

87

public void Cancel() {

88

if (cancellHandler != null) {

88

if (cancellHandler != null) {

89

try {

89

try {

90

cancellHandler();

90

cancellHandler();

91

} catch (Exception err) {

91

} catch (Exception err) {

92

Reject(err);

92

Reject(err);

93

return;

93

return;

94

}

94

}

95

}

95

}

96

if (medium != null)

96

if (medium != null)

97

medium.Cancel();

97

medium.Cancel();

98

}

98

}

99

}

99

}

100

101

const int UNRESOLVED_SATE = 0;

101

const int UNRESOLVED_SATE = 0;

102

const int TRANSITIONAL_STATE = 1;

102

const int TRANSITIONAL_STATE = 1;

103

const int SUCCEEDED_STATE = 2;

103

const int SUCCEEDED_STATE = 2;

104

const int REJECTED_STATE = 3;

104

const int REJECTED_STATE = 3;

105

const int CANCELLED_STATE = 4;

105

const int CANCELLED_STATE = 4;

106

107

readonly bool m_cancellable;

107

readonly bool m_cancellable;

108

109

int m_childrenCount = 0;

109

int m_childrenCount = 0;

110

int m_state;

110

int m_state;

111

T m_result;

111

T m_result;

112

Exception m_error;

112

Exception m_error;

113

114

readonly MTQueue<HandlerDescriptor> m_handlers = new MTQueue<HandlerDescriptor>();

114

readonly MTQueue<HandlerDescriptor> m_handlers = new MTQueue<HandlerDescriptor>();

115

116

public Promise() {

116

public Promise() {

117

m_cancellable = true;

117

m_cancellable = true;

118

}

118

}

119

120

public Promise(IPromise parent, bool cancellable) {

120

public Promise(IPromise parent, bool cancellable) {

121

m_cancellable = cancellable;

121

m_cancellable = cancellable;

122

if (parent != null)

122

if (parent != null)

123

AddHandler(

123

AddHandler(

124

null,

124

null,

125

null,

125

null,

126

() => {

126

() => {

127

if (parent.IsExclusive)

127

if (parent.IsExclusive)

128

parent.Cancel();

128

parent.Cancel();

129

},

129

},

130

null

130

null

131

);

131

);

132

}

132

}

133

134

bool BeginTransit() {

134

bool BeginTransit() {

135

return UNRESOLVED_SATE == Interlocked.CompareExchange(ref m_state, TRANSITIONAL_STATE, UNRESOLVED_SATE);

135

return UNRESOLVED_SATE == Interlocked.CompareExchange(ref m_state, TRANSITIONAL_STATE, UNRESOLVED_SATE);

136

}

136

}

137

138

void CompleteTransit(int state) {

138

void CompleteTransit(int state) {

139

if (TRANSITIONAL_STATE != Interlocked.CompareExchange(ref m_state, state, TRANSITIONAL_STATE))

139

if (TRANSITIONAL_STATE != Interlocked.CompareExchange(ref m_state, state, TRANSITIONAL_STATE))

140

throw new InvalidOperationException("Can't complete transition when the object isn't in the transitional state");

140

throw new InvalidOperationException("Can't complete transition when the object isn't in the transitional state");

141

}

141

}

142

143

void WaitTransition() {

143

void WaitTransition() {

144

while (m_state == TRANSITIONAL_STATE) {

144

while (m_state == TRANSITIONAL_STATE) {

145

Thread.MemoryBarrier();

145

Thread.MemoryBarrier();

146

}

146

}

147

}

147

}

148

149

public bool IsResolved {

149

public bool IsResolved {

150

get {

150

get {

151

Thread.MemoryBarrier();

151

Thread.MemoryBarrier();

152

return m_state > 1;

152

return m_state > 1;

153

}

153

}

154

}

154

}

155

156

public bool IsCancelled {

156

public bool IsCancelled {

157

get {

157

get {

158

Thread.MemoryBarrier();

158

Thread.MemoryBarrier();

159

return m_state == CANCELLED_STATE;

159

return m_state == CANCELLED_STATE;

160

}

160

}

161

}

161

}

162

163

public Type PromiseType {

163

public Type PromiseType {

164

get { return typeof(T); }

164

get { return typeof(T); }

165

}

165

}

166

167

/// <summary>

167

/// <summary>

168

/// Выполняет обещание, сообщая об успешном выполнении.

168

/// Выполняет обещание, сообщая об успешном выполнении.

169

/// </summary>

169

/// </summary>

170

/// <param name="result">Результат выполнения.</param>

170

/// <param name="result">Результат выполнения.</param>

171

/// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>

171

/// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>

172

public void Resolve(T result) {

172

public void Resolve(T result) {

173

if (BeginTransit()) {

173

if (BeginTransit()) {

174

m_result = result;

174

m_result = result;

175

CompleteTransit(SUCCEEDED_STATE);

175

CompleteTransit(SUCCEEDED_STATE);

176

OnStateChanged();

176

OnStateChanged();

177

} else {

177

} else {

178

WaitTransition();

178

WaitTransition();

179

if (m_state != CANCELLED_STATE)

179

if (m_state != CANCELLED_STATE)

180

throw new InvalidOperationException("The promise is already resolved");

180

throw new InvalidOperationException("The promise is already resolved");

181

}

181

}

182

}

182

}

183

184

/// <summary>

184

/// <summary>

185

/// Выполняет обещание, сообщая об успешном выполнении. Результатом выполнения будет пустое значения.

185

/// Выполняет обещание, сообщая об успешном выполнении. Результатом выполнения будет пустое значения.

186

/// </summary>

186

/// </summary>

187

/// <remarks>

187

/// <remarks>

188

/// Данный вариант удобен в случаях, когда интересен факт выполнения операции, нежели полученное значение.

188

/// Данный вариант удобен в случаях, когда интересен факт выполнения операции, нежели полученное значение.

189

/// </remarks>

189

/// </remarks>

190

public void Resolve() {

190

public void Resolve() {

191

Resolve(default(T));

191

Resolve(default(T));

192

}

192

}

193

194

/// <summary>

194

/// <summary>

195

/// Выполняет обещание, сообщая об ошибке

195

/// Выполняет обещание, сообщая об ошибке

196

/// </summary>

196

/// </summary>

197

/// <remarks>

197

/// <remarks>

198

/// Поскольку обещание должно работать в многопточной среде, при его выполнении сразу несколько потоков

198

/// Поскольку обещание должно работать в многопточной среде, при его выполнении сразу несколько потоков

199

/// могу вернуть ошибку, при этом только первая будет использована в качестве результата, остальные

199

/// могу вернуть ошибку, при этом только первая будет использована в качестве результата, остальные

200

/// будут проигнорированы.

200

/// будут проигнорированы.

201

/// </remarks>

201

/// </remarks>

202

/// <param name="error">Исключение возникшее при выполнении операции</param>

202

/// <param name="error">Исключение возникшее при выполнении операции</param>

203

/// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>

203

/// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>

204

public void Reject(Exception error) {

204

public void Reject(Exception error) {

205

if (BeginTransit()) {

205

if (BeginTransit()) {

206

m_error = error;

206

m_error = error is TransientPromiseException ? error.InnerException : error;

207

CompleteTransit(REJECTED_STATE);

207

CompleteTransit(REJECTED_STATE);

208

OnStateChanged();

208

OnStateChanged();

209

} else {

209

} else {

210

WaitTransition();

210

WaitTransition();

211

if (m_state == SUCCEEDED_STATE)

211

if (m_state == SUCCEEDED_STATE)

212

throw new InvalidOperationException("The promise is already resolved");

212

throw new InvalidOperationException("The promise is already resolved");

213

}

213

}

214

}

214

}

215

216

/// <summary>

216

/// <summary>

217

/// Отменяет операцию, если это возможно.

217

/// Отменяет операцию, если это возможно.

218

/// </summary>

218

/// </summary>

219

/// <remarks>Для определения была ли операция отменена следует использовать свойство <see cref="IsCancelled"/>.</remarks>

219

/// <remarks>Для определения была ли операция отменена следует использовать свойство <see cref="IsCancelled"/>.</remarks>

220

public void Cancel() {

220

public void Cancel() {

221

if (m_cancellable && BeginTransit()) {

221

if (m_cancellable && BeginTransit()) {

222

CompleteTransit(CANCELLED_STATE);

222

CompleteTransit(CANCELLED_STATE);

223

OnStateChanged();

223

OnStateChanged();

224

}

224

}

225

}

225

}

226

227

public IPromise<T> Then(ResultHandler<T> success, ErrorHandler<T> error, Action cancel) {

227

public IPromise<T> Then(ResultHandler<T> success, ErrorHandler<T> error, Action cancel) {

228

if (success == null && error == null && cancel == null)

228

if (success == null && error == null && cancel == null)

229

return this;

229

return this;

230

231

var medium = new Promise<T>(this, true);

231

var medium = new Promise<T>(this, true);

232

233

AddHandler(success, error, cancel, medium);

233

AddHandler(success, error, cancel, medium);

234

235

return medium;

235

return medium;

236

}

236

}

237

238

/// <summary>

238

/// <summary>

239

/// Adds new handlers to this promise.

239

/// Adds new handlers to this promise.

240

/// </summary>

240

/// </summary>

241

/// <param name="success">The handler of the successfully completed operation.

241

/// <param name="success">The handler of the successfully completed operation.

242

/// This handler will recieve an operation result as a parameter.</param>

242

/// This handler will recieve an operation result as a parameter.</param>

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>

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>

244

/// <returns>The new promise chained to this one.</returns>

244

/// <returns>The new promise chained to this one.</returns>

245

public IPromise<T> Then(ResultHandler<T> success, ErrorHandler<T> error) {

245

public IPromise<T> Then(ResultHandler<T> success, ErrorHandler<T> error) {

246

if (success == null && error == null)

246

if (success == null && error == null)

247

return this;

247

return this;

248

249

var medium = new Promise<T>(this, true);

249

var medium = new Promise<T>(this, true);

250

251

AddHandler(success, error, null, medium);

251

AddHandler(success, error, null, medium);

252

253

return medium;

253

return medium;

254

}

254

}

255

256

257

258

259

public IPromise<T> Then(ResultHandler<T> success) {

259

public IPromise<T> Then(ResultHandler<T> success) {

260

if (success == null)

260

if (success == null)

261

return this;

261

return this;

262

263

var medium = new Promise<T>(this, true);

263

var medium = new Promise<T>(this, true);

264

265

AddHandler(success, null, null, medium);

265

AddHandler(success, null, null, medium);

266

267

return medium;

267

return medium;

268

}

268

}

269

270

/// <summary>

270

/// <summary>

271

/// Последний обработчик в цепочки обещаний.

271

/// Последний обработчик в цепочки обещаний.

272

/// </summary>

272

/// </summary>

273

/// <param name="success"></param>

273

/// <param name="success"></param>

274

/// <param name="error"></param>

274

/// <param name="error"></param>

275

/// <param name="cancel"></param>

275

/// <param name="cancel"></param>

276

/// <remarks>

276

/// <remarks>

277

/// <para>

277

/// <para>

278

/// Данный метод не создает связанного с текущим обещания и предназначен для окончания

278

/// Данный метод не создает связанного с текущим обещания и предназначен для окончания

279

/// фсинхронной цепочки.

279

/// фсинхронной цепочки.

280

/// </para>

280

/// </para>

281

/// <para>

281

/// <para>

282

/// Если данный метод вызвать несколько раз, либо добавить другие обработчики, то цепочка

282

/// Если данный метод вызвать несколько раз, либо добавить другие обработчики, то цепочка

283

/// не будет одиночной <see cref="IsExclusive"/> и, как следствие, будет невозможна отмена

283

/// не будет одиночной <see cref="IsExclusive"/> и, как следствие, будет невозможна отмена

284

/// всей цепи обещаний снизу (с самого последнего обещания).

284

/// всей цепи обещаний снизу (с самого последнего обещания).

285

/// </para>

285

/// </para>

286

/// </remarks>

286

/// </remarks>

287

public void Last(ResultHandler<T> success, ErrorHandler error, Action cancel) {

287

public void Last(ResultHandler<T> success, ErrorHandler error, Action cancel) {

288

if (success == null && error == null && cancel == null)

288

if (success == null && error == null && cancel == null)

289

return;

289

return;

290

291

ErrorHandler<T> errorHandler = null;

291

ErrorHandler<T> errorHandler = null;

292

if (error != null)

292

if (error != null)

293

errorHandler = err => {

293

errorHandler = err => {

294

error(err);

294

error(err);

295

return default(T);

295

return default(T);

296

};

296

};

297

AddHandler(success, errorHandler, cancel, null);

297

AddHandler(success, errorHandler, cancel, null);

298

}

298

}

299

300

public void Last(ResultHandler<T> success, ErrorHandler error) {

300

public void Last(ResultHandler<T> success, ErrorHandler error) {

301

Last(success, error, null);

301

Last(success, error, null);

302

}

302

}

303

304

public void Last(ResultHandler<T> success) {

304

public void Last(ResultHandler<T> success) {

305

Last(success, null, null);

305

Last(success, null, null);

306

}

306

}

307

308

public IPromise Error(ErrorHandler error) {

308

public IPromise Error(ErrorHandler error) {

309

if (error == null)

309

if (error == null)

310

return this;

310

return this;

311

312

var medium = new Promise<T>(this, true);

312

var medium = new Promise<T>(this, true);

313

314

AddHandler(

314

AddHandler(

315

null,

315

null,

316

e => {

316

e => {

317

error(e);

317

error(e);

318

return default(T);

318

return default(T);

319

},

319

},

320

null,

320

null,

321

medium

321

medium

322

);

322

);

323

324

return medium;

324

return medium;

325

}

325

}

326

327

/// <summary>

327

/// <summary>

328

/// Handles error and allows to keep the promise.

328

/// Handles error and allows to keep the promise.

329

/// </summary>

329

/// </summary>

330

/// <remarks>

330

/// <remarks>

331

/// If the specified handler throws an exception, this exception will be used to reject the promise.

331

/// If the specified handler throws an exception, this exception will be used to reject the promise.

332

/// </remarks>

332

/// </remarks>

333

/// <param name="handler">The error handler which returns the result of the promise.</param>

333

/// <param name="handler">The error handler which returns the result of the promise.</param>

334

/// <returns>New promise.</returns>

334

/// <returns>New promise.</returns>

335

public IPromise<T> Error(ErrorHandler<T> handler) {

335

public IPromise<T> Error(ErrorHandler<T> handler) {

336

if (handler == null)

336

if (handler == null)

337

return this;

337

return this;

338

339

var medium = new Promise<T>(this, true);

339

var medium = new Promise<T>(this, true);

340

341

AddHandler(null, handler, null, medium);

341

AddHandler(null, handler, null, medium);

342

343

return medium;

343

return medium;

344

}

344

}

345

346

/// <summary>

346

/// <summary>

347

/// Позволяет преобразовать результат выполения операции к новому типу.

347

/// Позволяет преобразовать результат выполения операции к новому типу.

348

/// </summary>

348

/// </summary>

349

/// <typeparam name="TNew">Новый тип результата.</typeparam>

349

/// <typeparam name="TNew">Новый тип результата.</typeparam>

350

/// <param name="mapper">Преобразование результата к новому типу.</param>

350

/// <param name="mapper">Преобразование результата к новому типу.</param>

351

/// <param name="error">Обработчик ошибки. Данный обработчик получит

351

/// <param name="error">Обработчик ошибки. Данный обработчик получит

352

/// исключение возникшее при выполнении операции.</param>

352

/// исключение возникшее при выполнении операции.</param>

353

/// <returns>Новое обещание, которое будет выполнено при выполнении исходного обещания.</returns>

353

/// <returns>Новое обещание, которое будет выполнено при выполнении исходного обещания.</returns>

354

/// <param name = "cancel"></param>

354

/// <param name = "cancel"></param>

355

public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler<TNew> error, Action cancel) {

355

public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler<TNew> error, Action cancel) {

356

Safe.ArgumentNotNull(mapper, "mapper");

356

Safe.ArgumentNotNull(mapper, "mapper");

357

358

// создаем прицепленное обещание

358

// создаем прицепленное обещание

359

var medium = new Promise<TNew>(this, true);

359

var medium = new Promise<TNew>(this, true);

360

361

ResultHandler<T> resultHandler = result => medium.Resolve(mapper(result));

361

ResultHandler<T> resultHandler = result => medium.Resolve(mapper(result));

362

ErrorHandler<T> errorHandler;

362

ErrorHandler<T> errorHandler;

363

if (error != null)

363

if (error != null)

364

errorHandler = e => {

364

errorHandler = e => {

365

try {

365

try {

366

medium.Resolve(error(e));

366

medium.Resolve(error(e));

367

} catch (Exception e2) {

367

} catch (Exception e2) {

368

// в случае ошибки нужно передать исключение дальше по цепочке

368

// в случае ошибки нужно передать исключение дальше по цепочке

369

medium.Reject(e2);

369

medium.Reject(e2);

370

}

370

}

371

return default(T);

371

return default(T);

372

};

372

};

373

else

373

else

374

errorHandler = e => {

374

errorHandler = e => {

375

medium.Reject(e);

375

medium.Reject(e);

376

return default(T);

376

return default(T);

377

};

377

};

378

379

Action cancelHandler;

379

Action cancelHandler;

380

if (cancel != null)

380

if (cancel != null)

381

cancelHandler = () => {

381

cancelHandler = () => {

382

cancel();

382

cancel();

383

medium.Cancel();

383

medium.Cancel();

384

};

384

};

385

else

385

else

386

cancelHandler = medium.Cancel;

386

cancelHandler = medium.Cancel;

387

388

389

AddHandler(

389

AddHandler(

390

resultHandler,

390

resultHandler,

391

errorHandler,

391

errorHandler,

392

cancelHandler,

392

cancelHandler,

393

null

393

null

394

);

394

);

395

396

return medium;

396

return medium;

397

}

397

}

398

399

public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler<TNew> error) {

399

public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler<TNew> error) {

400

return Then(mapper, error, null);

400

return Then(mapper, error, null);

401

}

401

}

402

403

public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper) {

403

public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper) {

404

return Then(mapper, null, null);

404

return Then(mapper, null, null);

405

}

405

}

406

407

/// <summary>

407

/// <summary>

408

/// Сцепляет несколько аснхронных операций. Указанная асинхронная операция будет вызвана после

408

/// Сцепляет несколько аснхронных операций. Указанная асинхронная операция будет вызвана после

409

/// выполнения текущей, а результат текущей операции может быть использован для инициализации

409

/// выполнения текущей, а результат текущей операции может быть использован для инициализации

410

/// новой операции.

410

/// новой операции.

411

/// </summary>

411

/// </summary>

412

/// <typeparam name="TNew">Тип результата указанной асинхронной операции.</typeparam>

412

/// <typeparam name="TNew">Тип результата указанной асинхронной операции.</typeparam>

413

/// <param name="chained">Асинхронная операция, которая должна будет начаться после выполнения текущей.</param>

413

/// <param name="chained">Асинхронная операция, которая должна будет начаться после выполнения текущей.</param>

414

/// <param name="error">Обработчик ошибки. Данный обработчик получит

414

/// <param name="error">Обработчик ошибки. Данный обработчик получит

415

/// исключение возникшее при выполнении текуещй операции.</param>

415

/// исключение возникшее при выполнении текуещй операции.</param>

416

/// <returns>Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции.</returns>

416

/// <returns>Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции.</returns>

417

/// <param name = "cancel"></param>

417

/// <param name = "cancel"></param>

418

public IPromise<TNew> Chain<TNew>(ResultMapper<T, IPromise<TNew>> chained, ErrorHandler<IPromise<TNew>> error, Action cancel) {

418

public IPromise<TNew> Chain<TNew>(ResultMapper<T, IPromise<TNew>> chained, ErrorHandler<IPromise<TNew>> error, Action cancel) {

419

420

Safe.ArgumentNotNull(chained, "chained");

420

Safe.ArgumentNotNull(chained, "chained");

421

422

// проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно

422

// проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно

423

// создать посредника, к которому будут подвызяваться следующие обработчики.

423

// создать посредника, к которому будут подвызяваться следующие обработчики.

424

// когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы

424

// когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы

425

// передать через него результаты работы.

425

// передать через него результаты работы.

426

var medium = new Promise<TNew>(this, true);

426

var medium = new Promise<TNew>(this, true);

427

428

ResultHandler<T> resultHandler = delegate(T result) {

428

ResultHandler<T> resultHandler = delegate(T result) {

429

if (medium.IsCancelled)

429

if (medium.IsCancelled)

430

return;

430

return;

431

432

var promise = chained(result);

432

var promise = chained(result);

433

434

promise.Last(

434

promise.Last(

435

medium.Resolve,

435

medium.Resolve,

436

medium.Reject,

436

medium.Reject,

437

() => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка

437

() => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка

438

);

438

);

439

440

// notify chained operation that it's not needed anymore

440

// notify chained operation that it's not needed anymore

441

// порядок вызова Then, Cancelled важен, поскольку от этого

441

// порядок вызова Then, Cancelled важен, поскольку от этого

442

// зависит IsExclusive

442

// зависит IsExclusive

443

medium.Cancelled(() => {

443

medium.Cancelled(() => {

444

if (promise.IsExclusive)

444

if (promise.IsExclusive)

445

promise.Cancel();

445

promise.Cancel();

446

});

446

});

447

};

447

};

448

449

ErrorHandler<T> errorHandler;

449

ErrorHandler<T> errorHandler;

450

451

if (error != null)

451

if (error != null)

452

errorHandler = delegate(Exception e) {

452

errorHandler = delegate(Exception e) {

453

try {

453

try {

454

var promise = error(e);

454

var promise = error(e);

455

456

promise.Last(

456

promise.Last(

457

medium.Resolve,

457

medium.Resolve,

458

medium.Reject,

458

medium.Reject,

459

() => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка

459

() => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка

460

);

460

);

461

462

// notify chained operation that it's not needed anymore

462

// notify chained operation that it's not needed anymore

463

// порядок вызова Then, Cancelled важен, поскольку от этого

463

// порядок вызова Then, Cancelled важен, поскольку от этого

464

// зависит IsExclusive

464

// зависит IsExclusive

465

medium.Cancelled(() => {

465

medium.Cancelled(() => {

466

if (promise.IsExclusive)

466

if (promise.IsExclusive)

467

promise.Cancel();

467

promise.Cancel();

468

});

468

});

469

} catch (Exception e2) {

469

} catch (Exception e2) {

470

medium.Reject(e2);

470

medium.Reject(e2);

471

}

471

}

472

return default(T);

472

return default(T);

473

};

473

};

474

else

474

else

475

errorHandler = err => {

475

errorHandler = err => {

476

medium.Reject(err);

476

medium.Reject(err);

477

return default(T);

477

return default(T);

478

};

478

};

479

480

481

Action cancelHandler;

481

Action cancelHandler;

482

if (cancel != null)

482

if (cancel != null)

483

cancelHandler = () => {

483

cancelHandler = () => {

484

if (cancel != null)

484

if (cancel != null)

485

cancel();

485

cancel();

486

medium.Cancel();

486

medium.Cancel();

487

};

487

};

488

else

488

else

489

cancelHandler = medium.Cancel;

489

cancelHandler = medium.Cancel;

490

491

AddHandler(

491

AddHandler(

492

resultHandler,

492

resultHandler,

493

errorHandler,

493

errorHandler,

494

cancelHandler,

494

cancelHandler,

495

null

495

null

496

);

496

);

497

498

return medium;

498

return medium;

499

}

499

}

500

501

public IPromise<TNew> Chain<TNew>(ResultMapper<T, IPromise<TNew>> chained, ErrorHandler<IPromise<TNew>> error) {

501

public IPromise<TNew> Chain<TNew>(ResultMapper<T, IPromise<TNew>> chained, ErrorHandler<IPromise<TNew>> error) {

502

return Chain(chained, error, null);

502

return Chain(chained, error, null);

503

}

503

}

504

505

public IPromise<TNew> Chain<TNew>(ResultMapper<T, IPromise<TNew>> chained) {

505

public IPromise<TNew> Chain<TNew>(ResultMapper<T, IPromise<TNew>> chained) {

506

return Chain(chained, null, null);

506

return Chain(chained, null, null);

507

}

507

}

508

509

public IPromise<T> Cancelled(Action handler) {

509

public IPromise<T> Cancelled(Action handler) {

510

var medium = new Promise<T>(this,true);

510

var medium = new Promise<T>(this,true);

511

AddHandler(null, null, handler, medium);

511

AddHandler(null, null, handler, medium);

512

return medium;

512

return medium;

513

}

513

}

514

515

/// <summary>

515

/// <summary>

516

/// Adds the specified handler for all cases (success, error, cancel)

516

/// Adds the specified handler for all cases (success, error, cancel)

517

/// </summary>

517

/// </summary>

518

/// <param name="handler">The handler that will be called anyway</param>

518

/// <param name="handler">The handler that will be called anyway</param>

519

/// <returns>self</returns>

519

/// <returns>self</returns>

520

public IPromise<T> Anyway(Action handler) {

520

public IPromise<T> Anyway(Action handler) {

521

Safe.ArgumentNotNull(handler, "handler");

521

Safe.ArgumentNotNull(handler, "handler");

522

523

AddHandler(

523

AddHandler(

524

x => handler(),

524

x => handler(),

525

e => {

525

e => {

526

handler();

526

handler();

527

throw new TransientPromiseException(e);

527

throw new TransientPromiseException(e);

528

},

528

},

529

handler,

529

handler,

530

null

530

null

531

);

531

);

532

return this;

532

return this;

533

}

533

}

534

535

/// <summary>

535

/// <summary>

536

/// Преобразует результат обещания к нужному типу

536

/// Преобразует результат обещания к нужному типу

537

/// </summary>

537

/// </summary>

538

/// <typeparam name="T2"></typeparam>

538

/// <typeparam name="T2"></typeparam>

539

/// <returns></returns>

539

/// <returns></returns>

540

public IPromise<T2> Cast<T2>() {

540

public IPromise<T2> Cast<T2>() {

541

return Then(x => (T2)(object)x, null);

541

return Then(x => (T2)(object)x, null);

542

}

542

}

543

544

/// <summary>

544

/// <summary>

545

/// Дожидается отложенного обещания и в случае успеха, возвращает

545

/// Дожидается отложенного обещания и в случае успеха, возвращает

546

/// его, результат, в противном случае бросает исключение.

546

/// его, результат, в противном случае бросает исключение.

547

/// </summary>

547

/// </summary>

548

/// <remarks>

548

/// <remarks>

549

/// <para>

549

/// <para>

550

/// Если ожидание обещания было прервано по таймауту, это не значит,

550

/// Если ожидание обещания было прервано по таймауту, это не значит,

551

/// что обещание было отменено или что-то в этом роде, это только

551

/// что обещание было отменено или что-то в этом роде, это только

552

/// означает, что мы его не дождались, однако все зарегистрированные

552

/// означает, что мы его не дождались, однако все зарегистрированные

553

/// обработчики, как были так остались и они будут вызваны, когда

553

/// обработчики, как были так остались и они будут вызваны, когда

554

/// обещание будет выполнено.

554

/// обещание будет выполнено.

555

/// </para>

555

/// </para>

556

/// <para>

556

/// <para>

557

/// Такое поведение вполне оправдано поскольку таймаут может истечь

557

/// Такое поведение вполне оправдано поскольку таймаут может истечь

558

/// в тот момент, когда началась обработка цепочки обработчиков, и

558

/// в тот момент, когда началась обработка цепочки обработчиков, и

559

/// к тому же текущее обещание может стоять в цепочке обещаний и его

559

/// к тому же текущее обещание может стоять в цепочке обещаний и его

560

/// отклонение может привести к непрогнозируемому результату.

560

/// отклонение может привести к непрогнозируемому результату.

561

/// </para>

561

/// </para>

562

/// </remarks>

562

/// </remarks>

563

/// <param name="timeout">Время ожидания</param>

563

/// <param name="timeout">Время ожидания</param>

564

/// <returns>Результат выполнения обещания</returns>

564

/// <returns>Результат выполнения обещания</returns>

565

public T Join(int timeout) {

565

public T Join(int timeout) {

566

var evt = new ManualResetEvent(false);

566

var evt = new ManualResetEvent(false);

567

Anyway(() => evt.Set());

567

Anyway(() => evt.Set());

568

569

if (!evt.WaitOne(timeout, true))

569

if (!evt.WaitOne(timeout, true))

570

throw new TimeoutException();

570

throw new TimeoutException();

571

572

switch (m_state) {

572

switch (m_state) {

573

case SUCCEEDED_STATE:

573

case SUCCEEDED_STATE:

574

return m_result;

574

return m_result;

575

case CANCELLED_STATE:

575

case CANCELLED_STATE:

576

throw new OperationCanceledException();

576

throw new OperationCanceledException();

577

case REJECTED_STATE:

577

case REJECTED_STATE:

578

throw new TargetInvocationException(m_error);

578

throw new TargetInvocationException(m_error);

579

default:

579

default:

580

throw new ApplicationException(String.Format("Invalid promise state {0}", m_state));

580

throw new ApplicationException(String.Format("Invalid promise state {0}", m_state));

581

}

581

}

582

}

582

}

583

584

public T Join() {

584

public T Join() {

585

return Join(Timeout.Infinite);

585

return Join(Timeout.Infinite);

586

}

586

}

587

588

void AddHandler(ResultHandler<T> success, ErrorHandler<T> error, Action cancel, Promise<T> medium) {

588

void AddHandler(ResultHandler<T> success, ErrorHandler<T> error, Action cancel, Promise<T> medium) {

589

if (success != null || error != null)

589

if (success != null || error != null)

590

Interlocked.Increment(ref m_childrenCount);

590

Interlocked.Increment(ref m_childrenCount);

591

592

var handler = new HandlerDescriptor {

592

var handler = new HandlerDescriptor {

593

resultHandler = success,

593

resultHandler = success,

594

errorHandler = error,

594

errorHandler = error,

595

cancellHandler = cancel,

595

cancellHandler = cancel,

596

medium = medium

596

medium = medium

597

};

597

};

598

599

bool queued;

599

bool queued;

600

601

if (!IsResolved) {

601

if (!IsResolved) {

602

m_handlers.Enqueue(handler);

602

m_handlers.Enqueue(handler);

603

queued = true;

603

queued = true;

604

} else {

604

} else {

605

// the promise is in resolved state, just invoke the handled with minimum overhead

605

// the promise is in resolved state, just invoke the handled with minimum overhead

606

queued = false;

606

queued = false;

607

InvokeHandler(handler);

607

InvokeHandler(handler);

608

}

608

}

609

610

if (queued && IsResolved && m_handlers.TryDequeue(out handler))

610

if (queued && IsResolved && m_handlers.TryDequeue(out handler))

611

// if the promise have been resolved while we was adding handler to the queue

611

// if the promise have been resolved while we was adding handler to the queue

612

// we can't guarantee that someone is still processing it

612

// we can't guarantee that someone is still processing it

613

// therefore we will fetch a handler from the queue and execute it

613

// therefore we will fetch a handler from the queue and execute it

614

// note that fetched handler may be not the one that we have added

614

// note that fetched handler may be not the one that we have added

615

// even we can fetch no handlers at all :)

615

// even we can fetch no handlers at all :)

616

InvokeHandler(handler);

616

InvokeHandler(handler);

617

}

617

}

618

619

protected virtual void InvokeHandler(HandlerDescriptor handler) {

619

protected virtual void InvokeHandler(HandlerDescriptor handler) {

620

switch (m_state) {

620

switch (m_state) {

621

case SUCCEEDED_STATE:

621

case SUCCEEDED_STATE:

622

handler.Resolve(m_result);

622

handler.Resolve(m_result);

623

break;

623

break;

624

case REJECTED_STATE:

624

case REJECTED_STATE:

625

handler.Reject(m_error);

625

handler.Reject(m_error);

626

break;

626

break;

627

case CANCELLED_STATE:

627

case CANCELLED_STATE:

628

handler.Cancel();

628

handler.Cancel();

629

break;

629

break;

630

default:

630

default:

631

// do nothing

631

// do nothing

632

return;

632

return;

633

}

633

}

634

}

634

}

635

636

void OnStateChanged() {

636

void OnStateChanged() {

637

HandlerDescriptor handler;

637

HandlerDescriptor handler;

638

while (m_handlers.TryDequeue(out handler))

638

while (m_handlers.TryDequeue(out handler))

639

InvokeHandler(handler);

639

InvokeHandler(handler);

640

}

640

}

641

642

public bool IsExclusive {

642

public bool IsExclusive {

643

get {

643

get {

644

return m_childrenCount <= 1;

644

return m_childrenCount <= 1;

645

}

645

}

646

}

646

}

647

648

/// <summary>

648

/// <summary>

649

/// Объединяет несколько обещаний в одно, результатом которого является массив результатов других обещаний.

649

/// Объединяет несколько обещаний в одно, результатом которого является массив результатов других обещаний.

650

/// Если хотябы одно из переданных обещаний не будет выполнено, то новое обещение тоже не будет выполнено.

650

/// Если хотябы одно из переданных обещаний не будет выполнено, то новое обещение тоже не будет выполнено.

651

/// При отмене нового обещания, переданные обещания также будут отменены, если никто больше на них не подписан.

651

/// При отмене нового обещания, переданные обещания также будут отменены, если никто больше на них не подписан.

652

/// </summary>

652

/// </summary>

653

/// <param name="promises">Список обещаний. Если список пустой, то результирующее обещание возвращается уже выполненным.</param>

653

/// <param name="promises">Список обещаний. Если список пустой, то результирующее обещание возвращается уже выполненным.</param>

654

/// <returns>Обещание объединяющее в себе результат переданных обещаний.</returns>

654

/// <returns>Обещание объединяющее в себе результат переданных обещаний.</returns>

655

/// <exception cref="ArgumentNullException"><paramref name="promises"/> не может быть null</exception>

655

/// <exception cref="ArgumentNullException"><paramref name="promises"/> не может быть null</exception>

656

public static IPromise<T[]> CreateComposite(IList<IPromise<T>> promises) {

656

public static IPromise<T[]> CreateComposite(IList<IPromise<T>> promises) {

657

if (promises == null)

657

if (promises == null)

658

throw new ArgumentNullException();

658

throw new ArgumentNullException();

659

660

// создаем аккумулятор для результатов и результирующее обещание

660

// создаем аккумулятор для результатов и результирующее обещание

661

var result = new T[promises.Count];

661

var result = new T[promises.Count];

662

var promise = new Promise<T[]>();

662

var promise = new Promise<T[]>();

663

664

// special case

664

// special case

665

if (promises.Count == 0) {

665

if (promises.Count == 0) {

666

promise.Resolve(result);

666

promise.Resolve(result);

667

return promise;

667

return promise;

668

}

668

}

669

670

int pending = promises.Count;

670

int pending = promises.Count;

671

672

for (int i = 0; i < promises.Count; i++) {

672

for (int i = 0; i < promises.Count; i++) {

673

var dest = i;

673

var dest = i;

674

675

if (promises[i] != null) {

675

if (promises[i] != null) {

676

promises[i].Then(

676

promises[i].Then(

677

x => {

677

x => {

678

result[dest] = x;

678

result[dest] = x;

679

if (Interlocked.Decrement(ref pending) == 0)

679

if (Interlocked.Decrement(ref pending) == 0)

680

promise.Resolve(result);

680

promise.Resolve(result);

681

},

681

},

682

e => {

682

e => {

683

promise.Reject(e);

683

promise.Reject(e);

684

return default(T);

684

return default(T);

685

}

685

}

686

);

686

);

687

} else {

687

} else {

688

if (Interlocked.Decrement(ref pending) == 0)

688

if (Interlocked.Decrement(ref pending) == 0)

689

promise.Resolve(result);

689

promise.Resolve(result);

690

}

690

}

691

}

691

}

692

693

promise.Cancelled(

693

promise.Cancelled(

694

() => {

694

() => {

695

foreach (var d in promises)

695

foreach (var d in promises)

696

if (d != null && d.IsExclusive)

696

if (d != null && d.IsExclusive)

697

d.Cancel();

697

d.Cancel();

698

}

698

}

699

);

699

);

700

701

return promise;

701

return promise;

702

}

702

}

703

704

/// <summary>

704

/// <summary>

705

/// Объединяет несколько обещаний в одно. Результирующее обещание будет выполнено при

705

/// Объединяет несколько обещаний в одно. Результирующее обещание будет выполнено при

706

/// выполнении всех указанных обещаний. При этом возвращаемые значения первичных обещаний

706

/// выполнении всех указанных обещаний. При этом возвращаемые значения первичных обещаний

707

/// игнорируются.

707

/// игнорируются.

708

/// </summary>

708

/// </summary>

709

/// <param name="promises">Коллекция первичных обещаний, которые будут объеденены в одно.</param>

709

/// <param name="promises">Коллекция первичных обещаний, которые будут объеденены в одно.</param>

710

/// <returns>Новое обещание, объединяющее в себе переданные.</returns>

710

/// <returns>Новое обещание, объединяющее в себе переданные.</returns>

711

/// <remarks>

711

/// <remarks>

712

/// Если в коллекции встречаюься <c>null</c>, то они воспринимаются как выполненные обещания.

712

/// Если в коллекции встречаюься <c>null</c>, то они воспринимаются как выполненные обещания.

713

/// </remarks>

713

/// </remarks>

714

public static IPromise CreateComposite(ICollection<IPromise> promises) {

714

public static IPromise CreateComposite(ICollection<IPromise> promises) {

715

if (promises == null)

715

if (promises == null)

716

throw new ArgumentNullException();

716

throw new ArgumentNullException();

717

if (promises.Count == 0)

717

if (promises.Count == 0)

718

return Promise<object>.ResultToPromise(null);

718

return Promise<object>.ResultToPromise(null);

719

720

int countdown = promises.Count;

720

int countdown = promises.Count;

721

722

var result = new Promise<object>();

722

var result = new Promise<object>();

723

724

foreach (var d in promises) {

724

foreach (var d in promises) {

725

if (d == null) {

725

if (d == null) {

726

if (Interlocked.Decrement(ref countdown) == 0)

726

if (Interlocked.Decrement(ref countdown) == 0)

727

result.Resolve(null);

727

result.Resolve(null);

728

} else {

728

} else {

729

d.Then(() => {

729

d.Then(() => {

730

if (Interlocked.Decrement(ref countdown) == 0)

730

if (Interlocked.Decrement(ref countdown) == 0)

731

result.Resolve(null);

731

result.Resolve(null);

732

});

732

});

733

}

733

}

734

}

734

}

735

736

result.Cancelled(() => {

736

result.Cancelled(() => {

737

foreach (var d in promises)

737

foreach (var d in promises)

738

if (d != null && d.IsExclusive)

738

if (d != null && d.IsExclusive)

739

d.Cancel();

739

d.Cancel();

740

});

740

});

741

742

return result;

742

return result;

743

}

743

}

744

745

public static Promise<T> ResultToPromise(T result) {

745

public static Promise<T> ResultToPromise(T result) {

746

var p = new Promise<T>();

746

var p = new Promise<T>();

747

p.Resolve(result);

747

p.Resolve(result);

748

return p;

748

return p;

749

}

749

}

750

751

public static Promise<T> ExceptionToPromise(Exception error) {

751

public static Promise<T> ExceptionToPromise(Exception error) {

752

if (error == null)

752

if (error == null)

753

throw new ArgumentNullException();

753

throw new ArgumentNullException();

754

755

var p = new Promise<T>();

755

var p = new Promise<T>();

756

p.Reject(error);

756

p.Reject(error);

757

return p;

757

return p;

758

}

758

}

759

760

#region IPromiseBase explicit implementation

760

#region IPromiseBase explicit implementation

761

762

IPromise IPromise.Then(Action success, ErrorHandler error, Action cancel) {

762

IPromise IPromise.Then(Action success, ErrorHandler error, Action cancel) {

763

return Then(

763

return Then(

764

success != null ? new ResultHandler<T>(x => success()) : null,

764

success != null ? new ResultHandler<T>(x => success()) : null,

765

error != null ? new ErrorHandler<T>(e => {

765

error != null ? new ErrorHandler<T>(e => {

766

error(e);

766

error(e);

767

return default(T);

767

return default(T);

768

}) : null,

768

}) : null,

769

cancel

769

cancel

770

);

770

);

771

}

771

}

772

773

IPromise IPromise.Then(Action success, ErrorHandler error) {

773

IPromise IPromise.Then(Action success, ErrorHandler error) {

774

return Then(

774

return Then(

775

success != null ? new ResultHandler<T>(x => success()) : null,

775

success != null ? new ResultHandler<T>(x => success()) : null,

776

error != null ? new ErrorHandler<T>(e => {

776

error != null ? new ErrorHandler<T>(e => {

777

error(e);

777

error(e);

778

return default(T);

778

return default(T);

779

}) : null

779

}) : null

780

);

780

);

781

}

781

}

782

783

IPromise IPromise.Then(Action success) {

783

IPromise IPromise.Then(Action success) {

784

Safe.ArgumentNotNull(success, "success");

784

Safe.ArgumentNotNull(success, "success");

785

return Then(x => success());

785

return Then(x => success());

786

}

786

}

787

788

IPromise IPromise.Chain(Func<IPromise> chained, ErrorHandler<IPromise> error, Action cancel) {

788

IPromise IPromise.Chain(Func<IPromise> chained, ErrorHandler<IPromise> error, Action cancel) {

789

return ChainNoResult(chained, error, cancel);

789

return ChainNoResult(chained, error, cancel);

790

}

790

}

791

792

IPromise ChainNoResult(Func<IPromise> chained, ErrorHandler<IPromise> error, Action cancel) {

792

IPromise ChainNoResult(Func<IPromise> chained, ErrorHandler<IPromise> error, Action cancel) {

793

Safe.ArgumentNotNull(chained, "chained");

793

Safe.ArgumentNotNull(chained, "chained");

794

795

var medium = new Promise<object>(this, true);

795

var medium = new Promise<object>(this, true);

796

797

ResultHandler<T> resultHandler = delegate(T result) {

797

ResultHandler<T> resultHandler = delegate(T result) {

798

if (medium.IsCancelled)

798

if (medium.IsCancelled)

799

return;

799

return;

800

801

var promise = chained();

801

var promise = chained();

802

803

promise.Last(

803

promise.Last(

804

medium.Resolve,

804

medium.Resolve,

805

medium.Reject,

805

medium.Reject,

806

() => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка

806

() => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка

807

);

807

);

808

809

// notify chained operation that it's not needed anymore

809

// notify chained operation that it's not needed anymore

810

// порядок вызова Then, Cancelled важен, поскольку от этого

810

// порядок вызова Then, Cancelled важен, поскольку от этого

811

// зависит IsExclusive

811

// зависит IsExclusive

812

medium.Cancelled(() => {

812

medium.Cancelled(() => {

813

if (promise.IsExclusive)

813

if (promise.IsExclusive)

814

promise.Cancel();

814

promise.Cancel();

815

});

815

});

816

};

816

};

817

818

ErrorHandler<T> errorHandler;

818

ErrorHandler<T> errorHandler;

819

820

if (error != null)

820

if (error != null)

821

errorHandler = delegate(Exception e) {

821

errorHandler = delegate(Exception e) {

822

try {

822

try {

823

var promise = error(e);

823

var promise = error(e);

824

825

promise.Last(

825

promise.Last(

826

medium.Resolve,

826

medium.Resolve,

827

medium.Reject,

827

medium.Reject,

828

() => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка

828

() => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка

829

);

829

);

830

831

// notify chained operation that it's not needed anymore

831

// notify chained operation that it's not needed anymore

832

// порядок вызова Then, Cancelled важен, поскольку от этого

832

// порядок вызова Then, Cancelled важен, поскольку от этого

833

// зависит IsExclusive

833

// зависит IsExclusive

834

medium.Cancelled(() => {

834

medium.Cancelled(() => {

835

if (promise.IsExclusive)

835

if (promise.IsExclusive)

836

promise.Cancel();

836

promise.Cancel();

837

});

837

});

838

} catch (Exception e2) {

838

} catch (Exception e2) {

839

medium.Reject(e2);

839

medium.Reject(e2);

840

}

840

}

841

return default(T);

841

return default(T);

842

};

842

};

843

else

843

else

844

errorHandler = err => {

844

errorHandler = err => {

845

medium.Reject(err);

845

medium.Reject(err);

846

return default(T);

846

return default(T);

847

};

847

};

848

849

850

Action cancelHandler;

850

Action cancelHandler;

851

if (cancel != null)

851

if (cancel != null)

852

cancelHandler = () => {

852

cancelHandler = () => {

853

if (cancel != null)

853

if (cancel != null)

854

cancel();

854

cancel();

855

medium.Cancel();

855

medium.Cancel();

856

};

856

};

857

else

857

else

858

cancelHandler = medium.Cancel;

858

cancelHandler = medium.Cancel;

859

860

AddHandler(

860

AddHandler(

861

resultHandler,

861

resultHandler,

862

errorHandler,

862

errorHandler,

863

cancelHandler,

863

cancelHandler,

864

null

864

null

865

);

865

);

866

867

return medium;

867

return medium;

868

}

868

}

869

IPromise IPromise.Chain(Func<IPromise> chained, ErrorHandler<IPromise> error) {

869

IPromise IPromise.Chain(Func<IPromise> chained, ErrorHandler<IPromise> error) {

870

return ChainNoResult(chained, error, null);

870

return ChainNoResult(chained, error, null);

871

}

871

}

872

IPromise IPromise.Chain(Func<IPromise> chained) {

872

IPromise IPromise.Chain(Func<IPromise> chained) {

873

return ChainNoResult(chained, null, null);

873

return ChainNoResult(chained, null, null);

874

}

874

}

875

876

877

void IPromise.Last(Action success, ErrorHandler error, Action cancel) {

877

void IPromise.Last(Action success, ErrorHandler error, Action cancel) {

878

Last(x => success(), error, cancel);

878

Last(x => success(), error, cancel);

879

}

879

}

880

881

void IPromise.Last(Action success, ErrorHandler error) {

881

void IPromise.Last(Action success, ErrorHandler error) {

882

Last(x => success(), error, null);

882

Last(x => success(), error, null);

883

}

883

}

884

885

void IPromise.Last(Action success) {

885

void IPromise.Last(Action success) {

886

Last(x => success(), null, null);

886

Last(x => success(), null, null);

887

}

887

}

888

889

IPromise IPromise.Error(ErrorHandler error) {

889

IPromise IPromise.Error(ErrorHandler error) {

890

return Error(error);

890

return Error(error);

891

}

891

}

892

893

IPromise IPromise.Anyway(Action handler) {

893

IPromise IPromise.Anyway(Action handler) {

894

return Anyway(handler);

894

return Anyway(handler);

895

}

895

}

896

897

IPromise IPromise.Cancelled(Action handler) {

897

IPromise IPromise.Cancelled(Action handler) {

898

return Cancelled(handler);

898

return Cancelled(handler);

899

}

899

}

900

901

void IPromise.Join() {

901

void IPromise.Join() {

902

Join();

902

Join();

903

}

903

}

904

905

void IPromise.Join(int timeout) {

905

void IPromise.Join(int timeout) {

906

Join(timeout);

906

Join(timeout);

907

}

907

}

908

909

#endregion

909

#endregion

910

911

912

913

}

913

}

914

}

914

}

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             namespace Implab {
                 public interface IPromise: ICancellable {
                     /// <summary>
                     /// Check whereather the promise has no more than one dependent promise.
                     /// </summary>
                     bool IsExclusive {
                         get;
                     }
                     /// <summary>
                     /// Тип результата, получаемого через данное обещание.
                     /// </summary>
                     Type PromiseType { get; }
                     /// <summary>
-                    /// Обещание является выполненым, либо успешно, либо с ошибкой.
+                    /// Обещание является выполненым, либо успешно, либо с ошибкой, либо отменено.
                     /// </summary>
                     bool IsResolved { get; }
                     /// <summary>
                     /// Обещание было отменено.
                     /// </summary>
                     bool IsCancelled { get; }
                     IPromise Then(Action success, ErrorHandler error, Action cancel);
                     IPromise Then(Action success, ErrorHandler error);
                     IPromise Then(Action success);
                     IPromise Chain(Func<IPromise> chained, ErrorHandler<IPromise> error, Action cancel);
                     IPromise Chain(Func<IPromise> chained, ErrorHandler<IPromise> error);
                     IPromise Chain(Func<IPromise> chained);
                     /// <summary>
                     /// Добавляет последнй обработчик в цепочку обещаний, не создает промежуточных обещаний.
                     /// </summary>
                     /// <param name="success">Success.</param>
                     /// <param name="error">Error.</param>
                     /// <param name="cancel">Cancel.</param>
                     void Last(Action success, ErrorHandler error, Action cancel);
                     void Last(Action success, ErrorHandler error);
                     void Last(Action success);
                     IPromise Error(ErrorHandler error);
                     /// <summary>
                     /// Обрабатывает либо ошибку, либо результат. Событие отмены не обрабатывается.
                     /// </summary>
                     /// <param name="handler">Обработчик.</param>
                     /// <remarks>После обработке ошибки, она передается дальше.</remarks>
                     /// <summary>
                     /// Обрабатывает либо ошибку, либо результат, либо отмену обещания.
                     /// </summary>
                     /// <param name="handler">Обработчик.</param>
                     /// <remarks>После обработке ошибки, она передается дальше.</remarks>
                     IPromise Anyway(Action handler);
                     /// <summary>
                     /// Обработчик для регистрации отмены обещания, событие отмены не может быть подавлено.
                     /// </summary>
                     /// <returns>Новое обещание, связанное с текущим.</returns>
                     /// <param name="handler">Обработчик события.</param>
                     /// <remarks>Если обработчик вызывает исключение, то оно передается обработчику ошибки, результат работы
                     /// которого будет передан связанному обещанию</remarks>
                     IPromise Cancelled(Action handler);
                     /// <summary>
                     /// Преобразует результат обещания к заданному типу и возвращает новое обещание.
                     /// </summary>
                     IPromise<T> Cast<T>();
                     /// <summary>
                     /// Синхронизирует текущий поток с обещанием.
                     /// </summary>
                     void Join();
                     /// <summary>
                     /// Синхронизирует текущий поток с обещанием.
                     /// </summary>
                     /// <param name="timeout">Время ожидания, по его истечению возникнет исключение.</param>
                     /// <exception cref="TimeoutException">Превышено время ожидания.</exception>
                     void Join(int timeout);
                 }
             }

             using System;
             using System.Collections.Generic;
             using System.Reflection;
             using System.Diagnostics;
             using System.Threading;
             using Implab.Parallels;
             namespace Implab {
                 public delegate void ErrorHandler(Exception e);
                 public delegate T ErrorHandler<out T>(Exception e);
                 public delegate void ResultHandler<in T>(T result);
                 public delegate TNew ResultMapper<in TSrc,out TNew>(TSrc result);
                 /// <summary>
                 /// Класс для асинхронного получения результатов. Так называемое "обещание".
                 /// </summary>
                 /// <typeparam name="T">Тип получаемого результата</typeparam>
                 /// <remarks>
                 /// <para>Сервис при обращении к его методу дает обещаиние о выполнении операции,
                 /// клиент получив такое обещание может установить ряд обратных вызово для получения
                 /// событий выполнения обещания, тоесть завершения операции и предоставлении результатов.</para>
                 /// <para>
                 /// Обещение может быть как выполнено, так и выполнено с ошибкой. Для подписки на
                 /// данные события клиент должен использовать методы <c>Then</c>.
                 /// </para>
                 /// <para>
                 /// Сервис, в свою очередь, по окончанию выполнения операции (возможно с ошибкой),
                 /// использует методы <c>Resolve</c> либо <c>Reject</c> для оповещения клиетна о
                 /// выполнении обещания.
                 /// </para>
                 /// <para>
                 /// Если сервер успел выполнить обещание еще до того, как клиент на него подписался,
                 /// то в момент подписки клиента будут вызваны соответсвующие события в синхронном
                 /// режиме и клиент будет оповещен в любом случае. Иначе, обработчики добавляются в
                 /// список в порядке подписания и в этом же порядке они будут вызваны при выполнении
                 /// обещания.
                 /// </para>
                 /// <para>
                 /// Обрабатывая результаты обещания можно преобразовывать результаты либо инициировать
                 /// связанные асинхронные операции, которые также возвращают обещания. Для этого следует
                 /// использовать соответствующую форму методе <c>Then</c>.
                 /// </para>
                 /// <para>
                 /// Также хорошим правилом является то, что <c>Resolve</c> и <c>Reject</c> должен вызывать
                 /// только инициатор обещания иначе могут возникнуть противоречия.
                 /// </para>
                 /// </remarks>
                 public class Promise<T> : IPromise<T> {
                     protected struct HandlerDescriptor {
                         public ResultHandler<T> resultHandler;
                         public ErrorHandler<T> errorHandler;
                         public Action cancellHandler;
                         public Promise<T> medium;
                         public void Resolve(T result) {
                             if (resultHandler != null) {
                                 try {
                                     resultHandler(result);
                                 } catch (Exception e) {
                                     Reject(e);
                                     return;
                                 }
                             }
                             if (medium != null)
                                 medium.Resolve(result);
                         }
                         public void Reject(Exception err) {
                             if (errorHandler != null) {
                                 try {
                                     var res = errorHandler(err);
                                     if (medium != null)
                                         medium.Resolve(res);
-                                } catch (TransientPromiseException err2) {
+                                    /*} catch (TransientPromiseException err2) {
                                     if (medium != null)
-                                        medium.Reject(err2.InnerException);
+                                        medium.Reject(err2.InnerException);*/
                                 } catch (Exception err2) {
                                     if (medium != null)
                                         medium.Reject(err2);
                                 }
                             } else if (medium != null)
                                 medium.Reject(err);
                         }
                         public void Cancel() {
                             if (cancellHandler != null) {
                                 try {
                                     cancellHandler();
                                 } catch (Exception err) {
                                     Reject(err);
                                     return;
                                 }
                             }
                             if (medium != null)
                                 medium.Cancel();
                         }
                     }
                     const int UNRESOLVED_SATE = 0;
                     const int TRANSITIONAL_STATE = 1;
                     const int SUCCEEDED_STATE = 2;
                     const int REJECTED_STATE = 3;
                     const int CANCELLED_STATE = 4;
                     readonly bool m_cancellable;
                     int m_childrenCount = 0;
                     int m_state;
                     T m_result;
                     Exception m_error;
                     readonly MTQueue<HandlerDescriptor> m_handlers = new MTQueue<HandlerDescriptor>();
                     public Promise() {
                         m_cancellable = true;
                     }
                     public Promise(IPromise parent, bool cancellable) {
                         m_cancellable = cancellable;
                         if (parent != null)
                             AddHandler(
                                 null,
                                 null,
                                 () => {
                                     if (parent.IsExclusive)
                                         parent.Cancel();
                                 },
                                 null
                             );
                     }
                     bool BeginTransit() {
                         return UNRESOLVED_SATE == Interlocked.CompareExchange(ref m_state, TRANSITIONAL_STATE, UNRESOLVED_SATE);
                     }
                     void CompleteTransit(int state) {
                         if (TRANSITIONAL_STATE != Interlocked.CompareExchange(ref m_state, state, TRANSITIONAL_STATE))
                             throw new InvalidOperationException("Can't complete transition when the object isn't in the transitional state");
                     }
                     void WaitTransition() {
                         while (m_state == TRANSITIONAL_STATE) {
                             Thread.MemoryBarrier();
                         }
                     }
                     public bool IsResolved {
                         get {
                             Thread.MemoryBarrier();
                             return m_state > 1;
                         }
                     }
                     public bool IsCancelled {
                         get {
                             Thread.MemoryBarrier();
                             return m_state == CANCELLED_STATE;
                         }
                     }
                     public Type PromiseType {
                         get { return typeof(T); }
                     }
                     /// <summary>
                     /// Выполняет обещание, сообщая об успешном выполнении.
                     /// </summary>
                     /// <param name="result">Результат выполнения.</param>
                     /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
                     public void Resolve(T result) {
                         if (BeginTransit()) {
                             m_result = result;
                             CompleteTransit(SUCCEEDED_STATE);
                             OnStateChanged();
                         } else {
                             WaitTransition();
                             if (m_state != CANCELLED_STATE)
                                 throw new InvalidOperationException("The promise is already resolved");
                         }
                     }
                     /// <summary>
                     /// Выполняет обещание, сообщая об успешном выполнении. Результатом выполнения будет пустое значения.
                     /// </summary>
                     /// <remarks>
                     /// Данный вариант удобен в случаях, когда интересен факт выполнения операции, нежели полученное значение.
                     /// </remarks>
                     public void Resolve() {
                         Resolve(default(T));
                     }
                     /// <summary>
                     /// Выполняет обещание, сообщая об ошибке
                     /// </summary>
                     /// <remarks>
                     /// Поскольку обещание должно работать в многопточной среде, при его выполнении сразу несколько потоков
                     /// могу вернуть ошибку, при этом только первая будет использована в качестве результата, остальные
                     /// будут проигнорированы.
                     /// </remarks>
                     /// <param name="error">Исключение возникшее при выполнении операции</param>
                     /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
                     public void Reject(Exception error) {
                         if (BeginTransit()) {
-                            m_error = error;
+                            m_error = error is TransientPromiseException ? error.InnerException : error;
                             CompleteTransit(REJECTED_STATE);
                             OnStateChanged();
                         } else {
                             WaitTransition();
                             if (m_state == SUCCEEDED_STATE)
                                 throw new InvalidOperationException("The promise is already resolved");
                         }
                     }
                     /// <summary>
                     /// Отменяет операцию, если это возможно.
                     /// </summary>
                     /// <remarks>Для определения была ли операция отменена следует использовать свойство <see cref="IsCancelled"/>.</remarks>
                     public void Cancel() {
                         if (m_cancellable && BeginTransit()) {
                             CompleteTransit(CANCELLED_STATE);
                             OnStateChanged();
                         }
                     }
                     public IPromise<T> Then(ResultHandler<T> success, ErrorHandler<T> error, Action cancel) {
                         if (success == null && error == null && cancel == null)
                             return this;
                         var medium = new Promise<T>(this, true);
                         AddHandler(success, error, cancel, medium);
                         return medium;
                     }
                     /// <summary>
                     /// Adds new handlers to this promise.
                     /// </summary>
                     /// <param name="success">The handler of the successfully completed operation.
                     /// This handler will recieve an operation result as a parameter.</param>
                     /// <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>
                     /// <returns>The new promise chained to this one.</returns>
                     public IPromise<T> Then(ResultHandler<T> success, ErrorHandler<T> error) {
                         if (success == null && error == null)
                             return this;
                         var medium = new Promise<T>(this, true);
                         AddHandler(success, error, null, medium);
                         return medium;
                     }
                     public IPromise<T> Then(ResultHandler<T> success) {
                         if (success == null)
                             return this;
                         var medium = new Promise<T>(this, true);
                         AddHandler(success, null, null, medium);
                         return medium;
                     }
                     /// <summary>
                     /// Последний обработчик в цепочки обещаний.
                     /// </summary>
                     /// <param name="success"></param>
                     /// <param name="error"></param>
                     /// <param name="cancel"></param>
                     /// <remarks>
                     /// <para>
                     /// Данный метод не создает связанного с текущим обещания и предназначен для окончания
                     /// фсинхронной цепочки.
                     /// </para>
                     /// <para>
                     /// Если данный метод вызвать несколько раз, либо добавить другие обработчики, то цепочка
                     /// не будет одиночной <see cref="IsExclusive"/> и, как следствие, будет невозможна отмена
                     /// всей цепи обещаний снизу (с самого последнего обещания).
                     /// </para>
                     /// </remarks>
                     public void Last(ResultHandler<T> success, ErrorHandler error, Action cancel) {
                         if (success == null && error == null && cancel == null)
                             return;
                         ErrorHandler<T> errorHandler = null;
                         if (error != null)
                             errorHandler = err => {
                                 error(err);
                                 return default(T);
                             };
                         AddHandler(success, errorHandler, cancel, null);
                     }
                     public void Last(ResultHandler<T> success, ErrorHandler error) {
                         Last(success, error, null);
                     }
                     public void Last(ResultHandler<T> success) {
                         Last(success, null, null);
                     }
                     public IPromise Error(ErrorHandler error) {
                         if (error == null)
                             return this;
                         var medium = new Promise<T>(this, true);
                         AddHandler(
                             null,
                             e => {
                                 error(e);
                                 return default(T);
                             },
                             null,
                             medium
                         );
                         return medium;
                     }
                     /// <summary>
                     /// Handles error and allows to keep the promise.
                     /// </summary>
                     /// <remarks>
                     /// If the specified handler throws an exception, this exception will be used to reject the promise.
                     /// </remarks>
                     /// <param name="handler">The error handler which returns the result of the promise.</param>
                     /// <returns>New promise.</returns>
                     public IPromise<T> Error(ErrorHandler<T> handler) {
                         if (handler == null)
                             return this;
                         var medium = new Promise<T>(this, true);
                         AddHandler(null, handler, null, medium);
                         return medium;
                     }
                     /// <summary>
                     /// Позволяет преобразовать результат выполения операции к новому типу.
                     /// </summary>
                     /// <typeparam name="TNew">Новый тип результата.</typeparam>
                     /// <param name="mapper">Преобразование результата к новому типу.</param>
                     /// <param name="error">Обработчик ошибки. Данный обработчик получит
                     /// исключение возникшее при выполнении операции.</param>
                     /// <returns>Новое обещание, которое будет выполнено при выполнении исходного обещания.</returns>
                     /// <param name = "cancel"></param>
                     public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler<TNew> error, Action cancel) {
                         Safe.ArgumentNotNull(mapper, "mapper");
                         // создаем прицепленное обещание
                         var medium = new Promise<TNew>(this, true);
                         ResultHandler<T> resultHandler = result => medium.Resolve(mapper(result));
                         ErrorHandler<T> errorHandler;
                         if (error != null)
                             errorHandler = e => {
                                 try {
                                     medium.Resolve(error(e));
                                 } catch (Exception e2) {
                                     // в случае ошибки нужно передать исключение дальше по цепочке
                                     medium.Reject(e2);
                                 }
                                 return default(T);
                             };
                         else
                             errorHandler = e => {
                                 medium.Reject(e);
                                 return default(T);
                             };
                         Action cancelHandler;
                         if (cancel != null)
                             cancelHandler = () => {
                                 cancel();
                                 medium.Cancel();
                             };
                         else
                             cancelHandler = medium.Cancel;
                         AddHandler(
                             resultHandler,
                             errorHandler,
                             cancelHandler,
                             null
                         );
                         return medium;
                     }
                     public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler<TNew> error) {
                         return Then(mapper, error, null);
                     }
                     public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper) {
                         return Then(mapper, null, null);
                     }
                     /// <summary>
                     /// Сцепляет несколько аснхронных операций. Указанная асинхронная операция будет вызвана после
                     /// выполнения текущей, а результат текущей операции может быть использован для инициализации
                     /// новой операции.
                     /// </summary>
                     /// <typeparam name="TNew">Тип результата указанной асинхронной операции.</typeparam>
                     /// <param name="chained">Асинхронная операция, которая должна будет начаться после выполнения текущей.</param>
                     /// <param name="error">Обработчик ошибки. Данный обработчик получит
                     /// исключение возникшее при выполнении текуещй операции.</param>
                     /// <returns>Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции.</returns>
                     /// <param name = "cancel"></param>
                     public IPromise<TNew> Chain<TNew>(ResultMapper<T, IPromise<TNew>> chained, ErrorHandler<IPromise<TNew>> error, Action cancel) {
                         Safe.ArgumentNotNull(chained, "chained");
                         // проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно
                         // создать посредника, к которому будут подвызяваться следующие обработчики.
                         // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы
                         // передать через него результаты работы.
                         var medium = new Promise<TNew>(this, true);
                         ResultHandler<T> resultHandler = delegate(T result) {
                             if (medium.IsCancelled)
                                 return;
                             var promise = chained(result);
                             promise.Last(
                                 medium.Resolve,
                                 medium.Reject,
                                 () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
                             );
                             // notify chained operation that it's not needed anymore
                             // порядок вызова Then, Cancelled важен, поскольку от этого
                             // зависит IsExclusive
                             medium.Cancelled(() => {
                                 if (promise.IsExclusive)
                                     promise.Cancel();
                             });
                         };
                         ErrorHandler<T> errorHandler;
                         if (error != null)
                             errorHandler = delegate(Exception e) {
                                 try {
                                     var promise = error(e);
                                     promise.Last(
                                         medium.Resolve,
                                         medium.Reject,
                                         () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
                                     );
                                     // notify chained operation that it's not needed anymore
                                     // порядок вызова Then, Cancelled важен, поскольку от этого
                                     // зависит IsExclusive
                                     medium.Cancelled(() => {
                                         if (promise.IsExclusive)
                                             promise.Cancel();
                                     });
                                 } catch (Exception e2) {
                                     medium.Reject(e2);
                                 }
                                 return default(T);
                             };
                         else
                             errorHandler = err => {
                                 medium.Reject(err);
                                 return default(T);
                             };
                         Action cancelHandler;
                         if (cancel != null)
                             cancelHandler = () => {
                                 if (cancel != null)
                                     cancel();
                                 medium.Cancel();
                             };
                         else
                             cancelHandler = medium.Cancel;
                         AddHandler(
                             resultHandler,
                             errorHandler,
                             cancelHandler,
                             null
                         );
                         return medium;
                     }
                     public IPromise<TNew> Chain<TNew>(ResultMapper<T, IPromise<TNew>> chained, ErrorHandler<IPromise<TNew>> error) {
                         return Chain(chained, error, null);
                     }
                     public IPromise<TNew> Chain<TNew>(ResultMapper<T, IPromise<TNew>> chained) {
                         return Chain(chained, null, null);
                     }
                     public IPromise<T> Cancelled(Action handler) {
                         var medium = new Promise<T>(this,true);
                         AddHandler(null, null, handler, medium);
                         return medium;
                     }
                     /// <summary>
                     /// Adds the specified handler for all cases (success, error, cancel)
                     /// </summary>
                     /// <param name="handler">The handler that will be called anyway</param>
                     /// <returns>self</returns>
                     public IPromise<T> Anyway(Action handler) {
                         Safe.ArgumentNotNull(handler, "handler");
                         AddHandler(
                             x => handler(),
                             e => {
                                 handler();
                                 throw new TransientPromiseException(e);
                             },
                             handler,
                             null
                         );
                         return this;
                     }
                     /// <summary>
                     /// Преобразует результат обещания к нужному типу
                     /// </summary>
                     /// <typeparam name="T2"></typeparam>
                     /// <returns></returns>
                     public IPromise<T2> Cast<T2>() {
                         return Then(x => (T2)(object)x, null);
                     }
                     /// <summary>
                     /// Дожидается отложенного обещания и в случае успеха, возвращает
                     /// его, результат, в противном случае бросает исключение.
                     /// </summary>
                     /// <remarks>
                     /// <para>
                     /// Если ожидание обещания было прервано по таймауту, это не значит,
                     /// что обещание было отменено или что-то в этом роде, это только
                     /// означает, что мы его не дождались, однако все зарегистрированные
                     /// обработчики, как были так остались и они будут вызваны, когда
                     /// обещание будет выполнено.
                     /// </para>
                     /// <para>
                     /// Такое поведение вполне оправдано поскольку таймаут может истечь
                     /// в тот момент, когда началась обработка цепочки обработчиков, и
                     /// к тому же текущее обещание может стоять в цепочке обещаний и его
                     /// отклонение может привести к непрогнозируемому результату.
                     /// </para>
                     /// </remarks>
                     /// <param name="timeout">Время ожидания</param>
                     /// <returns>Результат выполнения обещания</returns>
                     public T Join(int timeout) {
                         var evt = new ManualResetEvent(false);
                         Anyway(() => evt.Set());
                         if (!evt.WaitOne(timeout, true))
                             throw new TimeoutException();
                         switch (m_state) {
                             case SUCCEEDED_STATE:
                                 return m_result;
                             case CANCELLED_STATE:
                                 throw new OperationCanceledException();
                             case REJECTED_STATE:
                                 throw new TargetInvocationException(m_error);
                             default:
                                 throw new ApplicationException(String.Format("Invalid promise state {0}", m_state));
                         }
                     }
                     public T Join() {
                         return Join(Timeout.Infinite);
                     }
                     void AddHandler(ResultHandler<T> success, ErrorHandler<T> error, Action cancel, Promise<T> medium) {
                         if (success != null || error != null)
                             Interlocked.Increment(ref m_childrenCount);
                         var handler = new HandlerDescriptor {
                             resultHandler = success,
                             errorHandler = error,
                             cancellHandler = cancel,
                             medium = medium
                         };
                         bool queued;
                         if (!IsResolved) {
                             m_handlers.Enqueue(handler);
                             queued = true;
                         } else {
                             // the promise is in resolved state, just invoke the handled with minimum overhead
                             queued = false;
                             InvokeHandler(handler);
                         }
                         if (queued && IsResolved && m_handlers.TryDequeue(out handler))
                             // if the promise have been resolved while we was adding handler to the queue
                             // we can't guarantee that someone is still processing it
                             // therefore we will fetch a handler from the queue and execute it
                             // note that fetched handler may be not the one that we have added
                             // even we can fetch no handlers at all :)
                             InvokeHandler(handler);
                     }
                     protected virtual void InvokeHandler(HandlerDescriptor handler) {
                         switch (m_state) {
                             case SUCCEEDED_STATE:
                                 handler.Resolve(m_result);
                                 break;
                             case REJECTED_STATE:
                                 handler.Reject(m_error);
                                 break;
                             case CANCELLED_STATE:
                                 handler.Cancel();
                                 break;
                             default:
                                 // do nothing
                                 return;
                         }
                     }
                     void OnStateChanged() {
                         HandlerDescriptor handler;
                         while (m_handlers.TryDequeue(out handler))
                             InvokeHandler(handler);
                     }
                     public bool IsExclusive {
                         get {
                             return m_childrenCount <= 1;
                         }
                     }
                     /// <summary>
                     /// Объединяет несколько обещаний в одно, результатом которого является массив результатов других обещаний.
                     /// Если хотябы одно из переданных обещаний не будет выполнено, то новое обещение тоже не будет выполнено.
                     /// При отмене нового обещания, переданные обещания также будут отменены, если никто больше на них не подписан.
                     /// </summary>
                     /// <param name="promises">Список обещаний. Если список пустой, то результирующее обещание возвращается уже выполненным.</param>
                     /// <returns>Обещание объединяющее в себе результат переданных обещаний.</returns>
                     /// <exception cref="ArgumentNullException"><paramref name="promises"/> не может быть null</exception>
                     public static IPromise<T[]> CreateComposite(IList<IPromise<T>> promises) {
                         if (promises == null)
                             throw new ArgumentNullException();
                         // создаем аккумулятор для результатов и результирующее обещание
                         var result = new T[promises.Count];
                         var promise = new Promise<T[]>();
                         // special case
                         if (promises.Count == 0) {
                             promise.Resolve(result);
                             return promise;
                         }
                         int pending = promises.Count;
                         for (int i = 0; i < promises.Count; i++) {
                             var dest = i;
                             if (promises[i] != null) {
                                 promises[i].Then(
                                     x => {
                                         result[dest] = x;
                                         if (Interlocked.Decrement(ref pending) == 0)
                                             promise.Resolve(result);
                                     },
                                     e => {
                                         promise.Reject(e);
                                         return default(T);
                                     }
                                 );
                             } else {
                                 if (Interlocked.Decrement(ref pending) == 0)
                                     promise.Resolve(result);
                             }
                         }
                         promise.Cancelled(
                             () => {
                                 foreach (var d in promises)
                                     if (d != null && d.IsExclusive)
                                         d.Cancel();
                             }
                         );
                         return promise;
                     }
                     /// <summary>
                     /// Объединяет несколько обещаний в одно. Результирующее обещание будет выполнено при
                     /// выполнении всех указанных обещаний. При этом возвращаемые значения первичных обещаний
                     /// игнорируются.
                     /// </summary>
                     /// <param name="promises">Коллекция первичных обещаний, которые будут объеденены в одно.</param>
                     /// <returns>Новое обещание, объединяющее в себе переданные.</returns>
                     /// <remarks>
                     /// Если в коллекции встречаюься <c>null</c>, то они воспринимаются как выполненные обещания.
                     /// </remarks>
                     public static IPromise CreateComposite(ICollection<IPromise> promises) {
                         if (promises == null)
                             throw new ArgumentNullException();
                         if (promises.Count == 0)
                             return Promise<object>.ResultToPromise(null);
                         int countdown = promises.Count;
                         var result = new Promise<object>();
                         foreach (var d in promises) {
                             if (d == null) {
                                 if (Interlocked.Decrement(ref countdown) == 0)
                                     result.Resolve(null);
                             } else {
                                 d.Then(() => {
                                     if (Interlocked.Decrement(ref countdown) == 0)
                                         result.Resolve(null);
                                 });
                             }
                         }
                         result.Cancelled(() => {
                             foreach (var d in promises)
                                 if (d != null && d.IsExclusive)
                                     d.Cancel();
                         });
                         return result;
                     }
                     public static Promise<T> ResultToPromise(T result) {
                         var p = new Promise<T>();
                         p.Resolve(result);
                         return p;
                     }
                     public static Promise<T> ExceptionToPromise(Exception error) {
                         if (error == null)
                             throw new ArgumentNullException();
                         var p = new Promise<T>();
                         p.Reject(error);
                         return p;
                     }
                     #region IPromiseBase explicit implementation
                     IPromise IPromise.Then(Action success, ErrorHandler error, Action cancel) {
                         return Then(
                             success != null ? new ResultHandler<T>(x => success()) : null,
                             error != null ? new ErrorHandler<T>(e => {
                                 error(e);
                                 return default(T);
                             }) : null,
                             cancel
                         );
                     }
                     IPromise IPromise.Then(Action success, ErrorHandler error) {
                         return Then(
                             success != null ? new ResultHandler<T>(x => success()) : null,
                             error != null ? new ErrorHandler<T>(e => {
                                 error(e);
                                 return default(T);
                             }) : null
                         );
                     }
                     IPromise IPromise.Then(Action success) {
                         Safe.ArgumentNotNull(success, "success");
                         return Then(x => success());
                     }
                     IPromise IPromise.Chain(Func<IPromise> chained, ErrorHandler<IPromise> error, Action cancel) {
                         return ChainNoResult(chained, error, cancel);
                     }
                     IPromise ChainNoResult(Func<IPromise> chained, ErrorHandler<IPromise> error, Action cancel) {
                             Safe.ArgumentNotNull(chained, "chained");
                         var medium = new Promise<object>(this, true);
                             ResultHandler<T> resultHandler = delegate(T result) {
                                 if (medium.IsCancelled)
                                     return;
                                 var promise = chained();
                                 promise.Last(
                                     medium.Resolve,
                                     medium.Reject,
                                     () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
                                 );
                                 // notify chained operation that it's not needed anymore
                                 // порядок вызова Then, Cancelled важен, поскольку от этого
                                 // зависит IsExclusive
                                 medium.Cancelled(() => {
                                     if (promise.IsExclusive)
                                         promise.Cancel();
                                 });
                             };
                             ErrorHandler<T> errorHandler;
                             if (error != null)
                                 errorHandler = delegate(Exception e) {
                                 try {
                                     var promise = error(e);
                                     promise.Last(
                                         medium.Resolve,
                                         medium.Reject,
                                         () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
                                     );
                                     // notify chained operation that it's not needed anymore
                                     // порядок вызова Then, Cancelled важен, поскольку от этого
                                     // зависит IsExclusive
                                     medium.Cancelled(() => {
                                         if (promise.IsExclusive)
                                             promise.Cancel();
                                     });
                                 } catch (Exception e2) {
                                     medium.Reject(e2);
                                 }
                                 return default(T);
                             };
                             else
                                 errorHandler = err => {
                                 medium.Reject(err);
                                 return default(T);
                             };
                             Action cancelHandler;
                             if (cancel != null)
                                 cancelHandler = () => {
                                 if (cancel != null)
                                     cancel();
                                 medium.Cancel();
                             };
                             else
                                 cancelHandler = medium.Cancel;
                             AddHandler(
                                 resultHandler,
                                 errorHandler,
                                 cancelHandler,
                                 null
                             );
                             return medium;
                     }
                     IPromise IPromise.Chain(Func<IPromise> chained, ErrorHandler<IPromise> error) {
                         return ChainNoResult(chained, error, null);
                     }
                     IPromise IPromise.Chain(Func<IPromise> chained) {
                         return ChainNoResult(chained, null, null);
                     }
                     void IPromise.Last(Action success, ErrorHandler error, Action cancel) {
                         Last(x => success(), error, cancel);
                     }
                     void IPromise.Last(Action success, ErrorHandler error) {
                         Last(x => success(), error, null);
                     }
                     void IPromise.Last(Action success) {
                         Last(x => success(), null, null);
                     }
                     IPromise IPromise.Error(ErrorHandler error) {
                         return Error(error);
                     }
                     IPromise IPromise.Anyway(Action handler) {
                         return Anyway(handler);
                     }
                     IPromise IPromise.Cancelled(Action handler) {
                         return Cancelled(handler);
                     }
                     void IPromise.Join() {
                         Join();
                     }
                     void IPromise.Join(int timeout) {
                         Join(timeout);
                     }
                     #endregion
                 }
             }