pub/ImplabNet: Implab/Promise.cs comparison

comparison Implab/Promise.cs @ 72:d67b95eddaf4 v2

promises refactoring

author	cin
date	Thu, 04 Sep 2014 18:47:12 +0400
parents	1714fd8678ef
children	c4140283575c

comparison

equal deleted inserted replaced

-:1714fd8678ef
+:d67b95eddaf4
 namespace Implab {
 public delegate void ErrorHandler(Exception e);
 public delegate T ErrorHandler<out T>(Exception e);
 public delegate void ResultHandler<in T>(T result);
-public delegate TNew ResultMapper<in TSrc, out TNew>(TSrc result);
+public delegate TNew ResultMapper<in TSrc,out TNew>(TSrc result);
-public delegate IPromise<TNew> ChainedOperation<in TSrc, TNew>(TSrc result);
+public delegate IPromise<TNew> ChainedOperation<in TSrc,TNew>(TSrc result);
 /// <summary>
 /// Класс для асинхронного получения результатов. Так называемое "обещание".
 /// </summary>
 /// <typeparam name="T">Тип получаемого результата</typeparam>
 /// </remarks>
 public class Promise<T> : IPromise<T> {
 protected struct HandlerDescriptor {
 public ResultHandler<T> resultHandler;
-public ErrorHandler errorHandler;
+public ErrorHandler<T> errorHandler;
 public Action cancellHandler;
+public Promise<T> medium;
 public void Resolve(T result) {
-if (resultHandler != null)
+if (resultHandler != null) {
 try {
 resultHandler(result);
 } catch (Exception e) {
 Reject(e);
+return;
 }
+}
+if (medium != null)
+medium.Resolve(result);
 }
 public void Reject(Exception err) {
-if (errorHandler != null)
+if (errorHandler != null) {
 try {
-errorHandler(err);
+var res = errorHandler(err);
-} catch {
+if (medium != null)
+medium.Resolve(res);
+} catch (TransientPromiseException err2) {
+if (medium != null)
+medium.Reject(err2.InnerException);
+} catch (Exception err2) {
+if (medium != null)
+medium.Reject(err2);
 }
+} else if (medium != null)
+medium.Reject(err);
 }
 public void Cancel() {
-if (cancellHandler != null)
+if (cancellHandler != null) {
 try {
 cancellHandler();
-} catch {
+} catch (Exception err) {
+Reject(err);
+return;
 }
+}
+if (medium != null)
+medium.Cancel();
 }
 }
 const int UNRESOLVED_SATE = 0;
 const int TRANSITIONAL_STATE = 1;
 }
 public Promise(IPromise parent, bool cancellable) {
 m_cancellable = cancellable;
 if (parent != null)
-AddHandler(
+Cancelled(() => {
-null,
+if (parent.IsExclusive)
-null,
+parent.Cancel();
-() => {
+});
-if (parent.IsExclusive)
-parent.Cancel();
-}
-);
 }
 bool BeginTransit() {
 return UNRESOLVED_SATE == Interlocked.CompareExchange(ref m_state, TRANSITIONAL_STATE, UNRESOLVED_SATE);
 }
 /// <summary>
 /// Отменяет операцию, если это возможно.
 /// </summary>
 /// <returns><c>true</c> Операция была отменена, обработчики не будут вызваны.<c>false</c> отмена не возможна, поскольку обещание уже выполнено и обработчики отработали.</returns>
 public bool Cancel() {
-if (BeginTransit()) {
+if (m_cancellable && BeginTransit()) {
 CompleteTransit(CANCELLED_STATE);
 OnStateChanged();
 return true;
-} else {
+}
 return false;
-}
 }
 // сделано для возвращаемого типа void
 protected void InternalCancel() {
 Cancel();
-}
-/// <summary>
-/// Adds new handlers to this promise.
-/// </summary>
-/// <param name="success">The handler of the successfully completed operation.
-/// This handler will recieve an operation result as a parameter.</param>
-/// <param name="error">Handles an exception that may occur during the operation.</param>
-/// <returns>The new promise chained to this one.</returns>
-public IPromise<T> Then(ResultHandler<T> success, ErrorHandler error) {
-if (success == null && error == null)
-return this;
-var medium = new Promise<T>(this, true);
-ResultHandler<T> resultHandler;
-if (success != null)
-resultHandler = x => {
-success(x);
-medium.Resolve(x);
-};
-else
-resultHandler = medium.Resolve;
-ErrorHandler errorHandler;
-if (error != null)
-errorHandler = x => {
-// несмотря на то, что обработчик ошибки вызывается безопасно,
-// т.е. возникшие в нем ошибки будут подавлены, нам нужно
-// гарантировать, что ошибка будет передана дальше по цепочке обещаний
-try {
-error(x);
-} catch { }
-medium.Reject(x);
-};
-else
-errorHandler = medium.Reject;
-AddHandler(resultHandler, errorHandler, medium.InternalCancel);
-return medium;
-}
-public IPromise Then(Action success, ErrorHandler error) {
-return Then(x => success(), error);
-}
-public IPromise Then(Action success) {
-return Then(x => success());
 }
 /// <summary>
 /// Adds new handlers to this promise.
 /// </summary>
 if (success == null && error == null)
 return this;
 var medium = new Promise<T>(this, true);
-ResultHandler<T> resultHandler;
+AddHandler(success, error, null, medium);
-ErrorHandler errorHandler;
-if (success != null)
-resultHandler = x => {
-success(x);
-medium.Resolve(x);
-};
-else
-resultHandler = medium.Resolve;
-if (error != null)
-errorHandler = x => {
-try {
-medium.Resolve(error(x));
-} catch (Exception e) {
-medium.Reject(e);
-}
-};
-else
-errorHandler = medium.Reject;
-AddHandler(resultHandler, errorHandler, medium.InternalCancel);
 return medium;
+}
+public IPromise Then(Action success, ErrorHandler error) {
+return Then(
+x => success(),
+e => {
+error(e);
+return default(T);
+}
+);
+}
+public IPromise Then(Action success) {
+return Then(x => success());
 }
 public IPromise<T> Then(ResultHandler<T> success) {
 if (success == null)
 return this;
 var medium = new Promise<T>(this, true);
-ResultHandler<T> resultHandler;
+AddHandler(success, null, null, medium);
-if (success != null)
-resultHandler = x => {
-success(x);
-medium.Resolve(x);
-};
-else
-resultHandler = medium.Resolve;
-AddHandler(resultHandler, medium.Reject, medium.InternalCancel);
 return medium;
 }
