implab/ImplabNet Commit - r112:38d6a4db35d7

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.Threading;

4

using System.Threading;

5

using Implab.Parallels;

5

using Implab.Parallels;

6

7

namespace Implab {

7

namespace Implab {

8

9

/// <summary>

9

/// <summary>

10

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

10

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

11

/// </summary>

11

/// </summary>

12

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

12

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

13

/// <remarks>

13

/// <remarks>

14

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

14

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

15

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

15

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

16

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

16

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

17

/// <para>

17

/// <para>

18

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

18

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

19

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

19

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

20

/// </para>

20

/// </para>

21

/// <para>

21

/// <para>

22

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

22

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

23

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

23

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

24

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

24

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

25

/// </para>

25

/// </para>

26

/// <para>

26

/// <para>

27

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

27

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

28

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

28

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

29

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

29

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

30

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

30

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

31

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

31

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

32

/// </para>

32

/// </para>

33

/// <para>

33

/// <para>

34

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

34

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

35

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

35

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

36

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

36

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

37

/// </para>

37

/// </para>

38

/// <para>

38

/// <para>

39

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

39

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

40

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

40

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

41

/// </para>

41

/// </para>

42

/// </remarks>

42

/// </remarks>

43

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

43

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

44

45

protected abstract class AbstractHandler : MTCustomQueueNode<AbstractHandler> {

45

protected abstract class AbstractHandler : MTCustomQueueNode<AbstractHandler> {

46

public abstract void Resolve(T result);

46

public abstract void Resolve(T result);

47

public abstract void Reject(Exception error);

47

public abstract void Reject(Exception error);

48

public abstract void Cancel();

48

public abstract void Cancel();

49

}

49

}

50

51

protected class RemapDescriptor<T2> : AbstractHandler {

51

protected class RemapDescriptor<T2> : AbstractHandler {

52

53

readonly Func<T,T2> m_resultHandler;

53

readonly Func<T,T2> m_resultHandler;

54

readonly Func<Exception,T2> m_errorHandler;

54

readonly Func<Exception,T2> m_errorHandler;

55

readonly Action m_cancellHandler;

55

readonly Action m_cancellHandler;

56

readonly Promise<T2> m_medium;

56

readonly Promise<T2> m_medium;

57

58

public RemapDescriptor(Func<T,T2> resultHandler, Func<Exception,T2> errorHandler, Action cancelHandler, Promise<T2> medium) {

58

public RemapDescriptor(Func<T,T2> resultHandler, Func<Exception,T2> errorHandler, Action cancelHandler, Promise<T2> medium) {

59

m_resultHandler = resultHandler;

59

m_resultHandler = resultHandler;

60

m_errorHandler = errorHandler;

60

m_errorHandler = errorHandler;

61

m_cancellHandler = cancelHandler;

61

m_cancellHandler = cancelHandler;

62

m_medium = medium;

62

m_medium = medium;

63

}

63

}

64

65

public override void Resolve(T result) {

65

public override void Resolve(T result) {

66

if (m_resultHandler != null) {

66

if (m_resultHandler != null) {

67

try {

67

try {

68

if (m_medium != null)

68

if (m_medium != null)

69

m_medium.Resolve(m_resultHandler(result));

69

m_medium.Resolve(m_resultHandler(result));

70

else

70

else

71

m_resultHandler(result);

71

m_resultHandler(result);

72

} catch (Exception e) {

72

} catch (Exception e) {

73

Reject(e);

73

Reject(e);

74

}

74

}

75

} else if(m_medium != null)

75

} else if(m_medium != null)

76

m_medium.Resolve(default(T2));

76

m_medium.Resolve(default(T2));

77

}

77

}

78

79

public override void Reject(Exception error) {

79

public override void Reject(Exception error) {

80

if (m_errorHandler != null) {

80

if (m_errorHandler != null) {

81

try {

81

try {

82

var res = m_errorHandler(error);

82

var res = m_errorHandler(error);

83

if (m_medium != null)

83

if (m_medium != null)

84

m_medium.Resolve(res);

84

m_medium.Resolve(res);

85

} catch (Exception err2) {

85

} catch (Exception err2) {

86

if (m_medium != null)

86

if (m_medium != null)

87

m_medium.Reject(err2);

87

m_medium.Reject(err2);

88

}

88

}

89

} else if (m_medium != null)

89

} else if (m_medium != null)

90

m_medium.Reject(error);

90

m_medium.Reject(error);

91

}

91

}

92

93

public override void Cancel() {

93

public override void Cancel() {

94

if (m_cancellHandler != null) {

94

if (m_cancellHandler != null) {

95

try {

95

try {

96

m_cancellHandler();

96

m_cancellHandler();

97

} catch (Exception err) {

97

} catch (Exception err) {

98

Reject(err);

98

Reject(err);

99

return;

99

return;

100

}

100

}

101

}

101

}

102

if (m_medium != null)

102

if (m_medium != null)

103

m_medium.Cancel();

103

m_medium.Cancel();

104

}

104

}

105

}

105

}

106

107

protected class HandlerDescriptor : AbstractHandler {

107

protected class HandlerDescriptor : AbstractHandler {

108

109

readonly Action<T> m_resultHandler;

109

readonly Action<T> m_resultHandler;

110

readonly Action<Exception> m_errorHandler;

110

readonly Action<Exception> m_errorHandler;

111

readonly Action m_cancellHandler;

111

readonly Action m_cancellHandler;

112

readonly Promise<T> m_medium;

112

readonly Promise<T> m_medium;

113

114

public HandlerDescriptor(Action<T> resultHandler, Action<Exception> errorHandler, Action cancelHandler, Promise<T> medium) {

114

public HandlerDescriptor(Action<T> resultHandler, Action<Exception> errorHandler, Action cancelHandler, Promise<T> medium) {

115

m_resultHandler = resultHandler;

115

m_resultHandler = resultHandler;

116

m_errorHandler = errorHandler;

116

m_errorHandler = errorHandler;

117

m_cancellHandler = cancelHandler;

117

m_cancellHandler = cancelHandler;

118

m_medium = medium;

118

m_medium = medium;

119

}

119

}

120

121

public override void Resolve(T result) {

121

public override void Resolve(T result) {

122

if (m_resultHandler != null) {

122

if (m_resultHandler != null) {

123

try {

123

try {

124

m_resultHandler(result);

124

m_resultHandler(result);

125

} catch (Exception e) {

125

} catch (Exception e) {

126

Reject(e);

126

Reject(e);

127

return;

127

return;

128

}

128

}

129

}

129

}

130

if(m_medium != null)

130

if(m_medium != null)

131

m_medium.Resolve(result);

131

m_medium.Resolve(result);

132

}

132

}

133

134

public override void Reject(Exception error) {

134

public override void Reject(Exception error) {

135

if (m_errorHandler != null) {

135

if (m_errorHandler != null) {

136

try {

136

try {

137

m_errorHandler(error);

137

m_errorHandler(error);

138

if (m_medium != null)

138

if (m_medium != null)

139

m_medium.Resolve(default(T));

139

m_medium.Resolve(default(T));

140

} catch (Exception err2) {

140

} catch (Exception err2) {

141

if (m_medium != null)

141

if (m_medium != null)

142

m_medium.Reject(err2);

142

m_medium.Reject(err2);

143

}

143

}

144

} else if (m_medium != null)

144

} else if (m_medium != null)

145

m_medium.Reject(error);

145

m_medium.Reject(error);

146

}

146

}

147

148

public override void Cancel() {

148

public override void Cancel() {

149

if (m_cancellHandler != null) {

149

if (m_cancellHandler != null) {

150

try {

150

try {

151

m_cancellHandler();

151

m_cancellHandler();

152

} catch (Exception err) {

152

} catch (Exception err) {

153

Reject(err);

153

Reject(err);

154

return;

154

return;

155

}

155

}

156

}

156

}

157

if (m_medium != null)

157

if (m_medium != null)

158

m_medium.Cancel();

158

m_medium.Cancel();

159

}

159

}

160

}

160

}

161

162

const int UNRESOLVED_SATE = 0;

162

const int UNRESOLVED_SATE = 0;

163

const int TRANSITIONAL_STATE = 1;

163

const int TRANSITIONAL_STATE = 1;

164

const int SUCCEEDED_STATE = 2;

164

const int SUCCEEDED_STATE = 2;

165

const int REJECTED_STATE = 3;

165

const int REJECTED_STATE = 3;

166

const int CANCELLED_STATE = 4;

166

const int CANCELLED_STATE = 4;

167

168

int m_childrenCount;

168

int m_childrenCount;

169

int m_state;

169

int m_state;

170

T m_result;

170

T m_result;

171

Exception m_error;

171

Exception m_error;

172

173

readonly MTCustomQueue<AbstractHandler> m_handlers = new MTCustomQueue<AbstractHandler>();

173

readonly MTCustomQueue<AbstractHandler> m_handlers = new MTCustomQueue<AbstractHandler>();

174

//readonly MTQueue<AbstractHandler> m_handlers = new MTQueue<AbstractHandler>();

174

//readonly MTQueue<AbstractHandler> m_handlers = new MTQueue<AbstractHandler>();

175

176

public Promise() {

176

public Promise() {

177

}

177

}

178

179

public Promise(IPromise parent) {

179

public Promise(IPromise parent) {

180

if (parent != null)

180

if (parent != null)

181

Add~~Mappers~~<T>(

181

AddHandler(

182

null,

182

null,

183

null,

183

null,

184

() => {

184

() => {

185

if (parent.IsExclusive)

185

if (parent.IsExclusive)

186

parent.Cancel();

186

parent.Cancel();

187

},

187

},

188

null,

188

null,

189

false

189

false

190

);

190

);

191

}

191

}

192

193

bool BeginTransit() {

193

bool BeginTransit() {

194

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

194

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

195

}

195

}

196

197

void CompleteTransit(int state) {

197

void CompleteTransit(int state) {

198

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

198

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

199

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

199

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

200

}

200

}

201

202

void WaitTransition() {

202

void WaitTransition() {

203

while (m_state == TRANSITIONAL_STATE) {

203

while (m_state == TRANSITIONAL_STATE) {

204

Thread.MemoryBarrier();

204

Thread.MemoryBarrier();

205

}

205

}

206

}

206

}

207

208

public bool IsResolved {

208

public bool IsResolved {

209

get {

209

get {

210

Thread.MemoryBarrier();

210

Thread.MemoryBarrier();

211

return m_state > 1;

211

return m_state > 1;

212

}

212

}

213

}

213

}

214

215

public bool IsCancelled {

215

public bool IsCancelled {

216

get {

216

get {

217

Thread.MemoryBarrier();

217

Thread.MemoryBarrier();

218

return m_state == CANCELLED_STATE;

218

return m_state == CANCELLED_STATE;

219

}

219

}

220

}

220

}

221

222

public Type PromiseType {

222

public Type PromiseType {

223

get { return typeof(T); }

223

get { return typeof(T); }

224

}

224

}

225

226

/// <summary>

226

/// <summary>

227

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

227

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

228

/// </summary>

228

/// </summary>

229

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

229

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

230

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

230

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

231

public void Resolve(T result) {

231

public void Resolve(T result) {

232

if (BeginTransit()) {

232

if (BeginTransit()) {

233

m_result = result;

233

m_result = result;

234

CompleteTransit(SUCCEEDED_STATE);

234

CompleteTransit(SUCCEEDED_STATE);

235

OnStateChanged();

235

OnStateChanged();

236

} else {

236

} else {

237

WaitTransition();

237

WaitTransition();

238

if (m_state != CANCELLED_STATE)

238

if (m_state != CANCELLED_STATE)

239

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

239

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

240

}

240

}

241

}

241

}

242

243

/// <summary>

243

/// <summary>

244

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

244

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

245

/// </summary>

245

/// </summary>

246

/// <remarks>

246

/// <remarks>

247

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

247

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

248

/// </remarks>

248

/// </remarks>

249

public void Resolve() {

249

public void Resolve() {

250

Resolve(default(T));

250

Resolve(default(T));

251

}

251

}

252

253

/// <summary>

253

/// <summary>

254

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

254

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

255

/// </summary>

255

/// </summary>

256

/// <remarks>

256

/// <remarks>

257

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

257

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

258

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

258

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

259

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

259

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

260

/// </remarks>

260

/// </remarks>

261

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

261

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

262

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

262

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

263

public void Reject(Exception error) {

263

public void Reject(Exception error) {

264

if (BeginTransit()) {

264

if (BeginTransit()) {

265

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

265

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

266

CompleteTransit(REJECTED_STATE);

266

CompleteTransit(REJECTED_STATE);

267

OnStateChanged();

267

OnStateChanged();

268

} else {

268

} else {

269

WaitTransition();

269

WaitTransition();

270

if (m_state == SUCCEEDED_STATE)

270

if (m_state == SUCCEEDED_STATE)

271

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

271

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

272

}

272

}

273

}

273

}

274

275

/// <summary>

275

/// <summary>

276

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

276

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

277

/// </summary>

277

/// </summary>

278

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

278

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

279

public void Cancel() {

279

public void Cancel() {

280

if (BeginTransit()) {

280

if (BeginTransit()) {

281

CompleteTransit(CANCELLED_STATE);

281

CompleteTransit(CANCELLED_STATE);

282

OnStateChanged();

282

OnStateChanged();

283

}

283

}

284

}

284

}

285

286

/// <summary>

286

/// <summary>

287

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

287

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

288

/// </summary>

288

/// </summary>

289

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

289

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

290

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

290

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

291

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

291

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

292

/// <remarks>

292

/// <remarks>

293

/// <para>

293

/// <para>

294

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

294

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

295

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

295

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

296

/// </para>

296

/// </para>

297

/// <para>

297

/// <para>

298

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

298

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

299

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

299

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

300

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

300

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

301

/// </para>

301

/// </para>

302

/// </remarks>

302

/// </remarks>

303

public void On(Action<T> success, Action<Exception> error, Action cancel) {

303

public void On(Action<T> success, Action<Exception> error, Action cancel) {

304

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

304

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

305

return;

305

return;

306

307

AddHandler(success, error, cancel, null, false);

307

AddHandler(success, error, cancel, null, false);

308

}

308

}

309

310

public void On(Action<T> success, Action<Exception> error) {

310

public void On(Action<T> success, Action<Exception> error) {

311

AddHandler(success, error, null, null, false);

311

AddHandler(success, error, null, null, false);

312

}

312

}

313

314

public void On(Action<T> success) {

314

public void On(Action<T> success) {

315

AddHandler(success, null, null, null, false);

315

AddHandler(success, null, null, null, false);

316

}

316

}

317

318

public void On(Action handler, PromiseEventType events) {

318

public void On(Action handler, PromiseEventType events) {

319

Safe.ArgumentNotNull(handler, "handler");

319

Safe.ArgumentNotNull(handler, "handler");

320

321

322

AddHandler(

322

AddHandler(

323

events.HasFlag(PromiseEventType.Success) ? new Action<T>(x => handler()) : null,

323

events.HasFlag(PromiseEventType.Success) ? new Action<T>(x => handler()) : null,

324

events.HasFlag(PromiseEventType.Error) ? new Action<Exception>( x => handler()) : null,

324

events.HasFlag(PromiseEventType.Error) ? new Action<Exception>( x => handler()) : null,

325

events.HasFlag(PromiseEventType.Cancelled) ? handler : null,

325

events.HasFlag(PromiseEventType.Cancelled) ? handler : null,

326

null,

326

null,

327

false

327

false

328

);

328

);

329

}

329

}

330

331

public IPromise Error(Action<Exception> error) {

331

public IPromise Error(Action<Exception> error) {

332

if (error == null)

332

if (error == null)

333

return this;

333

return this;

334

335

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

335

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

336

337

AddMappers(

337

AddMappers(

338

~~null~~,

338

x => x,

339

e => {

339

e => {

340

error(e);

340

error(e);

341

return default(T);

341

return default(T);

342

},

342

},

343

null,

343

null,

344

medium,

344

medium,

345

true

345

true

346

);

346

);

347

348

return medium;

348

return medium;

349

}

349

}

350

351

/// <summary>

351

/// <summary>

352

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

352

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

353

/// </summary>

353

/// </summary>

354

/// <remarks>

354

/// <remarks>

355

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

355

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

356

/// </remarks>

356

/// </remarks>

357

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

357

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

358

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

358

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

359

public IPromise<T> Error(Func<Exception,T> handler) {

359

public IPromise<T> Error(Func<Exception,T> handler) {

360

if (handler == null)

360

if (handler == null)

361

return this;

361

return this;

362

363

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

363

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

364

365

AddMappers(~~null~~, handler, null, medium, true);

365

AddMappers(x => x, handler, null, medium, true);

366

367

return medium;

367

return medium;

368

}

368

}

369

370

/// <summary>

370

/// <summary>

371

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

371

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

372

/// </summary>

372

/// </summary>

373

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

373

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

374

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

374

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

375

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

375

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

376

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

376

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

377

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

377

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

378

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

378

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

379

public IPromise<TNew> Then<TNew>(Func<T, TNew> mapper, Func<Exception,TNew> error, Action cancel) {

379

public IPromise<TNew> Then<TNew>(Func<T, TNew> mapper, Func<Exception,TNew> error, Action cancel) {

380

Safe.ArgumentNotNull(mapper, "mapper");

380

Safe.ArgumentNotNull(mapper, "mapper");

381

382

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

382

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

383

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

383

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

384

385

AddMappers(

385

AddMappers(

386

mapper,

386

mapper,

387

error,

387

error,

388

cancel,

388

cancel,

389

medium,

389

medium,

390

true

390

true

391

);

391

);

392

393

return medium;

393

return medium;

394

}

394

}

395

396

public IPromise<TNew> Then<TNew>(Func<T, TNew> mapper, Func<Exception,TNew> error) {

396

public IPromise<TNew> Then<TNew>(Func<T, TNew> mapper, Func<Exception,TNew> error) {

397

return Then(mapper, error, null);

397

return Then(mapper, error, null);

398

}

398

}

399

400

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

400

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

401

return Then(mapper, null, null);

401

return Then(mapper, null, null);

402

}

402

}

