pub/ImplabNet: Implab/Promise.cs comparison

comparison Implab/Promise.cs @ 33:b255e4aeef17

removed the reference to the parent from the promise object this allows resolved promises to release parents and results they are holding. Added complete set of operations to IPromiseBase interface Subscribing to the cancellation event of the promise should not affect it's IsExclusive property More tests.

author	cin
date	Thu, 10 Apr 2014 02:39:29 +0400
parents	8eca2652d2ff
children	653c4e04968b

comparison

equal deleted inserted replaced

-:8eca2652d2ff
+:b255e4aeef17
 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);
+public delegate IPromise<TNew> ChainedOperation<in TSrc, TNew>(TSrc result);
 /// <summary>
 /// Класс для асинхронного получения результатов. Так называемое "обещание".
 /// </summary>
 /// <typeparam name="T">Тип получаемого результата</typeparam>
 const int TransitionalState = 1;
 const int SucceededState = 2;
 const int RejectedState = 3;
 const int CancelledState = 4;
-readonly IPromiseBase m_parent;
 readonly bool m_cancellable;
 int m_childrenCount = 0;
 int m_state;
 T m_result;
 m_cancellable = true;
 }
 public Promise(IPromiseBase parent, bool cancellable) {
 m_cancellable = cancellable;
-m_parent = parent;
+if (parent != null)
-}
+AddHandler(
+null,
-void InternalCancel() {
+null,
-// don't try to cancel parent :)
+() => {
-Cancel(false);
+if (parent.IsExclusive)
+parent.Cancel();
+}
+);
 }
 bool BeginTransit() {
 return UnresolvedSate == Interlocked.CompareExchange(ref m_state, TransitionalState, UnresolvedSate);
 }
 } else {
 WaitTransition();
 if (m_state != CancelledState)
 throw new InvalidOperationException("The promise is already resolved");
 }
+}
+/// <summary>
+/// Выполняет обещание, сообщая об успешном выполнении. Результатом выполнения будет пустое значения.
+/// </summary>
+/// <remarks>
+/// Данный вариант удобен в случаях, когда интересен факт выполнения операции, нежели полученное значение.
+/// </remarks>
+public void Resolve() {
+Resolve(default(T));
 }
 /// <summary>
 /// Выполняет обещание, сообщая об ошибке
 /// </summary>
 /// <summary>
 /// Отменяет операцию, если это возможно.
 /// </summary>
 /// <returns><c>true</c> Операция была отменена, обработчики не будут вызваны.<c>false</c> отмена не возможна, поскольку обещание уже выполнено и обработчики отработали.</returns>
 public bool Cancel() {
-return Cancel(true);
+if (BeginTransit()) {
+CompleteTransit(CancelledState);
+OnStateChanged();
+return true;
+} else {
+return false;
+}
+}
+// сделано для возвращаемого типа void
+protected void InternalCancel() {
+Cancel();
 }
 /// <summary>
 /// Adds new handlers to this promise.
 /// </summary>
 AddHandler(resultHandler, errorHandler, medium.InternalCancel);
 return medium;
 }
