pub/ImplabNet: Implab/Promise.cs comparison

comparison Implab/Promise.cs @ 76:c761fc982e1d v2

Refactoring of the IPromise<T> interface Added tests

author	cin
date	Wed, 10 Sep 2014 17:53:05 +0400
parents	4439140706d0
children	4f20870d0816

comparison

equal deleted inserted replaced

-:4439140706d0
+:c761fc982e1d
 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 IPromise<TNew> ChainedOperation<in TSrc,TNew>(TSrc result);
 /// <summary>
 /// Класс для асинхронного получения результатов. Так называемое "обещание".
 /// </summary>
 /// <typeparam name="T">Тип получаемого результата</typeparam>
 }
 public Promise(IPromise parent, bool cancellable) {
 m_cancellable = cancellable;
 if (parent != null)
-Cancelled(() => {
+AddHandler(
-if (parent.IsExclusive)
+null,
-parent.Cancel();
+null,
-});
+() => {
+if (parent.IsExclusive)
+parent.Cancel();
+},
+null
+);
 }
 bool BeginTransit() {
 return UNRESOLVED_SATE == Interlocked.CompareExchange(ref m_state, TRANSITIONAL_STATE, UNRESOLVED_SATE);
 }
 }
 /// <summary>
 /// Отменяет операцию, если это возможно.
 /// </summary>
-/// <returns><c>true</c> Операция была отменена, обработчики не будут вызваны.<c>false</c> отмена не возможна, поскольку обещание уже выполнено и обработчики отработали.</returns>
+/// <remarks>Для определения была ли операция отменена следует использовать свойство <see cref="IsCancelled"/>.</remarks>
-public bool Cancel() {
+public void Cancel() {
 if (m_cancellable && BeginTransit()) {
 CompleteTransit(CANCELLED_STATE);
 OnStateChanged();
-return true;
+}
 }
-return false;
-}
-// сделано для возвращаемого типа void
-protected void InternalCancel() {
-Cancel();
-}
 public IPromise<T> Then(ResultHandler<T> success, ErrorHandler<T> error, Action cancel) {
 if (success == null && error == null && cancel == null)
 return this;
 AddHandler(success, error, null, medium);
 return medium;
 }
-public IPromise Then(Action success, ErrorHandler error, Action cancel) {
-return Then(
-x => success(),
-e => {
-error(e);
-return default(T);
-},
-cancel
-);
-}
-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;
 AddHandler(success, null, null, medium);
 return medium;
 }