403

404

/// <summary>

404

/// <summary>

405

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

405

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

406

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

406

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

407

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

407

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

408

/// </summary>

408

/// </summary>

409

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

409

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

410

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

410

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

411

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

411

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

412

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

412

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

413

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

413

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

414

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

414

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

415

public IPromise<TNew> Chain<TNew>(Func<T, IPromise<TNew>> chained, Func<Exception,IPromise<TNew>> error, Action cancel) {

415

public IPromise<TNew> Chain<TNew>(Func<T, IPromise<TNew>> chained, Func<Exception,IPromise<TNew>> error, Action cancel) {

416

417

Safe.ArgumentNotNull(chained, "chained");

417

Safe.ArgumentNotNull(chained, "chained");

418

419

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

419

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

420

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

420

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

421

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

421

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

422

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

422

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

423

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

423

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

424

425

Func<T,T> resultHandler = delegate(T result) {

425

Func<T,T> resultHandler = delegate(T result) {

426

if (medium.IsCancelled)

426

if (medium.IsCancelled)

427

return default(T);

427

return default(T);

428

429

var promise = chained(result);

429

var promise = chained(result);

430

431

promise.On(

431

promise.On(

432

medium.Resolve,

432

medium.Resolve,

433

medium.Reject,

433

medium.Reject,

434

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

434

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

435

);

435

);

436

437

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

437

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

438

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

438

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

439

// зависит IsExclusive

439

// зависит IsExclusive

440

medium.On(

440

medium.On(

441

null,

441

null,

442

null,

442

null,

443

() => {

443

() => {

444

if (promise.IsExclusive)

444

if (promise.IsExclusive)

445

promise.Cancel();

445

promise.Cancel();

446

}

446

}

447

);

447

);

448

449

return default(T);

449

return default(T);

450

};

450

};

451

452

Func<Exception,T> errorHandler;

452

Func<Exception,T> errorHandler;

453

454

if (error != null)

454

if (error != null)

455

errorHandler = delegate(Exception e) {

455

errorHandler = delegate(Exception e) {

456

try {

456

try {

457

var promise = error(e);

457

var promise = error(e);

458

459

promise.On(

459

promise.On(

460

medium.Resolve,

460

medium.Resolve,

461

medium.Reject,

461

medium.Reject,

462

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

462

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

463

);

463

);

464

465

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

465

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

466

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

466

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

467

// зависит IsExclusive

467

// зависит IsExclusive

468

medium.Cancelled(() => {

468

medium.Cancelled(() => {

469

if (promise.IsExclusive)

469

if (promise.IsExclusive)

470

promise.Cancel();

470

promise.Cancel();

471

});

471

});

472

} catch (Exception e2) {

472

} catch (Exception e2) {

473

medium.Reject(e2);

473

medium.Reject(e2);

474

}

474

}

475

return default(T);

475

return default(T);

476

};

476

};

477

else

477

else

478

errorHandler = err => {

478

errorHandler = err => {

479

medium.Reject(err);

479

medium.Reject(err);

480

return default(T);

480

return default(T);

481

};

481

};

482

483

484

Action cancelHandler;

484

Action cancelHandler;

485

if (cancel != null)

485

if (cancel != null)

486

cancelHandler = () => {

486

cancelHandler = () => {

487

if (cancel != null)

487

if (cancel != null)

488

cancel();

488

cancel();

489

medium.Cancel();

489

medium.Cancel();

490

};

490

};

491

else

491

else

492

cancelHandler = medium.Cancel;

492

cancelHandler = medium.Cancel;

493

494

AddMappers(

494

AddMappers(

495

resultHandler,

495

resultHandler,

496

errorHandler,

496

errorHandler,

497

cancelHandler,

497

cancelHandler,

498

null,

498

null,

499

true

499

true

500

);

500

);

501

502

return medium;

502

return medium;

503

}

503

}

