pub/ImplabNet: Implab/Promise.cs comparison

comparison Implab/Promise.cs @ 11:6ec82bf68c8e promises

refactoring

author	cin
date	Tue, 05 Nov 2013 01:09:58 +0400
parents	aa33d0bb8c0c
children	e943453e5039

comparison

equal deleted inserted replaced

-:aa33d0bb8c0c
+:6ec82bf68c8e
 using System.Threading;
 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 Promise<TNew> ChainedOperation<in TSrc, TNew>(TSrc result);
 /// <summary>
 /// <returns><c>true</c> Операция была отменена, обработчики не будут вызваны.<c>false</c> отмена не возможна, поскольку обещание уже выполнено и обработчики отработали.</returns>
 public bool Cancel() {
 return Cancel(true);
 }
+/// <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 Promise<T> Then(ResultHandler<T> success, ErrorHandler error) {
+if (success == null && error == null)
+return this;
+var medium = new Promise<T>(this, true);
+var handlerInfo = new ResultHandlerInfo();
+if (success != null)
+handlerInfo.resultHandler = x => {
+success(x);
+medium.Resolve(x);
+};
+else
+handlerInfo.resultHandler = medium.Resolve;
+if (error != null)
+handlerInfo.errorHandler = x => {
+try {
+error(x);
+} catch { }
+medium.Reject(x);
+};
+else
+handlerInfo.errorHandler = medium.Reject;
+AddHandler(handlerInfo);
+return medium;
+}
+/// <summary>
+/// Adds new handlers to this promise.
+/// </summary>
+/// <param name="success">The handler of the successfully completed operation.
+/// This handler will recieve an operation result as a parameter.</param>
+/// <param name="error">Handles an exception that may occur during the operation and returns the value which will be used as the result of the operation.</param>
+/// <returns>The new promise chained to this one.</returns>
+public Promise<T> Then(ResultHandler<T> success, ErrorHandler<T> error) {
+if (success == null && error == null)
+return this;
+var medium = new Promise<T>(this, true);
+var handlerInfo = new ResultHandlerInfo();
+if (success != null)
+handlerInfo.resultHandler = x => {
+success(x);
+medium.Resolve(x);
+};
+else
+handlerInfo.resultHandler = medium.Resolve;
+if (error != null)
+handlerInfo.errorHandler = x => {
+try {
+medium.Resolve(error(x));
+} catch { }
+medium.Reject(x);
+};
+else
+handlerInfo.errorHandler = medium.Reject;
+AddHandler(handlerInfo);
+return medium;
+}
+public Promise<T> Then(ResultHandler<T> success) {
+if (success == null)
+return this;
+var medium = new Promise<T>(this, true);
+var handlerInfo = new ResultHandlerInfo();
+if (success != null)
+handlerInfo.resultHandler = x => {
+success(x);
+medium.Resolve(x);
+};
+else
+handlerInfo.resultHandler = medium.Resolve;
+handlerInfo.errorHandler = medium.Reject;
+AddHandler(handlerInfo);
+return medium;
+}
+public Promise<T> Error(ErrorHandler error) {
+return Then(null, error);
+}
+/// <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 Promise<T> Error(ErrorHandler<T> handler) {
+if (handler == null)
+return this;
+var medium = new Promise<T>(this, true);
+AddHandler(new ResultHandlerInfo {
+errorHandler = e => {
+try {
+medium.Resolve(handler(e));
+} catch (Exception e2) {
+medium.Reject(e2);
+}
+}
+});
+return medium;
+}
+public Promise<T> Anyway(Action handler) {
+if (handler == null)
+return this;
+var medium = new Promise<T>();
+AddHandler(new ResultHandlerInfo {
+resultHandler = x => {
+// to avoid handler being called multiple times we handle exception by ourselfs
+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");
+// создаем прицепленное обещание
+var chained = new Promise<TNew>();
+AddHandler(new ResultHandlerInfo() {
+resultHandler = result => chained.Resolve(mapper(result)),
+errorHandler = delegate(Exception e) {
+if (error != null)
+try {
+error(e);
+} catch { }
+// в случае ошибки нужно передать исключение дальше по цепочке
+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) {
+// проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно
+// создать посредника, к которому будут подвызяваться следующие обработчики.
+// когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы
+// передать через него результаты работы.
+var medium = new Promise<TNew>(this, true);
+AddHandler(new ResultHandlerInfo {
+resultHandler = delegate(T result) {
+if (medium.State == PromiseState.Cancelled)
+return;
+var promise = chained(result);
+// notify chained operation that it's not needed
+medium.Cancelled(() => promise.Cancel());
+promise.Then(
+x => medium.Resolve(x),
+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);
+}
+public Promise<T> Cancelled(Action handler) {
+if (handler == null)
+return this;
+lock (m_lock) {
+if (m_state == PromiseState.Unresolved)
+m_cancelHandlers.AddLast(handler);
+else if (m_state == PromiseState.Cancelled)
+handler();
+}
+return this;
+}
+public void HandleCancelled(Action handler) {
+Cancelled(handler);
+}
+/// <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());
+Cancelled(() => evt.Set());
+if (!evt.WaitOne(timeout, true))
+throw new TimeoutException();
+switch (State) {
+case PromiseState.Resolved:
+return m_result;
+case PromiseState.Cancelled:
+throw new OperationCanceledException();
+case PromiseState.Rejected:
+throw new TargetInvocationException(m_error);
+default:
+throw new ApplicationException(String.Format("Invalid promise state {0}", State));
+}
+}
+public T Join() {
+return Join(Timeout.Infinite);
+}
+void AddHandler(ResultHandlerInfo handler) {
+bool invokeRequired = false;
+lock (m_lock) {
+m_childrenCount++;
+if (m_state == PromiseState.Unresolved) {
+m_resultHandlers.AddLast(handler);
+} else
+invokeRequired = true;
+}
+// обработчики не должны блокировать сам объект
+if (invokeRequired)
+InvokeHandler(handler);
+}
+void InvokeHandler(ResultHandlerInfo handler) {
+switch (m_state) {
+case PromiseState.Resolved:
+try {
+if (handler.resultHandler != null)
+handler.resultHandler(m_result);
+} catch (Exception e) {
+try {
+if (handler.errorHandler != null)
+handler.errorHandler(e);
+} catch { }
+}
+break;
+case PromiseState.Rejected:
+try {
+if (handler.errorHandler != null)
+handler.errorHandler(m_error);
+} catch { }
+break;
+default:
+// do nothing
+return;
+}
+}
 protected virtual void OnStateChanged() {
 switch (m_state) {
 case PromiseState.Resolved:
 foreach (var resultHandlerInfo in m_resultHandlers)
 try {
 m_resultHandlers = null;
 m_cancelHandlers = null;
 }
-/// <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 => {
-success(x);
-medium.Resolve(x);
-};
-else
-handlerInfo.resultHandler = medium.Resolve;
-if (error != null)
-handlerInfo.errorHandler = x => {
-try {
-error(x);
-} catch { }
-medium.Reject(x);
-};
-else
-handlerInfo.errorHandler = medium.Reject;
-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 => {
-// to avoid handler being called multiple times we handle exception by ourselfs
-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");
-// создаем прицепленное обещание
-var chained = new Promise<TNew>();
-AddHandler(new ResultHandlerInfo() {
-resultHandler = result => chained.Resolve(mapper(result)),
-errorHandler = delegate(Exception e) {
-if (error != null)
-try {
-error(e);
-} catch { }
-// в случае ошибки нужно передать исключение дальше по цепочке
-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) {
-// проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно
-// создать посредника, к которому будут подвызяваться следующие обработчики.
-// когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы
-// передать через него результаты работы.
-var medium = new Promise<TNew>(this, true);
-AddHandler(new ResultHandlerInfo {
-resultHandler = delegate(T result) {
-if (medium.State == PromiseState.Cancelled)
-return;
-var promise = chained(result);
-// notify chained operation that it's not needed
-medium.Cancelled(() => promise.Cancel());
-promise.Then(
-medium.Resolve,
-medium.Reject
-);
-},
-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);
-}
-public Promise<T> Cancelled(Action handler) {
-if (handler == null)
-return this;
-lock (m_lock) {
-if (m_state == PromiseState.Unresolved)
-m_cancelHandlers.AddLast(handler);
-else if (m_state == PromiseState.Cancelled)
-handler();
-}
-return this;
-}
-public void HandleCancelled(Action handler) {
-Cancelled(handler);
-}
-/// <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());
-Cancelled(() => evt.Set());
-if (!evt.WaitOne(timeout, true))
-throw new TimeoutException();
-switch (State) {
-case PromiseState.Resolved:
-return m_result;
-case PromiseState.Cancelled:
-throw new OperationCanceledException();
-case PromiseState.Rejected:
-throw new TargetInvocationException(m_error);
-default:
-throw new ApplicationException(String.Format("Invalid promise state {0}", State));
-}
-}
-public T Join() {
-return Join(Timeout.Infinite);
-}
-void AddHandler(ResultHandlerInfo handler) {
-bool invokeRequired = false;
-lock (m_lock) {
-m_childrenCount++;
-if (m_state == PromiseState.Unresolved) {
-m_resultHandlers.AddLast(handler);
-} else
-invokeRequired = true;
-}
-// обработчики не должны блокировать сам объект
-if (invokeRequired)
-InvokeHandler(handler);
-}
-void InvokeHandler(ResultHandlerInfo handler) {
-switch (m_state) {
-case PromiseState.Resolved:
-try {
-if (handler.resultHandler != null)
-handler.resultHandler(m_result);
-} catch (Exception e) {
-try {
-if (handler.errorHandler != null)
-handler.errorHandler(e);
-} catch { }
-}
-break;
-case PromiseState.Rejected:
-try {
-if (handler.errorHandler != null)
-handler.errorHandler(m_error);
-} catch { }
-break;
-default:
-// do nothing
-return;
-}
-}
 public bool IsExclusive {
 get {
 lock (m_lock) {
 return m_state;
 }
 }
 }
-public bool Cancel(bool dependencies) {
+protected bool Cancel(bool dependencies) {
 bool result;
 lock (m_lock) {
 if (m_state == PromiseState.Unresolved) {
 m_state = PromiseState.Cancelled;
 if (result)
 OnStateChanged();
 if (dependencies && m_parent != null && m_parent.IsExclusive) {
-m_parent.Cancel(true);
+m_parent.Cancel();
 }
 return result;
 }
 }

Mercurial > pub > ImplabNet

comparison Implab/Promise.cs @ 11:6ec82bf68c8e promises