implab/ImplabNet Commit - r9:c82e0dfbb4dd

1

using System;

1

using System;

2

using System.Collections.Generic;

2

using System.Collections.Generic;

3

using System.Linq;

3

using System.Linq;

4

using System.Reflection;

4

using System.Reflection;

5

using System.Text;

5

using System.Text;

6

using System.Diagnostics;

6

using System.Diagnostics;

7

using System.Threading;

7

using System.Threading;

8

9

namespace Implab {

9

namespace Implab {

10

11

public delegate void ErrorHandler(Exception e);

11

public delegate void ErrorHandler(Exception e);

12

13

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

13

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

14

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

14

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

15

public delegate Promise<TNew> ChainedOperation<TSrc, TNew>(TSrc result);

15

public delegate Promise<TNew> ChainedOperation<TSrc, TNew>(TSrc result);

16

17

/// <summary>

17

/// <summary>

18

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

18

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

19

/// </summary>

19

/// </summary>

20

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

20

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

21

/// <remarks>

21

/// <remarks>

22

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

22

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

23

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

23

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

24

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

24

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

25

/// <para>

25

/// <para>

26

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

26

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

27

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

27

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

28

/// </para>

28

/// </para>

29

/// <para>

29

/// <para>

30

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

30

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

31

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

31

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

32

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

32

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

33

/// </para>

33

/// </para>

34

/// <para>

34

/// <para>

35

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

35

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

36

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

36

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

37

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

37

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

38

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

38

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

39

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

39

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

40

/// </para>

40

/// </para>

41

/// <para>

41

/// <para>

42

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

42

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

43

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

43

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

44

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

44

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

45

/// </para>

45

/// </para>

46

/// <para>

46

/// <para>

47

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

47

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

48

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

48

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

49

/// </para>

49

/// </para>

50

/// </remarks>

50

/// </remarks>

51

public class Promise<T>: IPromise {

51

public class Promise<T> : IPromise {

52

53

struct ResultHandlerInfo {

53

struct ResultHandlerInfo {

54

public ResultHandler<T> resultHandler;

54

public ResultHandler<T> resultHandler;

55

public ErrorHandler errorHandler;

55

public ErrorHandler errorHandler;

56

public Action cancelHandler;

57

}

56

}

58

57

59

LinkedList<ResultHandlerInfo> m_handlersChain = new LinkedList<ResultHandlerInfo>();

58

IPromise m_parent;

59

60

LinkedList<ResultHandlerInfo> m_resultHandlers = new LinkedList<ResultHandlerInfo>();

61

LinkedList<Action> m_cancelHandlers = new LinkedList<Action>();

62

63

object m_lock = new Object();

64

bool m_cancellable;

65

60

PromiseState m_state;

66

PromiseState m_state;

61

bool m_cancellable;

62

T m_result;

67

T m_result;

63

Exception m_error;

68

Exception m_error;

64

IPromise m_parent;

69

65

int m_childrenCount;

70

int m_childrenCount;

66

71

67

public Promise() {

72

public Promise() {

68

m_cancellable = true;

73

m_cancellable = true;

69

}

74

}

70

75

71

public Promise(IPromise parent, bool cancellable)

76

public Promise(IPromise parent, bool cancellable) {

72

{

73

m_cancellable = cancellable;

77

m_cancellable = cancellable;

74

m_parent = parent;

78

m_parent = parent;

75

}

79

}

76

80

77

/// <summary>

81

/// <summary>

78

/// Событие, возникающее при отмене асинхронной операции.

82

/// Событие, возникающее при отмене асинхронной операции.

79

/// </summary>

83

/// </summary>

80

/// <description>

84

/// <description>

81

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

85

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

82

/// </description>

86

/// </description>

83

public event EventHandler Cancelled;

87

public event EventHandler Cancelled;

84

88

85

/// <summary>

89

/// <summary>

86

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

90

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

87

/// </summary>

91

/// </summary>

88

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

92

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

89

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

93

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

90

public void Resolve(T result) {

94

public void Resolve(T result) {

91

lock (this) {

95

lock (this) {

92

if (m_state == PromiseState.Cancelled)

96

if (m_state == PromiseState.Cancelled)

93

return;

97

return;

94

if (m_state != PromiseState.Unresolved)

98

if (m_state != PromiseState.Unresolved)

95

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

99

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

96

m_result = result;

100

m_result = result;

97

m_state = PromiseState.Resolved;

101

m_state = PromiseState.Resolved;

98

}

102

}

99

103

100

ResultHandlerInfo handler;

104

// state has been changed to rejected new handlers can't be added

105

106

foreach (var handler in m_resultHandlers)

107

InvokeHandler(handler);

108

109

/* ResultHandlerInfo handler;

101

while (FetchNextHandler(out handler))

110

while (FetchNextHandler(out handler))

102

~~InvokeHandler~~(~~handler~~);

111

InvokeHandler(handler); */

103

}

112

}

104

113

105

/// <summary>

114

/// <summary>

106

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

115

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

107

/// </summary>

116

/// </summary>

108

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

117

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

109

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

118

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

110

public void Reject(Exception error) {

119

public void Reject(Exception error) {

111

lock (this) {

120

lock (this) {

112

if (m_state == PromiseState.Cancelled)

121

if (m_state == PromiseState.Cancelled)

113

return;

122

return;

114

if (m_state != PromiseState.Unresolved)

123

if (m_state != PromiseState.Unresolved)

115

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

124

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

116

m_error = error;

125

m_error = error;

117

m_state = PromiseState.Rejected;

126

m_state = PromiseState.Rejected;

118

}

127

}

119

128

120

ResultHandlerInfo handler;

129

// state has been changed to rejected new handlers can't be added

130

131

foreach (var handler in m_resultHandlers)

132

InvokeHandler(handler);

133

134

/*ResultHandlerInfo handler;

121

while (FetchNextHandler(out handler))

135

while (FetchNextHandler(out handler))

122

~~InvokeHandler~~(~~handler~~);

136

InvokeHandler(handler);*/

123

}

137

}

124

138

125

/// <summary>

139

/// <summary>

126

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

140

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

127

/// </summary>

141

/// </summary>

128

/// <returns><c>true</c> Операция была отменена, обработчики не будут вызваны.<c>false</c> отмена не возможна, поскольку обещание уже выполнено и обработчики отработали.</returns>

142

/// <returns><c>true</c> Операция была отменена, обработчики не будут вызваны.<c>false</c> отмена не возможна, поскольку обещание уже выполнено и обработчики отработали.</returns>

129

public bool Cancel() {

143

public bool Cancel() {

130

lock (this) {

144

return Cancel(true);

131

if (m_state == PromiseState.Unresolved && m_cancellable)

132

{

133

m_state = PromiseState.Cancelled;

134

EventHandler temp = Cancelled;

135

136

if (temp != null)

137

temp(this, new EventArgs());

138

139

return true;

140

} else

141

return false;

142

}

143

}

145

}

144

146

145

/// <summary>

147

/// <summary>

146

/// Добавляет обработчики событий выполнения обещания.

148

/// Добавляет обработчики событий выполнения обещания.

147

/// </summary>

149

/// </summary>

148

/// <param name="success">Обработчик успешного выполнения обещания.

150

/// <param name="success">Обработчик успешного выполнения обещания.

149

/// Данному обработчику будет передан результат выполнения операции.</param>

151

/// Данному обработчику будет передан результат выполнения операции.</param>

150

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

152

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

151

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

153

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

152

/// <returns>Само обещание</returns>

154

/// <returns>Само обещание</returns>

153

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

155

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

154

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

156

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

155

return this;

157

return this;

156

158

157

var medium = new Promise<T>();

159

var medium = new Promise<T>();

158

160

159

var handlerInfo = new ResultHandlerInfo();

161

var handlerInfo = new ResultHandlerInfo();

160

162

161

if (success != null)

163

if (success != null)

162

handlerInfo.resultHandler = x => {

164

handlerInfo.resultHandler = x => {

163

try {

165

try {

164

success(x);

166

success(x);

165

medium.Resolve(x);

167

medium.Resolve(x);

166

} catch (Exception e) {

168

} catch (Exception e) {

167

medium.Reject(e);

169

medium.Reject(e);

168

}

170

}

169

};

171

};

170

else

172

else

171

handlerInfo.resultHandler = x => medium.Resolve(x);

173

handlerInfo.resultHandler = x => medium.Resolve(x);

172

174

173

if (error != null)

175

if (error != null)

174

handlerInfo.errorHandler = x => {

176

handlerInfo.errorHandler = x => {

175

try {

177

try {

176

error(x);

178

error(x);

177

} catch { }

179

} catch { }

178

medium.Reject(x);

180

medium.Reject(x);

179

};

181

};

180

else

182

else

181

handlerInfo.errorHandler = x => medium.Reject(x);

183

handlerInfo.errorHandler = x => medium.Reject(x);

182

184

183

AddHandler(handlerInfo);

185

AddHandler(handlerInfo);

184

186

185

return medium;

187

return medium;

186

}

188

}

187

189

188

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

190

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

189

return Then(success, null);

191

return Then(success, null);

190

}

192

}