504

505

public IPromise<TNew> Chain<TNew>(Func<T, IPromise<TNew>> chained, Func<Exception,IPromise<TNew>> error) {

505

public IPromise<TNew> Chain<TNew>(Func<T, IPromise<TNew>> chained, Func<Exception,IPromise<TNew>> error) {

506

return Chain(chained, error, null);

506

return Chain(chained, error, null);

507

}

507

}

508

509

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

509

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

510

return Chain(chained, null, null);

510

return Chain(chained, null, null);

511

}

511

}

512

513

public IPromise<T> Cancelled(Action handler) {

513

public IPromise<T> Cancelled(Action handler) {

514

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

514

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

515

AddHandler(null, null, handler, medium, false);

515

AddHandler(null, null, handler, medium, false);

516

return medium;

516

return medium;

517

}

517

}

518

519

/// <summary>

519

/// <summary>

520

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

520

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

521

/// </summary>

521

/// </summary>

522

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

522

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

523

/// <returns>self</returns>

523

/// <returns>self</returns>

524

public IPromise<T> Anyway(Action handler) {

524

public IPromise<T> Anyway(Action handler) {

525

Safe.ArgumentNotNull(handler, "handler");

525

Safe.ArgumentNotNull(handler, "handler");

526

527

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

527

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

528

529

AddHandler(

529

AddHandler(

530

x => handler(),

530

x => handler(),

531

e => {

531

e => {

532

handler();

532

handler();

533

throw new TransientPromiseException(e);

533

throw new TransientPromiseException(e);

534

},

534

},

535

handler,

535

handler,

536

medium,

536

medium,

537

true

537

true

538

);

538

);

539

540

return medium;

540

return medium;

541

}

541

}

