implab/ImplabNet Commit - r10:aa33d0bb8c0c

implemeted new cancellable promises concept

cin -

r10:aa33d0bb8c0c promises

parent child

Context file:

r10:aa33d0bb8c0c

Collapse all files

Implab.Test/PromiseHelper.cs created 644 +16 0

			@@ -0,0 +1,16
		1	using System;
		2	using System.Collections.Generic;
		3	using System.Linq;
		4	using System.Text;
		5	using System.Threading;
		6
		7	namespace Implab.Test {
		8	class PromiseHelper {
		9	public static Promise<T> Sleep<T>(int timeout, T retVal) {
		10	return AsyncPool.Invoke(() => {
		11	Thread.Sleep(timeout);
		12	return retVal;
		13	});
		14	}
		15	}
		16	}

.hgignore +1 0

              syntax: glob
              Implab.Test/bin/
              *.user
              Implab.Test/obj/
              *.userprefs
              Implab/bin/
              Implab/obj/
              TestResults/
              Implab.Fx/obj/
              Implab.Fx/bin/
              Implab.Fx.Test/bin/
              Implab.Fx.Test/obj/
+             _ReSharper.Implab/

Implab.Test/AsyncTests.cs +31 -5

              using System;
              using Microsoft.VisualStudio.TestTools.UnitTesting;
-             using Implab;
              using System.Reflection;
              using System.Threading;
-             namespace Implab.Tests
+             namespace Implab.Test
              {
              	[TestClass]
              	public class AsyncTests
              	{
              		[TestMethod]
              		public void ResolveTest ()
              		{
              			int res = -1;
              			var p = new Promise<int> ();
              			p.Then (x => res = x);
              			p.Resolve (100);
              			Assert.AreEqual (res, 100);
              		}
                      [TestMethod]
              		public void RejectTest ()
              		{
              			int res = -1;
              			Exception err = null;
              			var p = new Promise<int> ();
              			p.Then (x => res = x, e => err = e);
              			p.Reject (new ApplicationException ("error"));
              			Assert.AreEqual (res, -1);
              			Assert.AreEqual (err.Message, "error");
              		}
                      [TestMethod]
              		public void JoinSuccessTest ()
              		{
              			var p = new Promise<int> ();
              			p.Resolve (100);
              			Assert.AreEqual (p.Join (), 100);
              		}
                      [TestMethod]
              		public void JoinFailTest ()
              		{
              			var p = new Promise<int> ();
              			p.Reject (new ApplicationException ("failed"));
              			try {
              				p.Join ();
              				throw new ApplicationException ("WRONG!");
              			} catch (TargetInvocationException err) {
              				Assert.AreEqual (err.InnerException.Message, "failed");
              			} catch {
              				Assert.Fail ("Got wrong excaption");
              			}
              		}
                      [TestMethod]
              		public void MapTest ()
              		{
              			var p = new Promise<int> ();
              			var p2 = p.Map (x => x.ToString ());
              			p.Resolve (100);
              			Assert.AreEqual (p2.Join (), "100");
              		}
                      [TestMethod]
              		public void ChainTest ()
              		{
              			var p1 = new Promise<int> ();
              			var p3 = p1.Chain (x => {
              				var p2 = new Promise<string> ();
              				p2.Resolve (x.ToString ());
              				return p2;
              			});
              			p1.Resolve (100);
              			Assert.AreEqual (p3.Join (), "100");
              		}
                      [TestMethod]
              		public void PoolTest ()
              		{
              			var pid = Thread.CurrentThread.ManagedThreadId;
-             			var p = AsyncPool.Invoke (() => {
-             				return Thread.CurrentThread.ManagedThreadId;
-             			});
+             			var p = AsyncPool.Invoke (() => Thread.CurrentThread.ManagedThreadId);
              			Assert.AreNotEqual (pid, p.Join ());
              		}
+                     [TestMethod]
+                     public void ComplexCase1Test() {
+                         var flags = new bool[3];
+                         // op1 (aync 200ms) => op2 (async 200ms) => op3 (sync map)
+                         var p = PromiseHelper
+                             .Sleep(200, "Alan")
+                             .Cancelled(() => flags[0] = true)
+                             .Chain(x =>
+                                 PromiseHelper
+                                     .Sleep(200, "Hi, " + x)
+                                     .Map( y => y )
+                                     .Cancelled(() => flags[1] = true)
+                             )
+                             .Cancelled(() => flags[2] = true);
+                         Thread.Sleep(300);
+                         p.Cancel();
+                         try {
+                             Assert.AreEqual(p.Join(), "Hi, Alan");
+                             Assert.Fail("Shouldn't get here");
+                         } catch(OperationCanceledException) {
+                         }
+                         Assert.IsFalse(flags[0]);
+                         Assert.IsTrue(flags[1]);
+                         Assert.IsTrue(flags[2]);
+                     }
              	}
              }

