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 (() => {
+            			var p = AsyncPool.Invoke (() => Thread.CurrentThread.ManagedThreadId);
-            				return 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>

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 void ResultHandler<in T>(T result);
-                public delegate TNew ResultMapper<TSrc, TNew>(TSrc result);
+                public delegate TNew ResultMapper<in TSrc, out TNew>(TSrc result);
-                public delegate Promise<TNew> ChainedOperation<TSrc, 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();
+                    readonly object m_lock = new Object();
-                    bool m_cancellable;
+                    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>
+                    void InternalCancel() {
-                    /// Событие, возникающее при отмене асинхронной операции.
+                        // don't try to cancel parent :)
-                    /// </summary>
+                        Cancel(false);
-                    /// <description>
-                    /// Как правило используется для оповещения объекта, выполняющего асинхронную операцию, о том, что ее следует отменить.
-                    /// </description>
-                    public event EventHandler Cancelled;
                     /// <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
+                        OnStateChanged();
-                        foreach (var handler in m_resultHandlers)
-                            InvokeHandler(handler);
-                        /* ResultHandlerInfo handler;
-                        while (FetchNextHandler(out handler))
-                            InvokeHandler(handler); */
                     }
                     /// <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
+                        OnStateChanged();
-                        foreach (var handler in m_resultHandlers)
-                            InvokeHandler(handler);
-                        /*ResultHandlerInfo handler;
-                        while (FetchNextHandler(out handler))
-                            InvokeHandler(handler);*/
                     }
                     /// <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) {
+                            resultHandler = result => chained.Resolve(mapper(result)),
-                                try {
-                                    // если преобразование выдаст исключение, то сработает reject сцепленного deferred
-                                    chained.Resolve(mapper(result));
-                                } catch (Exception e) {
-                                    chained.Reject(e);
-                            },
                             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 {
+                                if (medium.State == PromiseState.Cancelled)
-                                    chained(result).Then(
+                                    return;
-                                        x => medium.Resolve(x),
-                                        e => medium.Reject(e)
+                                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
+                            default:
-                            return m_result;
+                                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) {
+                        lock (m_lock) {
-                            if (m_state == PromiseState.Unresolved)
+                            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 { }
                                 }
+                                break;
-                        if (m_error != null) {
+                            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) {
+                        if (result)
-                            // TODO syncronize IsExclusive, AddHandler, Cancel (maybe CancelExclusive)
+                            OnStateChanged();
-                            m_parent.Cancel(true);
-                        if (result) {
+                        if (dependencies && m_parent != null && m_parent.IsExclusive) {
-                            // state has been changed to cancelled, new handlers can't be added
+                            m_parent.Cancel(true);
-                            foreach (var handler in m_cancelHandlers)
-                                handler();
                         }
                         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