542

543

/// <summary>

543

/// <summary>

544

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

544

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

545

/// </summary>

545

/// </summary>

546

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

546

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

547

/// <returns></returns>

547

/// <returns></returns>

548

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

548

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

549

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

549

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

550

}

550

}

551

552

/// <summary>

552

/// <summary>

553

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

553

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

554

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

554

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

555

/// </summary>

555

/// </summary>

556

/// <remarks>

556

/// <remarks>

557

/// <para>

557

/// <para>

558

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

558

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

559

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

559

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

560

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

560

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

561

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

561

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

562

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

562

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

563

/// </para>

563

/// </para>

564

/// <para>

564

/// <para>

565

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

565

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

566

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

566

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

567

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

567

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

568

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

568

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

569

/// </para>

569

/// </para>

570

/// </remarks>

570

/// </remarks>

571

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

571

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

572

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

572

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

573

public T Join(int timeout) {

573

public T Join(int timeout) {

574

var evt = new ManualResetEvent(false);

574

var evt = new ManualResetEvent(false);

575

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

575

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

576

577

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

577

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

578

throw new TimeoutException();

578

throw new TimeoutException();

579

580

switch (m_state) {

580

switch (m_state) {

581

case SUCCEEDED_STATE:

581

case SUCCEEDED_STATE:

582

return m_result;

582

return m_result;

583

case CANCELLED_STATE:

583

case CANCELLED_STATE:

584

throw new OperationCanceledException();

584

throw new OperationCanceledException();

585

case REJECTED_STATE:

585

case REJECTED_STATE:

586

throw new TargetInvocationException(m_error);

586

throw new TargetInvocationException(m_error);

587

default:

587

default:

588

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

588

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

589

}

589

}

590

}

590

}

591

592

public T Join() {

592

public T Join() {

593

return Join(Timeout.Infinite);

593

return Join(Timeout.Infinite);

594

}

594

}

595

596