Implab.Test/Implab.Test.csproj +1 0

              <?xml version="1.0" encoding="utf-8"?>
              <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
                <PropertyGroup>
                  <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
                  <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
                  <ProductVersion>
                  </ProductVersion>
                  <SchemaVersion>2.0</SchemaVersion>
                  <ProjectGuid>{63F92C0C-61BF-48C0-A377-8D67C3C661D0}</ProjectGuid>
                  <OutputType>Library</OutputType>
                  <AppDesignerFolder>Properties</AppDesignerFolder>
                  <RootNamespace>Implab.Test</RootNamespace>
                  <AssemblyName>Implab.Test</AssemblyName>
                  <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
                  <FileAlignment>512</FileAlignment>
                  <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
                </PropertyGroup>
                <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
                  <DebugSymbols>true</DebugSymbols>
                  <DebugType>full</DebugType>
                  <Optimize>false</Optimize>
                  <OutputPath>bin\Debug\</OutputPath>
                  <DefineConstants>DEBUG;TRACE</DefineConstants>
                  <ErrorReport>prompt</ErrorReport>
                  <WarningLevel>4</WarningLevel>
                </PropertyGroup>
                <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
                  <DebugType>pdbonly</DebugType>
                  <Optimize>true</Optimize>
                  <OutputPath>bin\Release\</OutputPath>
                  <DefineConstants>TRACE</DefineConstants>
                  <ErrorReport>prompt</ErrorReport>
                  <WarningLevel>4</WarningLevel>
                </PropertyGroup>
                <ItemGroup>
                  <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
                  <Reference Include="System" />
                  <Reference Include="System.Core">
                    <RequiredTargetFramework>3.5</RequiredTargetFramework>
                  </Reference>
                </ItemGroup>
                <ItemGroup>
                  <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
                    <Visible>False</Visible>
                  </CodeAnalysisDependentAssemblyPaths>
                </ItemGroup>
                <ItemGroup>
                  <Compile Include="AsyncTests.cs" />
+                 <Compile Include="PromiseHelper.cs" />
                  <Compile Include="Properties\AssemblyInfo.cs" />
                </ItemGroup>
                <ItemGroup>
                  <ProjectReference Include="..\Implab\Implab.csproj">
                    <Project>{99B95D0D-9CF9-4F70-8ADF-F4D0AA5CB0D9}</Project>
                    <Name>Implab</Name>
                  </ProjectReference>
                </ItemGroup>
                <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
                <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
                     Other similar extension points exist, see Microsoft.Common.targets.
                <Target Name="BeforeBuild">
                </Target>
                <Target Name="AfterBuild">
                </Target>
                -->
              </Project>
  No newline at end of file

Implab.suo binary modified 0 0

NO CONTENT: modified file, binary diff hidden