191

193

192

public Promise<T> Error(ErrorHandler error) {

194

public Promise<T> Error(ErrorHandler error) {

193

return Then(null, error);

195

return Then(null, error);

194

}

196

}

195

197

196

public Promise<T> Anyway(Action handler) {

198

public Promise<T> Anyway(Action handler) {

197

if (handler == null)

199

if (handler == null)

198

return this;

200

return this;

199

201

200

var medium = new Promise<T>();

202

var medium = new Promise<T>();

201

203

202

AddHandler(new ResultHandlerInfo {

204

AddHandler(new ResultHandlerInfo {

203

resultHandler = x => {

205

resultHandler = x => {

204

try {

206

try {

205

handler();

207

handler();

206

medium.Resolve(x);

208

medium.Resolve(x);

207

} catch (Exception e) {

209

} catch (Exception e) {

208

medium.Reject(e);

210

medium.Reject(e);

209

}

211

}

210

},

212

},

211

errorHandler = x => {

213

errorHandler = x => {

212

try {

214

try {

213

handler();

215

handler();

214

} catch { }

216

} catch { }

215

medium.Reject(x);

217

medium.Reject(x);

216

}

218

}

217

});

219

});

218

220

219

return medium;

221

return medium;

220

}

222

}

221

223

222

/// <summary>