-public IPromiseBase Then(Action success,ErrorHandler error)
+public IPromiseBase Then(Action success, ErrorHandler error) {
-{
 return Then(x => success(), error);
 }
-public IPromiseBase Then(Action success)
+public IPromiseBase Then(Action success) {
-{
 return Then(x => success());
 }
 /// <summary>
 /// Adds new handlers to this promise.
 if (error != null)
 errorHandler = x => {
 try {
 medium.Resolve(error(x));
-} catch(Exception e) {
+} catch (Exception e) {
 medium.Reject(e);
 }
 };
 else
 errorHandler = medium.Reject;
 public IPromise<T> Anyway(Action handler) {
 if (handler == null)
 return this;
-var medium = new Promise<T>();
+var medium = new Promise<T>(this,true);
 AddHandler(
 x => {
 // to avoid handler being called multiple times we handle exception by ourselfs
 try {
 public IPromise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler error) {
 if (mapper == null)
 throw new ArgumentNullException("mapper");
 // создаем прицепленное обещание
-var chained = new Promise<TNew>();
+var chained = new Promise<TNew>(this,true);
 ResultHandler<T> resultHandler = result => chained.Resolve(mapper(result));
 ErrorHandler errorHandler = delegate(Exception e) {
 if (error != null)
 try {
 if (medium.IsCancelled)
 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)
 );
+// 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 errorHandler = delegate(Exception e) {
 if (error != null)
 error(e);
 public T Join() {
 return Join(Timeout.Infinite);
 }
 void AddHandler(ResultHandler<T> success, ErrorHandler error, Action cancel) {
-Interlocked.Increment(ref m_childrenCount);
+if (success != null || error != null)
+Interlocked.Increment(ref m_childrenCount);
 HandlerDescriptor handler = new HandlerDescriptor {
 resultHandler = success,
 errorHandler = error,
 cancellHandler = cancel
 get {
 return m_childrenCount <= 1;
 }
 }
-protected bool Cancel(bool dependencies) {
-if (BeginTransit()) {
-CompleteTransit(CancelledState);
-OnStateChanged();
-if (dependencies && m_parent != null && m_parent.IsExclusive)
-m_parent.Cancel();
-return true;
-} else {
-return false;
-}
-}
 /// <summary>
 /// Объединяет несколько обещаний в одно, результатом которого является массив результатов других обещаний.
 /// Если хотябы одно из переданных обещаний не будет выполнено, то новое обещение тоже не будет выполнено.
 /// При отмене нового обещания, переданные обещания также будут отменены, если никто больше на них не подписан.
 /// </summary>
 int pending = promises.Count;
 for (int i = 0; i < promises.Count; i++) {
 var dest = i;
-promises[i].Then(
+if (promises[i] != null) {
-x => {
+promises[i].Then(
-result[dest] = x;
+x => {
-if(Interlocked.Decrement(ref pending) == 0)
+result[dest] = x;
-promise.Resolve(result);
+if (Interlocked.Decrement(ref pending) == 0)
-},
+promise.Resolve(result);
-e => promise.Reject(e)
+},
-);
+e => promise.Reject(e)
+);
+} else {
+if (Interlocked.Decrement(ref pending) == 0)
+promise.Resolve(result);
+}
 }
 promise.Cancelled(
 () => {
-foreach(var d in promises)
+foreach (var d in promises)
-if(d.IsExclusive)
+if (d != null && d.IsExclusive)
 d.Cancel();
 }
 );
 return promise;
+}
+/// <summary>
+/// Объединяет несколько обещаний в одно. Результирующее обещание будет выполнено при
+/// выполнении всех указанных обещаний. При этом возвращаемые значения первичных обещаний
+/// игнорируются.
+/// </summary>
+/// <param name="promises">Коллекция первичных обещаний, которые будут объеденены в одно.</param>
+/// <returns>Новое обещание, объединяющее в себе переданные.</returns>
+/// <remarks>
+/// Если в коллекции встречаюься <c>null</c>, то они воспринимаются как выполненные обещания.
+/// </remarks>
+public static IPromiseBase CreateComposite(ICollection<IPromiseBase> promises) {
+if (promises == null)
+throw new ArgumentNullException();
+if (promises.Count == 0)
+return Promise<object>.ResultToPromise(null);
+int countdown = promises.Count;
+var result = new Promise<object>();
+foreach (var d in promises) {
+if (d == null) {
+if (Interlocked.Decrement(ref countdown) == 0)
+result.Resolve(null);
+} else {
+d.Then(() => {
+if (Interlocked.Decrement(ref countdown) == 0)
+result.Resolve(null);
+});
+}
+}
+result.Cancelled(() => {
+foreach (var d in promises)
+if (d != null && d.IsExclusive)
+d.Cancel();
+});
+return result;
 }
 public static Promise<T> ResultToPromise(T result) {
 var p = new Promise<T>();
 p.Resolve(result);
 var p = new Promise<T>();
 p.Reject(error);
 return p;
 }
+#region IPromiseBase explicit implementation
+IPromiseBase IPromiseBase.Error(ErrorHandler error) {
+return Error(error);
+}
+IPromiseBase IPromiseBase.Anyway(Action handler) {
+return Anyway(handler);
+}
+IPromiseBase IPromiseBase.Finally(Action handler) {
+return Finally(handler);
+}
+IPromiseBase IPromiseBase.Cancelled(Action handler) {
+return Cancelled(handler);
+}
+void IPromiseBase.Join() {
+Join();
+}
+void IPromiseBase.Join(int timeout) {
+Join(timeout);
+}
+#endregion
 }
 }

Mercurial > pub > ImplabNet

comparison Implab/Promise.cs @ 33:b255e4aeef17