-public IPromise<T> Error(ErrorHandler error) {
+public IPromise Error(ErrorHandler error) {
-return Then((ResultHandler<T>)null, error);
+if (error == null)
+return this;
+var medium = new Promise<T>(this, true);
+AddHandler(
+null,
+e => {
+error(e);
+return default(T);
+},
+null,
+medium
+);
+return medium;
 }
 /// <summary>
 /// Handles error and allows to keep the promise.
 /// </summary>
 if (handler == null)
 return this;
 var medium = new Promise<T>(this, true);
-AddHandler(
+AddHandler(null, handler, null, medium);
-x => medium.Resolve(x),
-e => {
-try {
-medium.Resolve(handler(e));
-} catch (Exception e2) {
-medium.Reject(e2);
-}
-},
-medium.InternalCancel
-);
 return medium;
 }
 public IPromise<T> Anyway(Action handler) {
 if (handler == null)
 return this;
-var medium = new Promise<T>(this,true);
+var medium = new Promise<T>(this, true);
 AddHandler(
-x => {
+x => handler(),
-// to avoid handler being called multiple times we handle exception by ourselfs
+e => {
-try {
+handler();
-handler();
+throw new TransientPromiseException(e);
-medium.Resolve(x);
-} catch (Exception e) {
-medium.Reject(e);
-}
 },
+null,
-e => {
+medium
-try {
-handler();
-} catch { }
-medium.Reject(e);
-},
-medium.InternalCancel
 );
 return medium;
 }
 /// <typeparam name="TNew">Новый тип результата.</typeparam>
 /// <param name="mapper">Преобразование результата к новому типу.</param>
 /// <param name="error">Обработчик ошибки. Данный обработчик получит
 /// исключение возникшее при выполнении операции.</param>
 /// <returns>Новое обещание, которое будет выполнено при выполнении исходного обещания.</returns>
-public IPromise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler error) {
+public IPromise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler<T> error) {
 if (mapper == null)
 throw new ArgumentNullException("mapper");
 // создаем прицепленное обещание
-var chained = new Promise<TNew>(this,true);
+var chained = new Promise<TNew>(this, true);
 ResultHandler<T> resultHandler = result => chained.Resolve(mapper(result));
-ErrorHandler errorHandler = delegate(Exception e) {
+ErrorHandler<T> errorHandler;
 if (error != null)
+errorHandler = e => {
 try {
-error(e);
+return error(e);
-} catch { }
+} catch (Exception e2) {
 // в случае ошибки нужно передать исключение дальше по цепочке
-chained.Reject(e);
+chained.Reject(e2);
-};
+}
+return default(T);
+};
+else
+errorHandler = e => {
+chained.Reject(e);
+return default(T);
+};
 AddHandler(
 resultHandler,
 errorHandler,
-chained.InternalCancel
+chained.InternalCancel,
+null
 );
 return chained;
 }
 /// <typeparam name="TNew">Тип результата указанной асинхронной операции.</typeparam>
 /// <param name="chained">Асинхронная операция, которая должна будет начаться после выполнения текущей.</param>
 /// <param name="error">Обработчик ошибки. Данный обработчик получит
 /// исключение возникшее при выполнении текуещй операции.</param>
 /// <returns>Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции.</returns>