224

/// <summary>

223

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

225

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

224

/// </summary>

226

/// </summary>

225

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

227

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

226

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

228

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

227

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

229

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

228

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

230

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

229

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

231

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

230

public Promise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler error) {

232

public Promise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler error) {

231

if (mapper == null)

233

if (mapper == null)

232

throw new ArgumentNullException("mapper");

234

throw new ArgumentNullException("mapper");

233

235

234

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

236

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

235

Promise<TNew> chained = new Promise<TNew>();

237

Promise<TNew> chained = new Promise<TNew>();

236

238

237

AddHandler(new ResultHandlerInfo() {

239

AddHandler(new ResultHandlerInfo() {

238

resultHandler = delegate(T result) {

240

resultHandler = delegate(T result) {

239

try {

241

try {

240

// если преобразование выдаст исключение, то сработает reject сцепленного deferred

242

// если преобразование выдаст исключение, то сработает reject сцепленного deferred

241

chained.Resolve(mapper(result));

243

chained.Resolve(mapper(result));

242

} catch (Exception e) {

244

} catch (Exception e) {

243

chained.Reject(e);

245

chained.Reject(e);

244

}

246

}

245

},

247

},

246

errorHandler = delegate(Exception e) {

248

errorHandler = delegate(Exception e) {

247

if (error != null)

249

if (error != null)

248

error(e);

250

error(e);

249

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

251

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

250

chained.Reject(e);

252

chained.Reject(e);

251

}

253

}

252

});

254

});

253

255

254

return chained;

256

return chained;

255

}

257

}

256

258

257

public Promise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper) {

259

public Promise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper) {

258

return Map(mapper, null);

260

return Map(mapper, null);

259

}

261

}

260

262

261

/// <summary>

263

/// <summary>

262

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

264

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

263

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

265

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

264

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

266

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

265

/// </summary>

267

/// </summary>

266

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

268

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

267

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

269

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

268

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

270

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

269

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

271

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

270

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

272

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

271

public Promise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained, ErrorHandler error) {

273

public Promise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained, ErrorHandler error) {

272

274

273

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

275

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

274

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

276

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

275

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

277

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

276

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

278

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

277

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

279

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

278

280

279

AddHandler(new ResultHandlerInfo() {

281

AddHandler(new ResultHandlerInfo() {

280

resultHandler = delegate(T result) {

282

resultHandler = delegate(T result) {

281

try {

283

try {

282

chained(result).Then(

284

chained(result).Then(

283

x => medium.Resolve(x),

285

x => medium.Resolve(x),

284

e => medium.Reject(e)

286

e => medium.Reject(e)

285

);

287

);

286

} catch (Exception e) {

288

} catch (Exception e) {

287

// если сцепленное действие выдало исключение вместо обещания, то передаем ошибку по цепочке

289

// если сцепленное действие выдало исключение вместо обещания, то передаем ошибку по цепочке

288

medium.Reject(e);

290

medium.Reject(e);

289

}

291

}

290

},

292

},

291

errorHandler = delegate(Exception e) {

293

errorHandler = delegate(Exception e) {

292

if (error != null)

294

if (error != null)

293

error(e);

295

error(e);

294

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

296

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

295

medium.Reject(e);

297

medium.Reject(e);

296

}

298

}

297

});

299

});

298

300

299

return medium;

301

return medium;

300

}

