implab/ImplabNet Commit - r33:b255e4aeef17

removed the reference to the parent from the promise object this allows...

cin -

r33:b255e4aeef17 default

parent child

Context file:

r33:b255e4aeef17

Collapse all files

Implab.Test/AsyncTests.cs +53 0

		@@ -328,6 +328,59 namespace Implab.Test {
328	328	Assert.IsTrue(flags[1]);
329	329	Assert.IsTrue(flags[2]);
330	330	}
	331
	332	[TestMethod]
	333	public void ChainedCancel1Test() {
	334	// при отмене сцепленной асинхронной операции все обещание должно
	335	// завершаться ошибкой OperationCanceledException
	336	var p = PromiseHelper
	337	.Sleep(1, "Hi, HAL!")
	338	.Chain(x => {
	339	// запускаем две асинхронные операции
	340	var result = PromiseHelper.Sleep(1000, "HEM ENABLED!!!");
	341	// вторая операция отменяет первую до завершения
	342	PromiseHelper
	343	.Sleep(100, "HAL, STOP!")
	344	.Then(() => result.Cancel());
	345	return result;
	346	});
	347	try {
	348	p.Join();
	349	} catch (TargetInvocationException err) {
	350	Assert.IsTrue(err.InnerException is OperationCanceledException);
	351	}
	352	}
	353
	354	[TestMethod]
	355	public void ChainedCancel2Test() {
	356	// при отмене цепочки обещаний, вложенные операции также должны отменяться
	357	IPromiseBase p = null;
	358	var pSurvive = new Promise<bool>();
	359	var hemStarted = new ManualResetEvent(false);
	360	p = PromiseHelper
	361	.Sleep(1, "Hi, HAL!")
	362	.Chain(x => {
	363	hemStarted.Set();
	364	// запускаем две асинхронные операции
	365	var result = PromiseHelper
	366	.Sleep(1000, "HEM ENABLED!!!")
	367	.Then(s => pSurvive.Resolve(false));
	368
	369	result
	370	.Cancelled(() => pSurvive.Resolve(true));
	371
	372	return result;
	373	});
	374
	375	hemStarted.WaitOne();
	376	p.Cancel();
	377
	378	try {
	379	p.Join();
	380	} catch (OperationCanceledException) {
	381	Assert.IsTrue(pSurvive.Join());
	382	}
	383	}
331	384	}
332	385	}
333	386

Implab.suo binary modified 0 0

NO CONTENT: modified file, binary diff hidden

Implab/IPromise.cs +6 -7

                  public interface IPromise<T>: IPromiseBase
                  {
-                     T Join();
-                     T Join(int timeout);
+                     new T Join();
+                     new T Join(int timeout);
                      IPromise<T> Then(ResultHandler<T> success, ErrorHandler error);
                      IPromise<T> Then(ResultHandler<T> success, ErrorHandler<T> error);
                      IPromise<T> Then(ResultHandler<T> success);
-                     IPromise<T> Error(ErrorHandler error);
+                     new IPromise<T> Error(ErrorHandler error);
                      IPromise<T> Error(ErrorHandler<T> error);
                      IPromise<T2> Map<T2>(ResultMapper<T,T2> mapper, ErrorHandler error);
                      IPromise<T2> Chain<T2>(ChainedOperation<T, T2> chained, ErrorHandler error);
                      IPromise<T2> Chain<T2>(ChainedOperation<T, T2> chained);
-                     IPromise<T> Cancelled(Action handler);
-                     IPromise<T> Finally(Action handler);
-                     IPromise<T> Anyway(Action handler);
+                     new IPromise<T> Cancelled(Action handler);
+                     new IPromise<T> Finally(Action handler);
+                     new IPromise<T> Anyway(Action handler);
                  }
              }

Implab/IPromiseBase.cs +7 0

                      IPromiseBase Then(Action success,ErrorHandler error);
                      IPromiseBase Then(Action success);
+                     IPromiseBase Error(ErrorHandler error);
+                     IPromiseBase Anyway(Action handler);
+                     IPromiseBase Finally(Action handler);
+                     IPromiseBase Cancelled(Action handler);
                      IPromise<T> Cast<T>();
+                     void Join();
+                     void Join(int timeout);
                  }
              }

Implab/Promise.cs +136 -43

                  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>
                  /// Класс для асинхронного получения результатов. Так называемое "обещание".
                      const int RejectedState = 3;
                      const int CancelledState = 4;
-                     readonly IPromiseBase m_parent;
                      readonly bool m_cancellable;
                      int m_childrenCount = 0;
                      public Promise(IPromiseBase parent, bool cancellable) {
                          m_cancellable = cancellable;
-                         m_parent = parent;
+                     }
-                     void InternalCancel() {
-                         // don't try to cancel parent :)
-                         Cancel(false);
+                         if (parent != null)
+                             AddHandler(
+                                 null,
+                                 null,
+                                 () => {
+                                     if (parent.IsExclusive)
+                                         parent.Cancel();
+                                 }
+                             );
                      }
                      bool BeginTransit() {
                      }
                      /// <summary>
+                     /// Выполняет обещание, сообщая об успешном выполнении. Результатом выполнения будет пустое значения.
+                     /// </summary>
+                     /// <remarks>
+                     /// Данный вариант удобен в случаях, когда интересен факт выполнения операции, нежели полученное значение.
+                     /// </remarks>
+                     public void Resolve() {
+                         Resolve(default(T));
+                     }
+                     /// <summary>
                      /// Выполняет обещание, сообщая об ошибке
                      /// </summary>
                      /// <remarks>
                      /// </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>
                          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());
                      }
                              errorHandler = x => {
                                  try {
                                      medium.Resolve(error(x));
-                                 } catch(Exception e) {
+                                 } catch (Exception e) {
                                      medium.Reject(e);
                                  }
                              };
                          if (handler == null)
                              return this;
-                         var medium = new Promise<T>();
+                         var medium = new Promise<T>(this,true);
                          AddHandler(
                              x => {
                              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) {
                              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) {
                      }
                      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,
                          }
                      }
-                     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>
                      /// Объединяет несколько обещаний в одно, результатом которого является массив результатов других обещаний.
                      /// Если хотябы одно из переданных обещаний не будет выполнено, то новое обещение тоже не будет выполнено.
                          for (int i = 0; i < promises.Count; i++) {
                              var dest = i;
-                             promises[i].Then(
-                                 x => {
-                                     result[dest] = x;
-                                     if(Interlocked.Decrement(ref pending) == 0)
-                                         promise.Resolve(result);
-                                 },
-                                 e => promise.Reject(e)
-                             );
+                             if (promises[i] != null) {
+                                 promises[i].Then(
+                                     x => {
+                                         result[dest] = x;
+                                         if (Interlocked.Decrement(ref pending) == 0)
+                                             promise.Resolve(result);
+                                     },
+                                     e => promise.Reject(e)
+                                 );
+                             } else {
+                                 if (Interlocked.Decrement(ref pending) == 0)
+                                     promise.Resolve(result);
+                             }
                          }
                          promise.Cancelled(
                              () => {
-                                 foreach(var d in promises)
-                                     if(d.IsExclusive)
+                                 foreach (var d in promises)
+                                     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);
                          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
                  }
              }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	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