-public IPromise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained, ErrorHandler error) {
+public IPromise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained, ErrorHandler<T> error) {
 // проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно
 // создать посредника, к которому будут подвызяваться следующие обработчики.
 // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы
 // передать через него результаты работы.
 return;
 var promise = chained(result);
 promise.Then(
-x => medium.Resolve(x),
+medium.Resolve,
-e => medium.Reject(e)
+err => {
+medium.Reject(err);
+throw new TransientPromiseException(err);
+}
 );
 // notify chained operation that it's not needed anymore
 // порядок вызова Then, Cancelled важен, поскольку от этого
 // зависит IsExclusive
 medium.Cancelled(() => {
-if(promise.IsExclusive)
+if (promise.IsExclusive)
 promise.Cancel();
 });
 // внешняя отмена связанной операции рассматривается как ошибка
 promise.Cancelled(() => medium.Reject(new OperationCanceledException()));
 };
-ErrorHandler errorHandler = delegate(Exception e) {
+ErrorHandler<T> errorHandler = delegate(Exception e) {
-if (error != null)
+if (error != null) {
-error(e);
+try {
+return error(e);
+} catch (Exception e2) {
+medium.Reject(e2);
+return default(T);
+}
+}
 // в случае ошибки нужно передать исключение дальше по цепочке
 medium.Reject(e);
+return default(T);
 };
 AddHandler(
 resultHandler,
 errorHandler,
-medium.InternalCancel
+medium.InternalCancel,
+null
 );
 return medium;
 }
 public IPromise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained) {
 return Chain(chained, null);
 }
 public IPromise<T> Cancelled(Action handler) {
-AddHandler(null, null, handler);
+AddHandler(null, null, handler, null);
 return this;
 }
 /// <summary>
 /// Adds the specified handler for all cases (success, error, cancel)
 public IPromise<T> Finally(Action handler) {
 if (handler == null)
 throw new ArgumentNullException("handler");
 AddHandler(
 x => handler(),
-e => handler(),
+e => {
-handler
+handler();
+throw new TransientPromiseException(e);
+},
+handler,
+null
 );
 return this;
 }
 /// <summary>
 public T Join() {
 return Join(Timeout.Infinite);
 }
-void AddHandler(ResultHandler<T> success, ErrorHandler error, Action cancel) {
+void AddHandler(ResultHandler<T> success, ErrorHandler<T> error, Action cancel, Promise<T> medium) {
 if (success != null || error != null)
 Interlocked.Increment(ref m_childrenCount);
-HandlerDescriptor handler = new HandlerDescriptor {
+var handler = new HandlerDescriptor {
 resultHandler = success,
 errorHandler = error,
-cancellHandler = cancel
+cancellHandler = cancel,
+medium = medium
 };
 bool queued;
 if (!IsResolved) {
 x => {
 result[dest] = x;
 if (Interlocked.Decrement(ref pending) == 0)
 promise.Resolve(result);
 },
-e => promise.Reject(e)
+e => {
+promise.Reject(e);
+return default(T);
+}
 );
 } else {
 if (Interlocked.Decrement(ref pending) == 0)
 promise.Resolve(result);
 }

Mercurial > pub > ImplabNet

comparison Implab/Promise.cs @ 72:d67b95eddaf4 v2