302

}

301

303

302

public Promise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained) {

304

public Promise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained) {

303

return Chain(chained, null);

305

return Chain(chained, null);

304

}

306

}

305

307

306

/// <summary>

308

/// <summary>

307

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

309

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

308

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

310

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

309

/// </summary>

311

/// </summary>

310

/// <remarks>

312

/// <remarks>

311

/// <para>

313

/// <para>

312

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

314

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

313

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

315

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

314

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

316

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

315

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

317

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

316

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

318

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

317

/// </para>

319

/// </para>

318

/// <para>

320

/// <para>

319

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

321

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

320

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

322

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

321

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

323

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

322

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

324

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

323

/// </para>

325

/// </para>

324

/// </remarks>

326

/// </remarks>

325

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

327

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

326

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

328

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

327

public T Join(int timeout) {

329

public T Join(int timeout) {

328

ManualResetEvent evt = new ManualResetEvent(false);

330

ManualResetEvent evt = new ManualResetEvent(false);

329

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

331

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

330

332

331

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

333

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

332

throw new TimeoutException();

334

throw new TimeoutException();

333

335

334

if (m_error != null)

336

if (m_error != null)

335

throw new TargetInvocationException(m_error);

337

throw new TargetInvocationException(m_error);

336

else

338

else

337

return m_result;

339

return m_result;

338

}

340

}

339

341

340

public T Join() {

342

public T Join() {

341

return Join(Timeout.Infinite);

343

return Join(Timeout.Infinite);

342

}

344

}

343

345

344

/// <summary>

346

/// <summary>

345

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

347

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

346

/// их больше не осталось - ставит состояние "разрешено".

348

/// их больше не осталось - ставит состояние "разрешено".

347

/// </summary>

349

/// </summary>

348

/// <param name="handler">Информация об обработчике</param>

350

/// <param name="handler">Информация об обработчике</param>

349

/// <returns>Признак того, что еще остались обработчики в очереди</returns>

351

/// <returns>Признак того, что еще остались обработчики в очереди</returns>

350

bool FetchNextHandler(out ResultHandlerInfo handler) {

352

bool FetchNextHandler(out ResultHandlerInfo handler) {

351

handler = default(ResultHandlerInfo);

353

handler = default(ResultHandlerInfo);

352

354

353

lock (this) {

355

lock (this) {

354

Debug.Assert(m_state != PromiseState.Unresolved);

356

Debug.Assert(m_state != PromiseState.Unresolved);

355

357

356

if (m_handlers~~Chain~~.Count > 0) {

358

if (m_resultHandlers.Count > 0) {

357

handler = m_handlers~~Chain~~.First.Value;

359

handler = m_resultHandlers.First.Value;

358

m_handlers~~Chain~~.RemoveFirst();

360

m_resultHandlers.RemoveFirst();

359

return true;

361

return true;

360

} else {

362

} else {

361

return false;

363

return false;

362

}

364

}

363

}

365

}

364

}

366

}

365

367

366

void AddHandler(ResultHandlerInfo handler) {

368

void AddHandler(ResultHandlerInfo handler) {

367

bool invokeRequired = false;

369

bool invokeRequired = false;

368

370

369

lock (this) {

371

lock (this) {

370

if (m_state == PromiseState.Unresolved)

372

if (m_state == PromiseState.Unresolved)

371

m_handlers~~Chain~~.AddLast(handler);

373

m_resultHandlers.AddLast(handler);

372

else

374

else

373

invokeRequired = true;

375

invokeRequired = true;

374

}

376

}

375

377

376

// обработчики не должны блокировать сам объект

378

// обработчики не должны блокировать сам объект

377

if (invokeRequired)

379

if (invokeRequired)

378

InvokeHandler(handler);

380

InvokeHandler(handler);

379

}

381

}

380

382

381