void AddMappers<T2>(Func<T,T2> success, Func<Exception,T2> error, Action cancel, Promise<T2> medium, bool inc) {

596

void AddMappers<T2>(Func<T,T2> success, Func<Exception,T2> error, Action cancel, Promise<T2> medium, bool inc) {

597

if (inc)

597

if (inc)

598

Interlocked.Increment(ref m_childrenCount);

598

Interlocked.Increment(ref m_childrenCount);

599

600

AbstractHandler handler = new RemapDescriptor<T2>(success, error, cancel, medium);

600

AbstractHandler handler = new RemapDescriptor<T2>(success, error, cancel, medium);

601

602

bool queued;

602

bool queued;

603

604

if (!IsResolved) {

604

if (!IsResolved) {

605

m_handlers.Enqueue(handler);

605

m_handlers.Enqueue(handler);

606

queued = true;

606

queued = true;

607

} else {

607

} else {

608

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

608

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

609

queued = false;

609

queued = false;

610

InvokeHandler(handler);

610

InvokeHandler(handler);

611

}

611

}

612

613

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

613

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

614

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

614

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

615

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

615

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

616

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

616

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

617

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

617

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

618

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

618

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

619

InvokeHandler(handler);

619

InvokeHandler(handler);

620

}

620

}

621

622

void AddHandler(Action<T> success, Action<Exception> error, Action cancel, Promise<T> medium, bool inc) {

622

void AddHandler(Action<T> success, Action<Exception> error, Action cancel, Promise<T> medium, bool inc) {

623

if (inc)

623

if (inc)

624

Interlocked.Increment(ref m_childrenCount);

624

Interlocked.Increment(ref m_childrenCount);

625

626

AbstractHandler handler = new HandlerDescriptor(success, error, cancel, medium);

626

AbstractHandler handler = new HandlerDescriptor(success, error, cancel, medium);

627

628

bool queued;

628

bool queued;

629

630

if (!IsResolved) {

630

if (!IsResolved) {

631

m_handlers.Enqueue(handler);

631

m_handlers.Enqueue(handler);

632

queued = true;

632

queued = true;

633

} else {

633

} else {

634

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

634

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

635

queued = false;

635

queued = false;

636

InvokeHandler(handler);

636

InvokeHandler(handler);

637

}

637

}

638

639

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

639

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

640

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

640

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

641

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

641

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

642

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

642

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

643

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

643

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

644

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

644

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

645

InvokeHandler(handler);

645

InvokeHandler(handler);

646

}

646

}

647

648

protected virtual void InvokeHandler(AbstractHandler handler) {

648

protected virtual void InvokeHandler(AbstractHandler handler) {

649

switch (m_state) {

649

switch (m_state) {

650

case SUCCEEDED_STATE:

650

case SUCCEEDED_STATE:

651

handler.Resolve(m_result);

651

handler.Resolve(m_result);

652

break;

652

break;

653

case REJECTED_STATE:

653

case REJECTED_STATE:

654

handler.Reject(m_error);

654

handler.Reject(m_error);

655

break;

655

break;

656

case CANCELLED_STATE:

656

case CANCELLED_STATE:

657

handler.Cancel();

657

handler.Cancel();

658

break;

658

break;

659

default:

659

default:

660

// do nothing

660

// do nothing

661

return;

661

return;

662

}

662

}

663

}

663

}

664

665

void OnStateChanged() {

665

void OnStateChanged() {

666

AbstractHandler handler;

666

AbstractHandler handler;

667

while (m_handlers.TryDequeue(out handler))

667

while (m_handlers.TryDequeue(out handler))

668

InvokeHandler(handler);

668

InvokeHandler(handler);

669

}

669

}

670

671

public bool IsExclusive {

671

public bool IsExclusive {

672

get {

672

get {

673

return m_childrenCount <= 1;

673

return m_childrenCount <= 1;

674

}

674

}

675

}

675

}

676

677

/// <summary>

677

/// <summary>

678

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

678

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

679

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

679

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

680

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

680

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

681

/// </summary>

681

/// </summary>

682

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

682

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

683

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

683

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

684

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

684

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

685

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

685

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

686

if (promises == null)

686

if (promises == null)

687

throw new ArgumentNullException();

687

throw new ArgumentNullException();

688

689

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

689

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

690

var result = new T[promises.Count];

690

var result = new T[promises.Count];

691

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

691

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

692

693

// special case

693

// special case

694

if (promises.Count == 0) {

694

if (promises.Count == 0) {

695

promise.Resolve(result);

695

promise.Resolve(result);

696

return promise;

696

return promise;

697

}

697

}

698

699

int pending = promises.Count;

699

int pending = promises.Count;

700

701

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

701

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

702

var dest = i;

702

var dest = i;

703

704

if (promises[i] != null) {

704

if (promises[i] != null) {

705

promises[i].On(

705

promises[i].On(

706

x => {

706

x => {

707

result[dest] = x;

707

result[dest] = x;

708

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

708

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

709

promise.Resolve(result);

709

promise.Resolve(result);

710

},

710

},

711

promise.Reject

711

promise.Reject

712

);

712

);

713

} else {

713

} else {

714

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

714

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

715

promise.Resolve(result);

715

promise.Resolve(result);

716

}

716

}

717

}

717

}

718

719

promise.Cancelled(

719

promise.Cancelled(

720

() => {

720

() => {

721

foreach (var d in promises)

721

foreach (var d in promises)

722

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

722

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

723

d.Cancel();

723

d.Cancel();

724

}

724

}

725

);

725

);

726

727

return promise;

727

return promise;

728

}

728

}

729

730

/// <summary>

730

/// <summary>

731

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

731

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

732

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

732

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

733

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

733

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

734

/// </summary>

734

/// </summary>

735

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

735

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

736

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

736

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

737

/// <remarks>

737

/// <remarks>

738

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

738

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

739

/// </remarks>

739

/// </remarks>

740

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

740

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

741

if (promises == null)

741

if (promises == null)

742

throw new ArgumentNullException();

742

throw new ArgumentNullException();

743

if (promises.Count == 0)

743

if (promises.Count == 0)

744

return Promise<object>.ResultToPromise(null);

744

return Promise<object>.ResultToPromise(null);

745

746

int countdown = promises.Count;

746

int countdown = promises.Count;

747

748

var result = new Promise<object>();

748

var result = new Promise<object>();

749

750

foreach (var d in promises) {

750

foreach (var d in promises) {

751

if (d == null) {

751

if (d == null) {

752

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

752

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

753

result.Resolve(null);

753

result.Resolve(null);

754

} else {

754

} else {

755

d.Then(() => {

755

d.Then(() => {

756

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

756

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

757

result.Resolve(null);

757

result.Resolve(null);

758

});

758

});

759

}

759

}

760

}

760

}