+/// <summary>
+/// Последний обработчик в цепочки обещаний.
+/// </summary>
+/// <param name="success"></param>
+/// <param name="error"></param>
+/// <param name="cancel"></param>
+/// <remarks>
+/// <para>
+/// Данный метод не создает связанного с текущим обещания и предназначен для окончания
+/// фсинхронной цепочки.
+/// </para>
+/// <para>
+/// Если данный метод вызвать несколько раз, либо добавить другие обработчики, то цепочка
+/// не будет одиночной <see cref="IsExclusive"/> и, как следствие, будет невозможна отмена
+/// всей цепи обещаний снизу (с самого последнего обещания).
+/// </para>
+/// </remarks>
 public void Last(ResultHandler<T> success, ErrorHandler error, Action cancel) {
 if (success == null && error == null && cancel == null)
 return;
 ErrorHandler<T> errorHandler = null;
 Last(success, error, null);
 }
 public void Last(ResultHandler<T> success) {
 Last(success, null, null);
-}
-public void Last(Action success,ErrorHandler error, Action cancel) {
-Last(x => success(), error, cancel);
-}
-public void Last(Action success,ErrorHandler error) {
-Last(x => success(), error, null);
-}
-public void Last(Action success) {
-Last(x => success(), null, null);
 }
 public IPromise Error(ErrorHandler error) {
 if (error == null)
 return this;
 /// <typeparam name="TNew">Новый тип результата.</typeparam>
 /// <param name="mapper">Преобразование результата к новому типу.</param>
 /// <param name="error">Обработчик ошибки. Данный обработчик получит
 /// исключение возникшее при выполнении операции.</param>
 /// <returns>Новое обещание, которое будет выполнено при выполнении исходного обещания.</returns>
-public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler<T> error) {
+public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler<TNew> error, Action cancel) {
-if (mapper == null)
+Safe.ArgumentNotNull(mapper, "mapper");
-throw new ArgumentNullException("mapper");
 // создаем прицепленное обещание
-var chained = new Promise<TNew>(this, true);
+var medium = new Promise<TNew>(this, true);
-ResultHandler<T> resultHandler = result => chained.Resolve(mapper(result));
+ResultHandler<T> resultHandler = result => medium.Resolve(mapper(result));
 ErrorHandler<T> errorHandler;
 if (error != null)
 errorHandler = e => {
 try {
-return error(e);
+medium.Resolve(error(e));
 } catch (Exception e2) {
 // в случае ошибки нужно передать исключение дальше по цепочке
-chained.Reject(e2);
+medium.Reject(e2);
 }
 return default(T);
 };
 else
 errorHandler = e => {
-chained.Reject(e);
+medium.Reject(e);
 return default(T);
 };
+Action cancelHandler;
+if (cancel != null)
+cancelHandler = () => {
+cancel();
+medium.Cancel();
+};
+else
+cancelHandler = medium.Cancel;
 AddHandler(
 resultHandler,
 errorHandler,
-chained.InternalCancel,
+cancelHandler,
 null
 );
-return chained;
+return medium;
+}
+public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler<TNew> error) {
+return Then(mapper, error, null);
 }
 public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper) {
-return Then(mapper, null);
+return Then(mapper, null, null);
 }
 /// <summary>
 /// Сцепляет несколько аснхронных операций. Указанная асинхронная операция будет вызвана после
 /// выполнения текущей, а результат текущей операции может быть использован для инициализации
 /// <typeparam name="TNew">Тип результата указанной асинхронной операции.</typeparam>
 /// <param name="chained">Асинхронная операция, которая должна будет начаться после выполнения текущей.</param>
 /// <param name="error">Обработчик ошибки. Данный обработчик получит
 /// исключение возникшее при выполнении текуещй операции.</param>
 /// <returns>Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции.</returns>