void InvokeHandler(ResultHandlerInfo handler) {

383

void InvokeHandler(ResultHandlerInfo handler) {

382

if (m_error == null) {

384

if (m_error == null) {

383

try {

385

try {

384

if (handler.resultHandler != null)

386

if (handler.resultHandler != null)

385

handler.resultHandler(m_result);

387

handler.resultHandler(m_result);

386

} catch { }

388

} catch { }

387

}

389

}

388

390

389

if (m_error != null) {

391

if (m_error != null) {

390

try {

392

try {

391

if (handler.errorHandler != null)

393

if (handler.errorHandler != null)

392

handler.errorHandler(m_error);

394

handler.errorHandler(m_error);

393

} catch { }

395

} catch { }

394

}

396

}

395

}

397

}

396

398

397

399

400

401

public bool IsExclusive {

402

get {

403

lock (m_lock) {

404

return m_childrenCount <= 1;

405

}

406

}

407

}

408

409

public PromiseState State {

410

get {

411

lock (m_lock) {

412

return m_state;

413

}

398

}

414

}

399

}

415

}

416

417

public bool Cancel(bool dependencies) {

418

bool result;

419

420

lock (m_lock) {

421

if (m_state == PromiseState.Unresolved) {

422

m_state = PromiseState.Cancelled;

423

result = true;

424

} else {

425

result = false;

426

}

427

}

428

429

if (dependencies && m_parent != null && m_parent.IsExclusive) {

430

// TODO syncronize IsExclusive, AddHandler, Cancel (maybe CancelExclusive)

431

m_parent.Cancel(true);

432

}

433

434

if (result) {

435

// state has been changed to cancelled, new handlers can't be added

436

foreach (var handler in m_cancelHandlers)

437

handler();

438

}

439

440

return result;

441

}

442

}