761

762

result.Cancelled(() => {

762

result.Cancelled(() => {

763

foreach (var d in promises)

763

foreach (var d in promises)

764

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

764

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

765

d.Cancel();

765

d.Cancel();

766

});

766

});

767

768

return result;

768

return result;

769

}

769

}

770

771

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

771

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

772

var p = new Promise<T>();

772

var p = new Promise<T>();

773

p.Resolve(result);

773

p.Resolve(result);

774

return p;

774

return p;

775

}

775

}

776

777

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

777

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

778

if (error == null)

778

if (error == null)

779

throw new ArgumentNullException();

779

throw new ArgumentNullException();

780

781

var p = new Promise<T>();

781

var p = new Promise<T>();

782

p.Reject(error);

782

p.Reject(error);

783

return p;

783

return p;

784

}

784

}

785

786

#region IPromiseBase explicit implementation

786

#region IPromiseBase explicit implementation

787

788

IPromise IPromise.Then(Action success, Action<Exception> error, Action cancel) {

788

IPromise IPromise.Then(Action success, Action<Exception> error, Action cancel) {

789

return Then(

789

return Then(

790

success != null ? new Func<T,T>(x => {

790

success != null ? new Func<T,T>(x => {

791

success();

791

success();

792

return x;

792

return x;

793

}) : null,

793

}) : null,

794

error != null ? new Func<Exception,T>(e => {

794

error != null ? new Func<Exception,T>(e => {

795

error(e);

795

error(e);

796

return default(T);

796

return default(T);

797

}) : null,

797

}) : null,

798

cancel

798

cancel

799

);

799

);

800

}

800

}

801

802

IPromise IPromise.Then(Action success, Action<Exception> error) {

802

IPromise IPromise.Then(Action success, Action<Exception> error) {

803

return Then(

803

return Then(

804

success != null ? new Func<T,T>(x => {

804

success != null ? new Func<T,T>(x => {

805

success();

805

success();

806

return x;

806

return x;

807

}) : null,

807

}) : null,

808

error != null ? new Func<Exception,T>(e => {

808

error != null ? new Func<Exception,T>(e => {

809

error(e);

809

error(e);

810

return default(T);

810

return default(T);

811

}) : null

811

}) : null

812

);

812

);

813

}

813

}

814

815

IPromise IPromise.Then(Action success) {

815

IPromise IPromise.Then(Action success) {

816

Safe.ArgumentNotNull(success, "success");

816

Safe.ArgumentNotNull(success, "success");

817

return Then(x => {

817

return Then(x => {

818

success();

818

success();

819

return x;

819

return x;

820

});

820

});

821

}

821

}

822

823

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

823

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

824

return ChainNoResult(chained, error, cancel);

824

return ChainNoResult(chained, error, cancel);

825

}

825

}

826

827

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

827

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

828

Safe.ArgumentNotNull(chained, "chained");

828

Safe.ArgumentNotNull(chained, "chained");

829

830

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

830

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

831

832

Func<T,T> resultHandler = delegate {

832

Func<T,T> resultHandler = delegate {

833

if (medium.IsCancelled)

833

if (medium.IsCancelled)

834

return default(T);

834

return default(T);

835

836

var promise = chained();

836

var promise = chained();

837

838

promise.On(

838

promise.On(

839

medium.Resolve,

839

medium.Resolve,

840

medium.Reject,

840

medium.Reject,

841

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

841

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

842

);

842

);

843

844

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

844

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

845

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

845

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

846

// зависит IsExclusive

846

// зависит IsExclusive

847

medium.Cancelled(() => {

847

medium.Cancelled(() => {

848

if (promise.IsExclusive)

848

if (promise.IsExclusive)

849

promise.Cancel();

849

promise.Cancel();

850

});

850

});

851

852

return default(T);

852

return default(T);

853

};

853

};

854

855

Func<Exception,T> errorHandler;

855

Func<Exception,T> errorHandler;

856

857

if (error != null)

857

if (error != null)

858

errorHandler = delegate(Exception e) {

858

errorHandler = delegate(Exception e) {

859

try {

859

try {

860

var promise = error(e);

860

var promise = error(e);

861

862

promise.On(

862

promise.On(

863

medium.Resolve,

863

medium.Resolve,

864

medium.Reject,

864

medium.Reject,

865

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

865

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

866

);

866

);

867

868

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

868

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

869

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

869

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

870

// зависит IsExclusive

870

// зависит IsExclusive

871

medium.Cancelled(() => {

871

medium.Cancelled(() => {

872

if (promise.IsExclusive)

872

if (promise.IsExclusive)

873

promise.Cancel();

873

promise.Cancel();

874

});

874

});

875

} catch (Exception e2) {

875

} catch (Exception e2) {

876

medium.Reject(e2);

876

medium.Reject(e2);

877

}

877

}

878

return default(T);

878

return default(T);

879

};

879

};

880

else

880

else

881

errorHandler = err => {

881

errorHandler = err => {

882

medium.Reject(err);

882

medium.Reject(err);

883

return default(T);

883

return default(T);

884

};

884

};

885

886

887

Action cancelHandler;

887

Action cancelHandler;

888

if (cancel != null)

888

if (cancel != null)

889

cancelHandler = () => {

889

cancelHandler = () => {

890

if (cancel != null)

890

if (cancel != null)

891

cancel();

891

cancel();

892

medium.Cancel();

892

medium.Cancel();

893

};

893

};

894

else

894

else

895

cancelHandler = medium.Cancel;

895

cancelHandler = medium.Cancel;

896

897

AddMappers(

897

AddMappers(

898

resultHandler,

898

resultHandler,

899

errorHandler,

899

errorHandler,

900

cancelHandler,

900

cancelHandler,

901

null,

901

null,

902

true

902

true

903

);

903

);

904

905

return medium;

905

return medium;

906

}

906

}

907

908

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

908

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

909

return ChainNoResult(chained, error, null);

909

return ChainNoResult(chained, error, null);

910

}

910

}

911

912

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

912

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

913

return ChainNoResult(chained, null, null);

913

return ChainNoResult(chained, null, null);

914

}

914

}

915

916

917

void IPromise.On(Action success, Action<Exception> error, Action cancel) {

917

void IPromise.On(Action success, Action<Exception> error, Action cancel) {

918

On(success != null ? new Action<T>(x => success()) : null, error, cancel);

918

On(success != null ? new Action<T>(x => success()) : null, error, cancel);

919

}

919

}

920

921