-public IPromise<TNew> Then<TNew>(ChainedOperation<T, TNew> chained, ErrorHandler<T> error) {
+public IPromise<TNew> Chain<TNew>(ResultMapper<T, IPromise<TNew>> chained, ErrorHandler<IPromise<TNew>> error, Action cancel) {
+Safe.ArgumentNotNull(chained, "chained");
 // проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно
 // создать посредника, к которому будут подвызяваться следующие обработчики.
 // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы
 // передать через него результаты работы.
 if (medium.IsCancelled)
 return;
 var promise = chained(result);
-promise.Then(
+promise.Last(
 medium.Resolve,
-err => {
+medium.Reject,
-medium.Reject(err);
+() => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
-throw new TransientPromiseException(err);
-}
 );
 // notify chained operation that it's not needed anymore
 // порядок вызова Then, Cancelled важен, поскольку от этого
 // зависит IsExclusive
 medium.Cancelled(() => {
 if (promise.IsExclusive)
 promise.Cancel();
 });
-// внешняя отмена связанной операции рассматривается как ошибка
-promise.Cancelled(() => medium.Reject(new OperationCanceledException()));
 };
-ErrorHandler<T> errorHandler = delegate(Exception e) {
+ErrorHandler<T> errorHandler;
-if (error != null) {
+if (error != null)
+errorHandler = delegate(Exception e) {
 try {
-return error(e);
+var promise = error(e);
+promise.Last(
+medium.Resolve,
+medium.Reject,
+() => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
+);
+// notify chained operation that it's not needed anymore
+// порядок вызова Then, Cancelled важен, поскольку от этого
+// зависит IsExclusive
+medium.Cancelled(() => {
+if (promise.IsExclusive)
+promise.Cancel();
+});
 } catch (Exception e2) {
 medium.Reject(e2);
-return default(T);
 }
-}
+return default(T);
-// в случае ошибки нужно передать исключение дальше по цепочке
+};
-medium.Reject(e);
+else
-return default(T);
+errorHandler = err => {
-};
+medium.Reject(err);
+return default(T);
+};
+Action cancelHandler;
+if (cancel != null)
+cancelHandler = () => {
+if (cancel != null)
+cancel();
+medium.Cancel();
+};
+else
+cancelHandler = medium.Cancel;
 AddHandler(
 resultHandler,
 errorHandler,
-medium.InternalCancel,
+cancelHandler,
 null
 );
 return medium;
 }
-public IPromise<TNew> Then<TNew>(ChainedOperation<T, TNew> chained) {
+public IPromise<TNew> Chain<TNew>(ResultMapper<T, IPromise<TNew>> chained, ErrorHandler<IPromise<TNew>> error) {
-return Then(chained, null);
+return Chain(chained, error, null);
+}
+public IPromise<TNew> Chain<TNew>(ResultMapper<T, IPromise<TNew>> chained) {
+return Chain(chained, null, null);
 }
 public IPromise<T> Cancelled(Action handler) {
-var medium = new Promise<T>(this, true);
+var medium = new Promise<T>(this,true);
 AddHandler(null, null, handler, medium);
 return medium;
 }
 /// <summary>
 /// Adds the specified handler for all cases (success, error, cancel)
 /// </summary>
 /// <param name="handler">The handler that will be called anyway</param>
 /// <returns>self</returns>
-public IPromise<T> Finally(Action handler) {
+public IPromise<T> Anyway(Action handler) {
-if (handler == null)
+Safe.ArgumentNotNull(handler, "handler");
-throw new ArgumentNullException("handler");
 AddHandler(
 x => handler(),
 e => {
 handler();
 throw new TransientPromiseException(e);
 /// </remarks>
 /// <param name="timeout">Время ожидания</param>
 /// <returns>Результат выполнения обещания</returns>
 public T Join(int timeout) {
 var evt = new ManualResetEvent(false);
-Finally(() => evt.Set());
+Anyway(() => evt.Set());
 if (!evt.WaitOne(timeout, true))
 throw new TimeoutException();
 switch (m_state) {
 return p;
 }
 #region IPromiseBase explicit implementation
+IPromise IPromise.Then(Action success, ErrorHandler error, Action cancel) {
+return Then(
+x => success(),
+e => {
+error(e);
+return default(T);
+},
+cancel
+);
+}
+IPromise IPromise.Then(Action success, ErrorHandler error) {
+return Then(
+x => success(),
+e => {
+error(e);
+return default(T);
+}
+);
+}
+IPromise IPromise.Then(Action success) {
+return Then(x => success());
+}
+void IPromise.Last(Action success, ErrorHandler error, Action cancel) {
+Last(x => success(), error, cancel);
+}
+void IPromise.Last(Action success, ErrorHandler error) {
+Last(x => success(), error, null);
+}
+void IPromise.Last(Action success) {
+Last(x => success(), null, null);
+}
 IPromise IPromise.Error(ErrorHandler error) {
 return Error(error);
 }
-IPromise IPromise.Finally(Action handler) {
+IPromise IPromise.Anyway(Action handler) {
-return Finally(handler);
+return Anyway(handler);
 }
 IPromise IPromise.Cancelled(Action handler) {
 return Cancelled(handler);
 }

Mercurial > pub > ImplabNet

comparison Implab/Promise.cs @ 76:c761fc982e1d v2