443

}

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

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

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             namespace Implab
             {
                 public interface IPromise
                 {
                     /// <summary>
                     /// Check whereather the promise has no more than one dependent promise.
                     /// </summary>
                     bool IsExclusive
                     {
                         get;
                     }
                     /// <summary>
                     /// The current state of the promise.
                     /// </summary>
                     PromiseState State
                     {
                         get;
                     }
                     /// <summary>
                     /// Tries to cancel the promise or the complete chain.
                     /// </summary>
-                    /// <param name="dependencies">Try to cancel the parent promise is it has the only one child</param>
+                    /// <param name="dependencies">Try to cancel the whole promise chain, the parent promise will be cancelled only if it has only one promise</param>
                     /// <returns></returns>
                     bool Cancel(bool dependencies);
                 }
             }

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Reflection;
             using System.Text;
             using System.Diagnostics;
             using System.Threading;
             namespace Implab {
                 public delegate void ErrorHandler(Exception e);
                 public delegate void ResultHandler<T>(T result);
                 public delegate TNew ResultMapper<TSrc, TNew>(TSrc result);
                 public delegate Promise<TNew> ChainedOperation<TSrc, TNew>(TSrc result);
                 /// <summary>
                 /// Класс для асинхронного получения результатов. Так называемое "обещание".
                 /// </summary>
                 /// <typeparam name="T">Тип получаемого результата</typeparam>
                 /// <remarks>
                 /// <para>Сервис при обращении к его методу дает обещаиние о выполнении операции,
                 /// клиент получив такое обещание может установить ряд обратных вызово для получения
                 /// событий выполнения обещания, тоесть завершения операции и предоставлении результатов.</para>
                 /// <para>
                 /// Обещение может быть как выполнено, так и выполнено с ошибкой. Для подписки на
                 /// данные события клиент должен использовать методы <c>Then</c>.
                 /// </para>
                 /// <para>
                 /// Сервис, в свою очередь, по окончанию выполнения операции (возможно с ошибкой),
                 /// использует методы <c>Resolve</c> либо <c>Reject</c> для оповещения клиетна о
                 /// выполнении обещания.
                 /// </para>
                 /// <para>
                 /// Если сервер успел выполнить обещание еще до того, как клиент на него подписался,
                 /// то в момент подписки клиента будут вызваны соответсвующие события в синхронном
                 /// режиме и клиент будет оповещен в любом случае. Иначе, обработчики добавляются в
                 /// список в порядке подписания и в этом же порядке они будут вызваны при выполнении
                 /// обещания.
                 /// </para>
                 /// <para>
                 /// Обрабатывая результаты обещания можно преобразовывать результаты либо инициировать
                 /// связанные асинхронные операции, которые также возвращают обещания. Для этого следует
                 /// использовать соответствующую форму методе <c>Then</c>.
                 /// </para>
                 /// <para>
                 /// Также хорошим правилом является то, что <c>Resolve</c> и <c>Reject</c> должен вызывать
                 /// только инициатор обещания иначе могут возникнуть противоречия.
                 /// </para>
                 /// </remarks>
                 public class Promise<T> : IPromise {
                     struct ResultHandlerInfo {
                         public ResultHandler<T> resultHandler;
                         public ErrorHandler errorHandler;
-                        public Action cancelHandler;
                     }
-                    LinkedList<ResultHandlerInfo> m_handlersChain = new LinkedList<ResultHandlerInfo>();
+                    IPromise m_parent;
+                    LinkedList<ResultHandlerInfo> m_resultHandlers = new LinkedList<ResultHandlerInfo>();
+                    LinkedList<Action> m_cancelHandlers = new LinkedList<Action>();
+                    object m_lock = new Object();
+                    bool m_cancellable;
                     PromiseState m_state;
-                    bool m_cancellable;
                     T m_result;
                     Exception m_error;
-                    IPromise m_parent;
                     int m_childrenCount;
                     public Promise() {
                         m_cancellable = true;
                     }
-                    public Promise(IPromise parent, bool cancellable)
+                    public Promise(IPromise parent, bool cancellable) {
                         m_cancellable = cancellable;
                         m_parent = parent;
                     }
                     /// <summary>
                     /// Событие, возникающее при отмене асинхронной операции.
                     /// </summary>
                     /// <description>
                     /// Как правило используется для оповещения объекта, выполняющего асинхронную операцию, о том, что ее следует отменить.
                     /// </description>
                     public event EventHandler Cancelled;
                     /// <summary>
                     /// Выполняет обещание, сообщая об успешном выполнении.
                     /// </summary>
                     /// <param name="result">Результат выполнения.</param>
                     /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
                     public void Resolve(T result) {
                         lock (this) {
                             if (m_state == PromiseState.Cancelled)
                                 return;
                             if (m_state != PromiseState.Unresolved)
                                 throw new InvalidOperationException("The promise is already resolved");
                             m_result = result;
                             m_state = PromiseState.Resolved;
                         }
-                        ResultHandlerInfo handler;
+                        // state has been changed to rejected new handlers can't be added
+                        foreach (var handler in m_resultHandlers)
+                            InvokeHandler(handler);
+                        /* ResultHandlerInfo handler;
                         while (FetchNextHandler(out handler))
-                            InvokeHandler(handler);
+                            InvokeHandler(handler); */
                     }
                     /// <summary>
                     /// Выполняет обещание, сообщая об ошибке
                     /// </summary>
                     /// <param name="error">Исключение возникшее при выполнении операции</param>
                     /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
                     public void Reject(Exception error) {
                         lock (this) {
                             if (m_state == PromiseState.Cancelled)
                                 return;
                             if (m_state != PromiseState.Unresolved)
                                 throw new InvalidOperationException("The promise is already resolved");
                             m_error = error;
                             m_state = PromiseState.Rejected;
                         }
-                        ResultHandlerInfo handler;
+                        // state has been changed to rejected new handlers can't be added
+                        foreach (var handler in m_resultHandlers)
+                            InvokeHandler(handler);
+                        /*ResultHandlerInfo handler;
                         while (FetchNextHandler(out handler))
-                            InvokeHandler(handler);
+                            InvokeHandler(handler);*/
                     }
                     /// <summary>
                     /// Отменяет операцию, если это возможно.
                     /// </summary>
                     /// <returns><c>true</c> Операция была отменена, обработчики не будут вызваны.<c>false</c> отмена не возможна, поскольку обещание уже выполнено и обработчики отработали.</returns>
                     public bool Cancel() {
-                        lock (this) {
+                        return Cancel(true);
-                            if (m_state == PromiseState.Unresolved && m_cancellable)
-                                m_state = PromiseState.Cancelled;
-                                EventHandler temp = Cancelled;
-                                if (temp != null)
-                                    temp(this, new EventArgs());
-                                return true;
-                            } else
-                                return false;
                     }
                     /// <summary>
                     /// Добавляет обработчики событий выполнения обещания.
                     /// </summary>
                     /// <param name="success">Обработчик успешного выполнения обещания.
                     /// Данному обработчику будет передан результат выполнения операции.</param>
                     /// <param name="error">Обработчик ошибки. Данный обработчик получит
                     /// исключение возникшее при выполнении операции.</param>
                     /// <returns>Само обещание</returns>
                     public Promise<T> Then(ResultHandler<T> success, ErrorHandler error) {
                         if (success == null && error == null)
                             return this;
                         var medium = new Promise<T>();
                         var handlerInfo = new ResultHandlerInfo();
                         if (success != null)
                             handlerInfo.resultHandler = x => {
                                 try {
                                     success(x);
                                     medium.Resolve(x);
                                 } catch (Exception e) {
                                     medium.Reject(e);
                                 }
                             };
                         else
                             handlerInfo.resultHandler = x => medium.Resolve(x);
                         if (error != null)
                             handlerInfo.errorHandler = x => {
                                 try {
                                     error(x);
                                 } catch { }
                                 medium.Reject(x);
                             };
                         else
                             handlerInfo.errorHandler = x => medium.Reject(x);
                         AddHandler(handlerInfo);
                         return medium;
                     }
                     public Promise<T> Then(ResultHandler<T> success) {
                         return Then(success, null);
                     }
                     public Promise<T> Error(ErrorHandler error) {
                         return Then(null, error);
                     }
                     public Promise<T> Anyway(Action handler) {
                         if (handler == null)
                             return this;
                         var medium = new Promise<T>();
                         AddHandler(new ResultHandlerInfo {
                             resultHandler = x => {
                                 try {
                                     handler();
                                     medium.Resolve(x);
                                 } catch (Exception e) {
                                     medium.Reject(e);
                                 }
                             },
                             errorHandler = x => {
                                 try {
                                     handler();
                                 } catch { }
                                 medium.Reject(x);
                             }
                         });
                         return medium;
                     }
                     /// <summary>
                     /// Позволяет преобразовать результат выполения операции к новому типу.
                     /// </summary>
                     /// <typeparam name="TNew">Новый тип результата.</typeparam>
                     /// <param name="mapper">Преобразование результата к новому типу.</param>
                     /// <param name="error">Обработчик ошибки. Данный обработчик получит
                     /// исключение возникшее при выполнении операции.</param>
                     /// <returns>Новое обещание, которое будет выполнено при выполнении исходного обещания.</returns>
                     public Promise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler error) {
                         if (mapper == null)
                             throw new ArgumentNullException("mapper");
                         // создаем прицепленное обещание
                         Promise<TNew> chained = new Promise<TNew>();
                         AddHandler(new ResultHandlerInfo() {
                             resultHandler = delegate(T result) {
                                 try {
                                     // если преобразование выдаст исключение, то сработает reject сцепленного deferred
                                     chained.Resolve(mapper(result));
                                 } catch (Exception e) {
                                     chained.Reject(e);
                                 }
                             },
                             errorHandler = delegate(Exception e) {
                                 if (error != null)
                                     error(e);
                                 // в случае ошибки нужно передать исключение дальше по цепочке
                                 chained.Reject(e);
                             }
                         });
                         return chained;
                     }
                     public Promise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper) {
                         return Map(mapper, null);
                     }
                     /// <summary>
                     /// Сцепляет несколько аснхронных операций. Указанная асинхронная операция будет вызвана после
                     /// выполнения текущей, а результат текущей операции может быть использован для инициализации
                     /// новой операции.
                     /// </summary>
                     /// <typeparam name="TNew">Тип результата указанной асинхронной операции.</typeparam>
                     /// <param name="chained">Асинхронная операция, которая должна будет начаться после выполнения текущей.</param>
                     /// <param name="error">Обработчик ошибки. Данный обработчик получит
                     /// исключение возникшее при выполнении текуещй операции.</param>
                     /// <returns>Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции.</returns>
                     public Promise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained, ErrorHandler error) {
                         // проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно
                         // создать посредника, к которому будут подвызяваться следующие обработчики.
                         // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы
                         // передать через него результаты работы.
                         Promise<TNew> medium = new Promise<TNew>();
                         AddHandler(new ResultHandlerInfo() {
                             resultHandler = delegate(T result) {
                                 try {
                                     chained(result).Then(
                                         x => medium.Resolve(x),
                                         e => medium.Reject(e)
                                         );
                                 } catch (Exception e) {
                                     // если сцепленное действие выдало исключение вместо обещания, то передаем ошибку по цепочке
                                     medium.Reject(e);
                                 }
                             },
                             errorHandler = delegate(Exception e) {
                                 if (error != null)
                                     error(e);
                                 // в случае ошибки нужно передать исключение дальше по цепочке
                                 medium.Reject(e);
                             }
                         });
                         return medium;
                     }
                     public Promise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained) {
                         return Chain(chained, null);
                     }
                     /// <summary>
                     /// Дожидается отложенного обещания и в случае успеха, возвращает
                     /// его, результат, в противном случае бросает исключение.
                     /// </summary>
                     /// <remarks>
                     /// <para>
                     /// Если ожидание обещания было прервано по таймауту, это не значит,
                     /// что обещание было отменено или что-то в этом роде, это только
                     /// означает, что мы его не дождались, однако все зарегистрированные
                     /// обработчики, как были так остались и они будут вызваны, когда
                     /// обещание будет выполнено.
                     /// </para>
                     /// <para>
                     /// Такое поведение вполне оправдано поскольку таймаут может истечь
                     /// в тот момент, когда началась обработка цепочки обработчиков, и
                     /// к тому же текущее обещание может стоять в цепочке обещаний и его
                     /// отклонение может привести к непрогнозируемому результату.
                     /// </para>
                     /// </remarks>
                     /// <param name="timeout">Время ожидания</param>
                     /// <returns>Результат выполнения обещания</returns>
                     public T Join(int timeout) {
                         ManualResetEvent evt = new ManualResetEvent(false);
                         Anyway(() => evt.Set());
                         if (!evt.WaitOne(timeout, true))
                             throw new TimeoutException();
                         if (m_error != null)
                             throw new TargetInvocationException(m_error);
                         else
                             return m_result;
                     }
                     public T Join() {
                         return Join(Timeout.Infinite);
                     }
                     /// <summary>
                     /// Данный метод последовательно извлекает обработчики обещания и когда
                     /// их больше не осталось - ставит состояние "разрешено".
                     /// </summary>
                     /// <param name="handler">Информация об обработчике</param>
                     /// <returns>Признак того, что еще остались обработчики в очереди</returns>
                     bool FetchNextHandler(out ResultHandlerInfo handler) {
                         handler = default(ResultHandlerInfo);
                         lock (this) {
                             Debug.Assert(m_state != PromiseState.Unresolved);
-                            if (m_handlersChain.Count > 0) {
+                            if (m_resultHandlers.Count > 0) {
-                                handler = m_handlersChain.First.Value;
+                                handler = m_resultHandlers.First.Value;
-                                m_handlersChain.RemoveFirst();
+                                m_resultHandlers.RemoveFirst();
                                 return true;
                             } else {
                                 return false;
                             }
                         }
                     }
                     void AddHandler(ResultHandlerInfo handler) {
                         bool invokeRequired = false;
                         lock (this) {
                             if (m_state == PromiseState.Unresolved)
-                                m_handlersChain.AddLast(handler);
+                                m_resultHandlers.AddLast(handler);
                             else
                                 invokeRequired = true;
                         }
                         // обработчики не должны блокировать сам объект
                         if (invokeRequired)
                             InvokeHandler(handler);
                     }
                     void InvokeHandler(ResultHandlerInfo handler) {
                         if (m_error == null) {
                             try {
                                 if (handler.resultHandler != null)
                                     handler.resultHandler(m_result);
                             } catch { }
                         }
                         if (m_error != null) {
                             try {
                                 if (handler.errorHandler != null)
                                     handler.errorHandler(m_error);
                             } catch { }
                         }
                     }
+                    public bool IsExclusive {
+                        get {
+                            lock (m_lock) {
+                                return m_childrenCount <= 1;
+                            }
+                        }
+                    }
+                    public PromiseState State {
+                        get {
+                            lock (m_lock) {
+                                return m_state;
+                            }
                         }
                     }
+                    public bool Cancel(bool dependencies) {
+                        bool result;
+                        lock (m_lock) {
+                            if (m_state == PromiseState.Unresolved) {
+                                m_state = PromiseState.Cancelled;
+                                result = true;
+                            } else {
+                                result = false;
+                            }
+                        }
+                        if (dependencies && m_parent != null && m_parent.IsExclusive) {
+                            // TODO syncronize IsExclusive, AddHandler, Cancel (maybe CancelExclusive)
+                            m_parent.Cancel(true);
+                        }
+                        if (result) {
+                            // state has been changed to cancelled, new handlers can't be added
+                            foreach (var handler in m_cancelHandlers)
+                                handler();
+                        }
+                        return result;
+                    }
+                }
+            }