Implab/IPromise.cs +7 0

              using System;
              using System.Collections.Generic;
              using System.Linq;
              using System.Text;
              namespace Implab
              {
                  public interface IPromise
                  {
                      /// <summary>
                      /// Check whereather the promise has no more than one dependent promise.
                      /// </summary>
                      bool IsExclusive
                      {
                          get;
                      }
                      /// <summary>
                      /// The current state of the promise.
                      /// </summary>
                      PromiseState State
                      {
                          get;
                      }
                      /// <summary>
                      /// Tries to cancel the promise or the complete chain.
                      /// </summary>
                      /// <param name="dependencies">Try to cancel the whole promise chain, the parent promise will be cancelled only if it has only one promise</param>
                      /// <returns></returns>
                      bool Cancel(bool dependencies);
+                     /// <summary>
+                     /// Registers handler for the case when the promise is cencelled. If the promise already cancelled the
+                     /// handler will be invoked immediatelly.
+                     /// </summary>
+                     /// <param name="handler">The handler</param>
+                     void HandleCancelled(Action handler);
                  }
              }

Implab/Promise.cs +114 -98

              using System;
              using System.Collections.Generic;
-             using System.Linq;
              using System.Reflection;
-             using System.Text;
              using System.Diagnostics;
              using System.Threading;
              namespace Implab {
                  public delegate void ErrorHandler(Exception e);
-                 public delegate void ResultHandler<T>(T result);
-                 public delegate TNew ResultMapper<TSrc, TNew>(TSrc result);
-                 public delegate Promise<TNew> ChainedOperation<TSrc, TNew>(TSrc result);
+                 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>
                  /// Класс для асинхронного получения результатов. Так называемое "обещание".
                  /// </summary>
                  /// <typeparam name="T">Тип получаемого результата</typeparam>
                  /// <remarks>
                  /// <para>Сервис при обращении к его методу дает обещаиние о выполнении операции,
                  /// клиент получив такое обещание может установить ряд обратных вызово для получения
                  /// событий выполнения обещания, тоесть завершения операции и предоставлении результатов.</para>
                  /// <para>
                  /// Обещение может быть как выполнено, так и выполнено с ошибкой. Для подписки на
                  /// данные события клиент должен использовать методы <c>Then</c>.
                  /// </para>
                  /// <para>
                  /// Сервис, в свою очередь, по окончанию выполнения операции (возможно с ошибкой),
                  /// использует методы <c>Resolve</c> либо <c>Reject</c> для оповещения клиетна о
                  /// выполнении обещания.
                  /// </para>
                  /// <para>
                  /// Если сервер успел выполнить обещание еще до того, как клиент на него подписался,
                  /// то в момент подписки клиента будут вызваны соответсвующие события в синхронном
                  /// режиме и клиент будет оповещен в любом случае. Иначе, обработчики добавляются в
                  /// список в порядке подписания и в этом же порядке они будут вызваны при выполнении
                  /// обещания.
                  /// </para>
                  /// <para>
                  /// Обрабатывая результаты обещания можно преобразовывать результаты либо инициировать
                  /// связанные асинхронные операции, которые также возвращают обещания. Для этого следует
                  /// использовать соответствующую форму методе <c>Then</c>.
                  /// </para>
                  /// <para>
                  /// Также хорошим правилом является то, что <c>Resolve</c> и <c>Reject</c> должен вызывать
                  /// только инициатор обещания иначе могут возникнуть противоречия.
                  /// </para>
                  /// </remarks>
                  public class Promise<T> : IPromise {
                      struct ResultHandlerInfo {
                          public ResultHandler<T> resultHandler;
                          public ErrorHandler errorHandler;
                      }
-                     IPromise m_parent;
+                     readonly IPromise m_parent;
                      LinkedList<ResultHandlerInfo> m_resultHandlers = new LinkedList<ResultHandlerInfo>();
                      LinkedList<Action> m_cancelHandlers = new LinkedList<Action>();
-                     object m_lock = new Object();
-                     bool m_cancellable;
+                     readonly object m_lock = new Object();
+                     readonly bool m_cancellable;
+                     int m_childrenCount = 0;
                      PromiseState m_state;
                      T m_result;
                      Exception m_error;
-                     int m_childrenCount;
                      public Promise() {
                          m_cancellable = true;
                      }
                      public Promise(IPromise parent, bool cancellable) {
                          m_cancellable = cancellable;
                          m_parent = parent;
+                         if (parent != null)
+                             parent.HandleCancelled(InternalCancel);
                      }
-                     /// <summary>
-                     /// Событие, возникающее при отмене асинхронной операции.
-                     /// </summary>
-                     /// <description>
-                     /// Как правило используется для оповещения объекта, выполняющего асинхронную операцию, о том, что ее следует отменить.
-                     /// </description>
-                     public event EventHandler Cancelled;
+                     void InternalCancel() {
+                         // don't try to cancel parent :)
+                         Cancel(false);
+                     }
                      /// <summary>
                      /// Выполняет обещание, сообщая об успешном выполнении.
                      /// </summary>
                      /// <param name="result">Результат выполнения.</param>
                      /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
                      public void Resolve(T result) {
                          lock (this) {
                              if (m_state == PromiseState.Cancelled)
                                  return;
                              if (m_state != PromiseState.Unresolved)
                                  throw new InvalidOperationException("The promise is already resolved");
                              m_result = result;
                              m_state = PromiseState.Resolved;
                          }
-                         // state has been changed to rejected new handlers can't be added
-                         foreach (var handler in m_resultHandlers)
-                             InvokeHandler(handler);
-                         /* ResultHandlerInfo handler;
-                         while (FetchNextHandler(out handler))
-                             InvokeHandler(handler); */
+                         OnStateChanged();
                      }
                      /// <summary>
                      /// Выполняет обещание, сообщая об ошибке
                      /// </summary>
                      /// <param name="error">Исключение возникшее при выполнении операции</param>
                      /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
                      public void Reject(Exception error) {
                          lock (this) {
                              if (m_state == PromiseState.Cancelled)
                                  return;
                              if (m_state != PromiseState.Unresolved)
                                  throw new InvalidOperationException("The promise is already resolved");
                              m_error = error;
                              m_state = PromiseState.Rejected;
                          }
-                         // state has been changed to rejected new handlers can't be added
-                         foreach (var handler in m_resultHandlers)
-                             InvokeHandler(handler);
-                         /*ResultHandlerInfo handler;
-                         while (FetchNextHandler(out handler))
-                             InvokeHandler(handler);*/
+                         OnStateChanged();
                      }
                      /// <summary>
                      /// Отменяет операцию, если это возможно.
                      /// </summary>
                      /// <returns><c>true</c> Операция была отменена, обработчики не будут вызваны.<c>false</c> отмена не возможна, поскольку обещание уже выполнено и обработчики отработали.</returns>
                      public bool Cancel() {
                          return Cancel(true);
                      }
+                     protected virtual void OnStateChanged() {
+                         switch (m_state) {
+                             case PromiseState.Resolved:
+                                 foreach (var resultHandlerInfo in m_resultHandlers)
+                                     try {
+                                         if (resultHandlerInfo.resultHandler != null)
+                                             resultHandlerInfo.resultHandler(m_result);
+                                     } catch (Exception e) {
+                                         try {
+                                             if (resultHandlerInfo.errorHandler != null)
+                                                 resultHandlerInfo.errorHandler(e);
+                                         } catch { }
+                                     }
+                                 break;
+                             case PromiseState.Cancelled:
+                                 foreach (var cancelHandler in m_cancelHandlers)
+                                     cancelHandler();
+                                 break;
+                             case PromiseState.Rejected:
+                                 foreach (var resultHandlerInfo in m_resultHandlers)
+                                     try {
+                                         if (resultHandlerInfo.errorHandler != null)
+                                             resultHandlerInfo.errorHandler(m_error);
+                                     } catch { }
+                                 break;
+                             default:
+                                 throw new InvalidOperationException(String.Format("Promise entered an invalid state {0}", m_state));
+                         }
+                         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 => {
-                                 try {
-                                     success(x);
-                                     medium.Resolve(x);
-                                 } catch (Exception e) {
-                                     medium.Reject(e);
+                                 }
                              };
                          else
-                             handlerInfo.resultHandler = x => medium.Resolve(x);
+                             handlerInfo.resultHandler = medium.Resolve;
                          if (error != null)
                              handlerInfo.errorHandler = x => {
                                  try {
                                      error(x);
                                  } catch { }
                                  medium.Reject(x);
                              };
                          else
-                             handlerInfo.errorHandler = x => medium.Reject(x);
+                             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");
                          // создаем прицепленное обещание
-                         Promise<TNew> chained = new Promise<TNew>();
+                         var chained = new Promise<TNew>();
                          AddHandler(new ResultHandlerInfo() {
-                             resultHandler = delegate(T result) {
-                                 try {
-                                     // если преобразование выдаст исключение, то сработает reject сцепленного deferred
-                                     chained.Resolve(mapper(result));
-                                 } catch (Exception e) {
-                                     chained.Reject(e);
+                                 }
-                             },
+                             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) {
                          // проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно
                          // создать посредника, к которому будут подвызяваться следующие обработчики.
                          // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы
                          // передать через него результаты работы.
-                         Promise<TNew> medium = new Promise<TNew>();
+                         var medium = new Promise<TNew>(this, true);
-                         AddHandler(new ResultHandlerInfo() {
+                         AddHandler(new ResultHandlerInfo {
                              resultHandler = delegate(T result) {
-                                 try {
-                                     chained(result).Then(
-                                         x => medium.Resolve(x),
-                                         e => medium.Reject(e)
+                                 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
-                                         );
-                                 } catch (Exception 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) {
-                         ManualResetEvent evt = new ManualResetEvent(false);
+                         var evt = new ManualResetEvent(false);
                          Anyway(() => evt.Set());
+                         Cancelled(() => evt.Set());
                          if (!evt.WaitOne(timeout, true))
                              throw new TimeoutException();
-                         if (m_error != null)
+                         switch (State) {
+                             case PromiseState.Resolved:
+                                 return m_result;
+                             case PromiseState.Cancelled:
+                                 throw new OperationCanceledException();
+                             case PromiseState.Rejected:
                              throw new TargetInvocationException(m_error);
-                         else
-                             return m_result;
+                             default:
+                                 throw new ApplicationException(String.Format("Invalid promise state {0}", State));
+                         }
                      }
                      public T Join() {
                          return Join(Timeout.Infinite);
                      }
-                     /// <summary>
-                     /// Данный метод последовательно извлекает обработчики обещания и когда
-                     /// их больше не осталось - ставит состояние "разрешено".
-                     /// </summary>
-                     /// <param name="handler">Информация об обработчике</param>
-                     /// <returns>Признак того, что еще остались обработчики в очереди</returns>
-                     bool FetchNextHandler(out ResultHandlerInfo handler) {
-                         handler = default(ResultHandlerInfo);
-                         lock (this) {
-                             Debug.Assert(m_state != PromiseState.Unresolved);
-                             if (m_resultHandlers.Count > 0) {
-                                 handler = m_resultHandlers.First.Value;
-                                 m_resultHandlers.RemoveFirst();
-                                 return true;
-                             } else {
-                                 return false;
+                             }
+                         }
+                     }
                      void AddHandler(ResultHandlerInfo handler) {
                          bool invokeRequired = false;
-                         lock (this) {
-                             if (m_state == PromiseState.Unresolved)
+                         lock (m_lock) {
+                             m_childrenCount++;
+                             if (m_state == PromiseState.Unresolved) {
                                  m_resultHandlers.AddLast(handler);
-                             else
+                             } else
                                  invokeRequired = true;
                          }
                          // обработчики не должны блокировать сам объект
                          if (invokeRequired)
                              InvokeHandler(handler);
                      }
                      void InvokeHandler(ResultHandlerInfo handler) {
-                         if (m_error == null) {
+                         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 { }
                          }
-                         if (m_error != null) {
+                                 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_childrenCount <= 1;
                              }
                          }
                      }
                      public PromiseState State {
                          get {
                              lock (m_lock) {
                                  return m_state;
                              }
                          }
                      }
                      public bool Cancel(bool dependencies) {
                          bool result;
                          lock (m_lock) {
                              if (m_state == PromiseState.Unresolved) {
                                  m_state = PromiseState.Cancelled;
                                  result = true;
                              } else {
                                  result = false;
                              }
                          }
-                         if (dependencies && m_parent != null && m_parent.IsExclusive) {
-                             // TODO syncronize IsExclusive, AddHandler, Cancel (maybe CancelExclusive)
-                             m_parent.Cancel(true);
+                         }
+                         if (result)
+                             OnStateChanged();
-                         if (result) {
-                             // state has been changed to cancelled, new handlers can't be added
-                             foreach (var handler in m_cancelHandlers)
-                                 handler();
+                         if (dependencies && m_parent != null && m_parent.IsExclusive) {
+                             m_parent.Cancel(true);
                          }
                          return result;
                      }
                  }
              }

Implab/TaskController.cs +1 -2

              using System;
              using System.Collections.Generic;
              using System.Linq;
              using System.Text;
              using System.Threading;
              namespace Implab
              {
                  /// <summary>
                  /// This class allows to interact with asyncronuos task.
                  /// </summary>
                  /// <remarks>
                  /// Members of this object are thread safe.
                  /// </remarks>
                  class TaskController
                  {
-                     object m_lock;
+                     readonly object m_lock;
                      string m_message;
-                     bool m_cancelled;
                      float m_current;
                      float m_max;
                      public event EventHandler<ValueEventArgs<string>> MessageUpdated;
                      public event EventHandler<ValueEventArgs<float>> ProgressUpdated;
                      public event EventHandler<ProgressInitEventArgs> ProgressInit;
                      public TaskController()
                      {
                          m_lock = new Object();
                      }
                      public string Message
                      {
                          get
                          {
                              lock (m_lock)
                                  return m_message;
                          }
                          set
                          {
                              lock (m_lock)
                              {
                                  m_message = value;
                                  OnMessageUpdated();
                              }
                          }
                      }
                      public float CurrentProgress
                      {
                          get
                          {
                              lock (m_lock)
                                  return m_current;
                          }
                          set
                          {
                              lock (m_lock)
                              {
                                  var prev = m_current;
                                  m_current = value;
                                  if (m_current >= m_max)
                                      m_current = m_max;
                                  if (m_current != prev)
                                      OnProgressUpdated();
                              }
                          }
                      }
                      public void InitProgress(float current, float max, string message)
                      {
                          if (max < 0)
                              throw new ArgumentOutOfRangeException("max");
                          if (current < 0 || current > max)
                              throw new ArgumentOutOfRangeException("current");
                          lock(m_lock) {
                              m_current = current;
                              m_max = max;
                              m_message = message;
                              OnProgressInit();
                          }
                      }
                      protected virtual void OnMessageUpdated()
                      {
                          var temp = MessageUpdated;
                          if (temp != null)
                          {
                              temp(this, new ValueEventArgs<string>(m_message));
                          }
                      }
                      protected virtual void OnProgressUpdated()
                      {
                          var temp = ProgressUpdated;
                          if (temp != null)
                          {
                              temp(this,new ValueEventArgs<float>(m_current));
                          }
                      }
                      protected virtual void OnProgressInit()
                      {
                          var temp = ProgressInit;
                          if (temp != null)
                          {
                              temp(this, new ProgressInitEventArgs(m_current,m_max, m_message));
                          }
                      }
                  }
              }

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