void IPromise.On(Action success, Action<Exception> error) {

921

void IPromise.On(Action success, Action<Exception> error) {

922

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

922

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

923

}

923

}

924

925

void IPromise.On(Action success) {

925

void IPromise.On(Action success) {

926

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

926

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

927

}

927

}

928

929

IPromise IPromise.Error(Action<Exception> error) {

929

IPromise IPromise.Error(Action<Exception> error) {

930

return Error(error);

930

return Error(error);

931

}

931

}

932

933

IPromise IPromise.Anyway(Action handler) {

933

IPromise IPromise.Anyway(Action handler) {

934

return Anyway(handler);

934

return Anyway(handler);

935

}

935

}

936

937

IPromise IPromise.Cancelled(Action handler) {

937

IPromise IPromise.Cancelled(Action handler) {

938

return Cancelled(handler);

938

return Cancelled(handler);

939

}

939

}

940

941

void IPromise.Join() {

941

void IPromise.Join() {

942

Join();

942

Join();

943

}

943

}

944

945

void IPromise.Join(int timeout) {

945

void IPromise.Join(int timeout) {

946

Join(timeout);

946

Join(timeout);

947

}

947

}

948

949

#endregion

949

#endregion

950

951

952

953

}

953

}

954

}

954

}

	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.Reflection;
             using System.Threading;
             using Implab.Parallels;
             namespace Implab {
                 /// <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 abstract class AbstractHandler : MTCustomQueueNode<AbstractHandler> {
                         public abstract void Resolve(T result);
                         public abstract void Reject(Exception error);
                         public abstract void Cancel();
                     }
                     protected class RemapDescriptor<T2> : AbstractHandler  {
                         readonly Func<T,T2> m_resultHandler;
                         readonly Func<Exception,T2> m_errorHandler;
                         readonly Action m_cancellHandler;
                         readonly Promise<T2> m_medium;
                         public RemapDescriptor(Func<T,T2> resultHandler, Func<Exception,T2> errorHandler, Action cancelHandler, Promise<T2> medium) {
                             m_resultHandler = resultHandler;
                             m_errorHandler = errorHandler;
                             m_cancellHandler = cancelHandler;
                             m_medium = medium;
                         }
                         public override void Resolve(T result) {
                             if (m_resultHandler != null) {
                                 try {
                                     if (m_medium != null)
                                         m_medium.Resolve(m_resultHandler(result));
                                     else
                                         m_resultHandler(result);
                                 } catch (Exception e) {
                                     Reject(e);
                                 }
                             } else if(m_medium != null)
                                 m_medium.Resolve(default(T2));
                         }
                         public override void Reject(Exception error) {
                             if (m_errorHandler != null) {
                                 try {
                                     var res = m_errorHandler(error);
                                     if (m_medium != null)
                                         m_medium.Resolve(res);
                                 } catch (Exception err2) {
                                     if (m_medium != null)
                                         m_medium.Reject(err2);
                                 }
                             } else if (m_medium != null)
                                 m_medium.Reject(error);
                         }
                         public override void Cancel() {
                             if (m_cancellHandler != null) {
                                 try {
                                     m_cancellHandler();
                                 } catch (Exception err) {
                                     Reject(err);
                                     return;
                                 }
                             }
                             if (m_medium != null)
                                 m_medium.Cancel();
                         }
                     }
                     protected class HandlerDescriptor : AbstractHandler  {
                         readonly Action<T> m_resultHandler;
                         readonly Action<Exception> m_errorHandler;
                         readonly Action m_cancellHandler;
                         readonly Promise<T> m_medium;
                         public HandlerDescriptor(Action<T> resultHandler, Action<Exception> errorHandler, Action cancelHandler, Promise<T> medium) {
                             m_resultHandler = resultHandler;
                             m_errorHandler = errorHandler;
                             m_cancellHandler = cancelHandler;
                             m_medium = medium;
                         }
                         public override void Resolve(T result) {
                             if (m_resultHandler != null) {
                                 try {
                                     m_resultHandler(result);
                                 } catch (Exception e) {
                                     Reject(e);
                                     return;
                                 }
                             }
                             if(m_medium != null)
                                 m_medium.Resolve(result);
                         }
                         public override void Reject(Exception error) {
                             if (m_errorHandler != null) {
                                 try {
                                     m_errorHandler(error);
                                     if (m_medium != null)
                                         m_medium.Resolve(default(T));
                                 } catch (Exception err2) {
                                     if (m_medium != null)
                                         m_medium.Reject(err2);
                                 }
                             } else if (m_medium != null)
                                 m_medium.Reject(error);
                         }
                         public override void Cancel() {
                             if (m_cancellHandler != null) {
                                 try {
                                     m_cancellHandler();
                                 } catch (Exception err) {
                                     Reject(err);
                                     return;
                                 }
                             }
                             if (m_medium != null)
                                 m_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;
                     int m_childrenCount;
                     int m_state;
                     T m_result;
                     Exception m_error;
                     readonly MTCustomQueue<AbstractHandler> m_handlers = new MTCustomQueue<AbstractHandler>();
                     //readonly MTQueue<AbstractHandler> m_handlers = new MTQueue<AbstractHandler>();
                     public Promise() {
                     }
                     public Promise(IPromise parent) {
                         if (parent != null)
-                            AddMappers<T>(
+                            AddHandler(
                                 null,
                                 null,
                                 () => {
                                     if (parent.IsExclusive)
                                         parent.Cancel();
                                 },
                                 null,
                                 false
                             );
                     }
                     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 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 (BeginTransit()) {
                             CompleteTransit(CANCELLED_STATE);
                             OnStateChanged();
                         }
                     }
                     /// <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 On(Action<T> success, Action<Exception> error, Action cancel) {
                         if (success == null && error == null && cancel == null)
                             return;
                         AddHandler(success, error, cancel, null, false);
                     }
                     public void On(Action<T> success, Action<Exception> error) {
                         AddHandler(success, error, null, null, false);
                     }
                     public void On(Action<T> success) {
                         AddHandler(success, null, null, null, false);
                     }
                     public void On(Action handler, PromiseEventType events) {
                         Safe.ArgumentNotNull(handler, "handler");
                         AddHandler(
                             events.HasFlag(PromiseEventType.Success) ? new Action<T>(x => handler()) : null,
                             events.HasFlag(PromiseEventType.Error) ? new Action<Exception>( x => handler()) : null,
                             events.HasFlag(PromiseEventType.Cancelled) ? handler : null,
                             null,
                             false
                         );
                     }
                     public IPromise Error(Action<Exception> error) {
                         if (error == null)
                             return this;
                         var medium = new Promise<T>(this);
                         AddMappers(
-                            null,
+                            x => x,
                             e => {
                                 error(e);
                                 return default(T);
                             },
                             null,
                             medium,
                             true
                         );
                         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(Func<Exception,T> handler) {
                         if (handler == null)
                             return this;
                         var medium = new Promise<T>(this);
-                        AddMappers(null, handler, null, medium, true);
+                        AddMappers(x => x, handler, null, medium, true);
                         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>(Func<T, TNew> mapper, Func<Exception,TNew> error, Action cancel) {
                         Safe.ArgumentNotNull(mapper, "mapper");
                         // создаем прицепленное обещание
                         var medium = new Promise<TNew>(this);
                         AddMappers(
                             mapper,
                             error,
                             cancel,
                             medium,
                             true
                         );
                         return medium;
                     }
                     public IPromise<TNew> Then<TNew>(Func<T, TNew> mapper, Func<Exception,TNew> error) {
                         return Then(mapper, error, null);
                     }
                     public IPromise<TNew> Then<TNew>(Func<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>(Func<T, IPromise<TNew>> chained, Func<Exception,IPromise<TNew>> error, Action cancel) {
                         Safe.ArgumentNotNull(chained, "chained");
                         // проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно
                         // создать посредника, к которому будут подвызяваться следующие обработчики.
                         // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы
                         // передать через него результаты работы.
                         var medium = new Promise<TNew>(this);
                         Func<T,T> resultHandler = delegate(T result) {
                             if (medium.IsCancelled)
                                 return default(T);
                             var promise = chained(result);
                             promise.On(
                                 medium.Resolve,
                                 medium.Reject,
                                 () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
                             );
                             // notify chained operation that it's not needed anymore
                             // порядок вызова Then, Cancelled важен, поскольку от этого
                             // зависит IsExclusive
                             medium.On(
                                 null,
                                 null,
                                 () => {
                                     if (promise.IsExclusive)
                                         promise.Cancel();
                                 }
                             );
                             return default(T);
                         };
                         Func<Exception,T> errorHandler;
                         if (error != null)
                             errorHandler = delegate(Exception e) {
                                 try {
                                     var promise = error(e);
                                     promise.On(
                                         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;
                         AddMappers(
                             resultHandler,
                             errorHandler,
                             cancelHandler,
                             null,
                             true
                         );
                         return medium;
                     }
                     public IPromise<TNew> Chain<TNew>(Func<T, IPromise<TNew>> chained, Func<Exception,IPromise<TNew>> error) {
                         return Chain(chained, error, null);
                     }
                     public IPromise<TNew> Chain<TNew>(Func<T, IPromise<TNew>> chained) {
                         return Chain(chained, null, null);
                     }
                     public IPromise<T> Cancelled(Action handler) {
                         var medium = new Promise<T>(this);
                         AddHandler(null, null, handler, medium, false);
                         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");
                         var medium = new Promise<T>(this);
                         AddHandler(
                             x => handler(),
                             e => {
                                 handler();
                                 throw new TransientPromiseException(e);
                             },
                             handler,
                             medium,
                             true
                         );
                         return medium;
                     }
                     /// <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 AddMappers<T2>(Func<T,T2> success, Func<Exception,T2> error, Action cancel, Promise<T2> medium, bool inc) {
                         if (inc)
                             Interlocked.Increment(ref m_childrenCount);
                         AbstractHandler handler = new RemapDescriptor<T2>(success, error, cancel, 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);
                     }
                     void AddHandler(Action<T> success, Action<Exception> error, Action cancel, Promise<T> medium, bool inc) {
                         if (inc)
                             Interlocked.Increment(ref m_childrenCount);
                         AbstractHandler handler = new HandlerDescriptor(success, error, cancel, 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(AbstractHandler 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() {
                         AbstractHandler 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].On(
                                     x => {
                                         result[dest] = x;
                                         if (Interlocked.Decrement(ref pending) == 0)
                                             promise.Resolve(result);
                                     },
                                     promise.Reject
                                 );
                             } 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, Action<Exception> error, Action cancel) {
                         return Then(
                             success != null ? new Func<T,T>(x => {
                                 success();
                                 return x;
                             }) : null,
                             error != null ? new Func<Exception,T>(e => {
                                 error(e);
                                 return default(T);
                             }) : null,
                             cancel
                         );
                     }
                     IPromise IPromise.Then(Action success, Action<Exception> error) {
                         return Then(
                             success != null ? new Func<T,T>(x => {
                                 success();
                                 return x;
                             }) : null,
                             error != null ? new Func<Exception,T>(e => {
                                 error(e);
                                 return default(T);
                             }) : null
                         );
                     }
                     IPromise IPromise.Then(Action success) {
                         Safe.ArgumentNotNull(success, "success");
                         return Then(x => {
                             success();
                             return x;
                         });
                     }
                     IPromise IPromise.Chain(Func<IPromise> chained, Func<Exception,IPromise> error, Action cancel) {
                         return ChainNoResult(chained, error, cancel);
                     }
                     IPromise ChainNoResult(Func<IPromise> chained, Func<Exception,IPromise> error, Action cancel) {
                         Safe.ArgumentNotNull(chained, "chained");
                         var medium = new Promise<object>(this);
                         Func<T,T> resultHandler = delegate {
                             if (medium.IsCancelled)
                                 return default(T);
                             var promise = chained();
                             promise.On(
                                 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();
                             });
                             return default(T);
                         };
                         Func<Exception,T> errorHandler;
                         if (error != null)
                             errorHandler = delegate(Exception e) {
                                 try {
                                     var promise = error(e);
                                     promise.On(
                                         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;
                         AddMappers(
                             resultHandler,
                             errorHandler,
                             cancelHandler,
                             null,
                             true
                         );
                         return medium;
                     }
                     IPromise IPromise.Chain(Func<IPromise> chained, Func<Exception,IPromise> error) {
                         return ChainNoResult(chained, error, null);
                     }
                     IPromise IPromise.Chain(Func<IPromise> chained) {
                         return ChainNoResult(chained, null, null);
                     }
                     void IPromise.On(Action success, Action<Exception> error, Action cancel) {
                         On(success != null ? new Action<T>(x => success()) : null, error, cancel);
                     }
                     void IPromise.On(Action success, Action<Exception> error) {
                         On(x => success(), error, null);
                     }
                     void IPromise.On(Action success) {
                         On(x => success(), null, null);
                     }
                     IPromise IPromise.Error(Action<Exception> 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
                 }
             }