Promise.cs
954 lines
| 39.7 KiB
| text/x-csharp
|
CSharpLexer
/ Implab / Promise.cs
cin
|
r2 | using System; | ||
| using System.Collections.Generic; | ||||
| using System.Reflection; | ||||
| using System.Threading; | ||||
|
cin
|
r19 | using Implab.Parallels; | ||
|
cin
|
r2 | |||
| namespace Implab { | ||||
|
cin
|
r6 | /// <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> | ||||
|
cin
|
r25 | public class Promise<T> : IPromise<T> { | ||
|
cin
|
r2 | |||
|
cin
|
r106 | protected abstract class AbstractHandler : MTCustomQueueNode<AbstractHandler> { | ||
| public abstract void Resolve(T result); | ||||
| public abstract void Reject(Exception error); | ||||
| public abstract void Cancel(); | ||||
| } | ||||
|
cin
|
r107 | protected class RemapDescriptor<T2> : AbstractHandler { | ||
|
cin
|
r106 | |||
| readonly Func<T,T2> m_resultHandler; | ||||
| readonly Func<Exception,T2> m_errorHandler; | ||||
| readonly Action m_cancellHandler; | ||||
| readonly Promise<T2> m_medium; | ||||
|
cin
|
r19 | |||
|
cin
|
r107 | public RemapDescriptor(Func<T,T2> resultHandler, Func<Exception,T2> errorHandler, Action cancelHandler, Promise<T2> medium) { | ||
|
cin
|
r106 | m_resultHandler = resultHandler; | ||
| m_errorHandler = errorHandler; | ||||
| m_cancellHandler = cancelHandler; | ||||
| m_medium = medium; | ||||
| } | ||||
| public override void Resolve(T result) { | ||||
| if (m_resultHandler != null) { | ||||
|
cin
|
r19 | try { | ||
|
cin
|
r106 | if (m_medium != null) | ||
| m_medium.Resolve(m_resultHandler(result)); | ||||
| else | ||||
| m_resultHandler(result); | ||||
|
cin
|
r19 | } catch (Exception e) { | ||
| Reject(e); | ||||
| } | ||||
|
cin
|
r106 | } else if(m_medium != null) | ||
| m_medium.Resolve(default(T2)); | ||||
|
cin
|
r19 | } | ||
|
cin
|
r106 | public override void Reject(Exception error) { | ||
| if (m_errorHandler != null) { | ||||
|
cin
|
r19 | try { | ||
|
cin
|
r106 | var res = m_errorHandler(error); | ||
| if (m_medium != null) | ||||
| m_medium.Resolve(res); | ||||
|
cin
|
r107 | } catch (Exception err2) { | ||
| if (m_medium != null) | ||||
| m_medium.Reject(err2); | ||||
| } | ||||
| } else if (m_medium != null) | ||||
| m_medium.Reject(error); | ||||
| } | ||||
| public override void Cancel() { | ||||
| if (m_cancellHandler != null) { | ||||
| try { | ||||
| m_cancellHandler(); | ||||
| } catch (Exception err) { | ||||
| Reject(err); | ||||
| return; | ||||
| } | ||||
| } | ||||
| if (m_medium != null) | ||||
| m_medium.Cancel(); | ||||
| } | ||||
| } | ||||
| protected class HandlerDescriptor : AbstractHandler { | ||||
| readonly Action<T> m_resultHandler; | ||||
| readonly Action<Exception> m_errorHandler; | ||||
| readonly Action m_cancellHandler; | ||||
| readonly Promise<T> m_medium; | ||||
| public HandlerDescriptor(Action<T> resultHandler, Action<Exception> errorHandler, Action cancelHandler, Promise<T> medium) { | ||||
| m_resultHandler = resultHandler; | ||||
| m_errorHandler = errorHandler; | ||||
| m_cancellHandler = cancelHandler; | ||||
| m_medium = medium; | ||||
| } | ||||
| public override void Resolve(T result) { | ||||
| if (m_resultHandler != null) { | ||||
| try { | ||||
| m_resultHandler(result); | ||||
| } catch (Exception e) { | ||||
| Reject(e); | ||||
| return; | ||||
| } | ||||
| } | ||||
| if(m_medium != null) | ||||
| m_medium.Resolve(result); | ||||
| } | ||||
| public override void Reject(Exception error) { | ||||
| if (m_errorHandler != null) { | ||||
| try { | ||||
| m_errorHandler(error); | ||||
| if (m_medium != null) | ||||
| m_medium.Resolve(default(T)); | ||||
|
cin
|
r72 | } catch (Exception err2) { | ||
|
cin
|
r106 | if (m_medium != null) | ||
| m_medium.Reject(err2); | ||||
|
cin
|
r19 | } | ||
|
cin
|
r106 | } else if (m_medium != null) | ||
| m_medium.Reject(error); | ||||
|
cin
|
r19 | } | ||
|
cin
|
r106 | public override void Cancel() { | ||
| if (m_cancellHandler != null) { | ||||
|
cin
|
r19 | try { | ||
|
cin
|
r106 | m_cancellHandler(); | ||
|
cin
|
r72 | } catch (Exception err) { | ||
| Reject(err); | ||||
| return; | ||||
|
cin
|
r19 | } | ||
|
cin
|
r72 | } | ||
|
cin
|
r106 | if (m_medium != null) | ||
| m_medium.Cancel(); | ||||
|
cin
|
r19 | } | ||
|
cin
|
r6 | } | ||
|
cin
|
r71 | const int UNRESOLVED_SATE = 0; | ||
| const int TRANSITIONAL_STATE = 1; | ||||
| const int SUCCEEDED_STATE = 2; | ||||
| const int REJECTED_STATE = 3; | ||||
| const int CANCELLED_STATE = 4; | ||||
|
cin
|
r19 | |||
|
cin
|
r101 | int m_childrenCount; | ||
|
cin
|
r19 | int m_state; | ||
|
cin
|
r6 | T m_result; | ||
| Exception m_error; | ||||
|
cin
|
r9 | |||
|
cin
|
r106 | readonly MTCustomQueue<AbstractHandler> m_handlers = new MTCustomQueue<AbstractHandler>(); | ||
| //readonly MTQueue<AbstractHandler> m_handlers = new MTQueue<AbstractHandler>(); | ||||
|
cin
|
r19 | |||
|
cin
|
r6 | public Promise() { | ||
| } | ||||
|
cin
|
r2 | |||
|
cin
|
r101 | public Promise(IPromise parent) { | ||
|
cin
|
r33 | if (parent != null) | ||
|
cin
|
r112 | AddHandler( | ||
|
cin
|
r76 | null, | ||
| null, | ||||
| () => { | ||||
| if (parent.IsExclusive) | ||||
| parent.Cancel(); | ||||
| }, | ||||
|
cin
|
r104 | null, | ||
| false | ||||
|
cin
|
r76 | ); | ||
|
cin
|
r10 | } | ||
|
cin
|
r2 | |||
|
cin
|
r19 | bool BeginTransit() { | ||
|
cin
|
r71 | return UNRESOLVED_SATE == Interlocked.CompareExchange(ref m_state, TRANSITIONAL_STATE, UNRESOLVED_SATE); | ||
|
cin
|
r19 | } | ||
| void CompleteTransit(int state) { | ||||
|
cin
|
r71 | if (TRANSITIONAL_STATE != Interlocked.CompareExchange(ref m_state, state, TRANSITIONAL_STATE)) | ||
|
cin
|
r19 | throw new InvalidOperationException("Can't complete transition when the object isn't in the transitional state"); | ||
| } | ||||
|
cin
|
r25 | void WaitTransition() { | ||
|
cin
|
r71 | while (m_state == TRANSITIONAL_STATE) { | ||
|
cin
|
r80 | Thread.MemoryBarrier(); | ||
|
cin
|
r25 | } | ||
| } | ||||
|
cin
|
r19 | public bool IsResolved { | ||
| get { | ||||
|
cin
|
r80 | Thread.MemoryBarrier(); | ||
|
cin
|
r19 | return m_state > 1; | ||
| } | ||||
| } | ||||
| public bool IsCancelled { | ||||
| get { | ||||
|
cin
|
r80 | Thread.MemoryBarrier(); | ||
|
cin
|
r71 | return m_state == CANCELLED_STATE; | ||
|
cin
|
r19 | } | ||
| } | ||||
|
cin
|
r29 | public Type PromiseType { | ||
| get { return typeof(T); } | ||||
| } | ||||
|
cin
|
r6 | /// <summary> | ||
| /// Выполняет обещание, сообщая об успешном выполнении. | ||||
| /// </summary> | ||||
| /// <param name="result">Результат выполнения.</param> | ||||
| /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception> | ||||
| public void Resolve(T result) { | ||||
|
cin
|
r19 | if (BeginTransit()) { | ||
|
cin
|
r6 | m_result = result; | ||
|
cin
|
r71 | CompleteTransit(SUCCEEDED_STATE); | ||
|
cin
|
r19 | OnStateChanged(); | ||
|
cin
|
r25 | } else { | ||
| WaitTransition(); | ||||
|
cin
|
r71 | if (m_state != CANCELLED_STATE) | ||
|
cin
|
r25 | throw new InvalidOperationException("The promise is already resolved"); | ||
| } | ||||
|
cin
|
r6 | } | ||
|
cin
|
r2 | |||
|
cin
|
r6 | /// <summary> | ||
|
cin
|
r33 | /// Выполняет обещание, сообщая об успешном выполнении. Результатом выполнения будет пустое значения. | ||
| /// </summary> | ||||
| /// <remarks> | ||||
| /// Данный вариант удобен в случаях, когда интересен факт выполнения операции, нежели полученное значение. | ||||
| /// </remarks> | ||||
| public void Resolve() { | ||||
| Resolve(default(T)); | ||||
| } | ||||
| /// <summary> | ||||
|
cin
|
r6 | /// Выполняет обещание, сообщая об ошибке | ||
| /// </summary> | ||||
|
cin
|
r16 | /// <remarks> | ||
| /// Поскольку обещание должно работать в многопточной среде, при его выполнении сразу несколько потоков | ||||
| /// могу вернуть ошибку, при этом только первая будет использована в качестве результата, остальные | ||||
| /// будут проигнорированы. | ||||
| /// </remarks> | ||||
|
cin
|
r6 | /// <param name="error">Исключение возникшее при выполнении операции</param> | ||
| /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception> | ||||
| public void Reject(Exception error) { | ||||
|
cin
|
r19 | if (BeginTransit()) { | ||
|
cin
|
r99 | m_error = error is TransientPromiseException ? error.InnerException : error; | ||
|
cin
|
r71 | CompleteTransit(REJECTED_STATE); | ||
|
cin
|
r19 | OnStateChanged(); | ||
|
cin
|
r25 | } else { | ||
| WaitTransition(); | ||||
|
cin
|
r71 | if (m_state == SUCCEEDED_STATE) | ||
|
cin
|
r25 | throw new InvalidOperationException("The promise is already resolved"); | ||
| } | ||||
|
cin
|
r6 | } | ||
|
cin
|
r2 | |||
|
cin
|
r6 | /// <summary> | ||
| /// Отменяет операцию, если это возможно. | ||||
| /// </summary> | ||||
|
cin
|
r76 | /// <remarks>Для определения была ли операция отменена следует использовать свойство <see cref="IsCancelled"/>.</remarks> | ||
| public void Cancel() { | ||||
|
cin
|
r101 | if (BeginTransit()) { | ||
|
cin
|
r71 | CompleteTransit(CANCELLED_STATE); | ||
|
cin
|
r33 | OnStateChanged(); | ||
| } | ||||
| } | ||||
|
cin
|
r76 | /// <summary> | ||
| /// Последний обработчик в цепочки обещаний. | ||||
| /// </summary> | ||||
| /// <param name="success"></param> | ||||
| /// <param name="error"></param> | ||||
| /// <param name="cancel"></param> | ||||
| /// <remarks> | ||||
| /// <para> | ||||
| /// Данный метод не создает связанного с текущим обещания и предназначен для окончания | ||||
| /// фсинхронной цепочки. | ||||
| /// </para> | ||||
| /// <para> | ||||
| /// Если данный метод вызвать несколько раз, либо добавить другие обработчики, то цепочка | ||||
| /// не будет одиночной <see cref="IsExclusive"/> и, как следствие, будет невозможна отмена | ||||
| /// всей цепи обещаний снизу (с самого последнего обещания). | ||||
| /// </para> | ||||
| /// </remarks> | ||||
|
cin
|
r104 | public void On(Action<T> success, Action<Exception> error, Action cancel) { | ||
|
cin
|
r75 | if (success == null && error == null && cancel == null) | ||
| return; | ||||
|
cin
|
r107 | AddHandler(success, error, cancel, null, false); | ||
|
cin
|
r104 | } | ||
| public void On(Action<T> success, Action<Exception> error) { | ||||
|
cin
|
r107 | AddHandler(success, error, null, null, false); | ||
|
cin
|
r104 | } | ||
| public void On(Action<T> success) { | ||||
|
cin
|
r107 | AddHandler(success, null, null, null, false); | ||
|
cin
|
r75 | } | ||
|
cin
|
r104 | public void On(Action handler, PromiseEventType events) { | ||
| Safe.ArgumentNotNull(handler, "handler"); | ||||
|
cin
|
r75 | |||
|
cin
|
r104 | |||
|
cin
|
r107 | AddHandler( | ||
| events.HasFlag(PromiseEventType.Success) ? new Action<T>(x => handler()) : null, | ||||
| events.HasFlag(PromiseEventType.Error) ? new Action<Exception>( x => handler()) : null, | ||||
| events.HasFlag(PromiseEventType.Cancelled) ? handler : null, | ||||
| null, | ||||
| false | ||||
| ); | ||||
|
cin
|
r75 | } | ||
|
cin
|
r101 | public IPromise Error(Action<Exception> error) { | ||
|
cin
|
r72 | if (error == null) | ||
| return this; | ||||
|
cin
|
r101 | var medium = new Promise<T>(this); | ||
|
cin
|
r72 | |||
|
cin
|
r107 | AddMappers( | ||
|
cin
|
r112 | x => x, | ||
|
cin
|
r72 | e => { | ||
| error(e); | ||||
| return default(T); | ||||
| }, | ||||
| null, | ||||
|
cin
|
r104 | medium, | ||
| true | ||||
|
cin
|
r72 | ); | ||
| return medium; | ||||
|
cin
|
r6 | } | ||
|
cin
|
r2 | |||
|
cin
|
r11 | /// <summary> | ||
| /// Handles error and allows to keep the promise. | ||||
| /// </summary> | ||||
| /// <remarks> | ||||
| /// If the specified handler throws an exception, this exception will be used to reject the promise. | ||||
| /// </remarks> | ||||
| /// <param name="handler">The error handler which returns the result of the promise.</param> | ||||
| /// <returns>New promise.</returns> | ||||
|
cin
|
r101 | public IPromise<T> Error(Func<Exception,T> handler) { | ||
|
cin
|
r11 | if (handler == null) | ||
| return this; | ||||
|
cin
|
r101 | var medium = new Promise<T>(this); | ||
|
cin
|
r11 | |||
|
cin
|
r112 | AddMappers(x => x, handler, null, medium, true); | ||
|
cin
|
r11 | |||
| return medium; | ||||
| } | ||||
|
cin
|
r6 | /// <summary> | ||
| /// Позволяет преобразовать результат выполения операции к новому типу. | ||||
| /// </summary> | ||||
| /// <typeparam name="TNew">Новый тип результата.</typeparam> | ||||
| /// <param name="mapper">Преобразование результата к новому типу.</param> | ||||
| /// <param name="error">Обработчик ошибки. Данный обработчик получит | ||||
| /// исключение возникшее при выполнении операции.</param> | ||||
| /// <returns>Новое обещание, которое будет выполнено при выполнении исходного обещания.</returns> | ||||
|
cin
|
r96 | /// <param name = "cancel"></param> | ||
|
cin
|
r101 | public IPromise<TNew> Then<TNew>(Func<T, TNew> mapper, Func<Exception,TNew> error, Action cancel) { | ||
|
cin
|
r76 | Safe.ArgumentNotNull(mapper, "mapper"); | ||
| // создаем прицепленное обещание | ||||
|
cin
|
r101 | var medium = new Promise<TNew>(this); | ||
|
cin
|
r2 | |||
|
cin
|
r107 | AddMappers( | ||
|
cin
|
r106 | mapper, | ||
| error, | ||||
| cancel, | ||||
| medium, | ||||
|
cin
|
r104 | true | ||
|
cin
|
r19 | ); | ||
|
cin
|
r2 | |||
|
cin
|
r76 | return medium; | ||
| } | ||||
|
cin
|
r101 | public IPromise<TNew> Then<TNew>(Func<T, TNew> mapper, Func<Exception,TNew> error) { | ||
|
cin
|
r76 | return Then(mapper, error, null); | ||
|
cin
|
r6 | } | ||
|
cin
|
r101 | public IPromise<TNew> Then<TNew>(Func<T, TNew> mapper) { | ||
|
cin
|
r76 | return Then(mapper, null, null); | ||
|
cin
|
r6 | } | ||
|
cin
|
r2 | |||
|
cin
|
r6 | /// <summary> | ||
| /// Сцепляет несколько аснхронных операций. Указанная асинхронная операция будет вызвана после | ||||
| /// выполнения текущей, а результат текущей операции может быть использован для инициализации | ||||
| /// новой операции. | ||||
| /// </summary> | ||||
| /// <typeparam name="TNew">Тип результата указанной асинхронной операции.</typeparam> | ||||
| /// <param name="chained">Асинхронная операция, которая должна будет начаться после выполнения текущей.</param> | ||||
| /// <param name="error">Обработчик ошибки. Данный обработчик получит | ||||
| /// исключение возникшее при выполнении текуещй операции.</param> | ||||
| /// <returns>Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции.</returns> | ||||
|
cin
|
r96 | /// <param name = "cancel"></param> | ||
|
cin
|
r101 | public IPromise<TNew> Chain<TNew>(Func<T, IPromise<TNew>> chained, Func<Exception,IPromise<TNew>> error, Action cancel) { | ||
|
cin
|
r76 | |||
| Safe.ArgumentNotNull(chained, "chained"); | ||||
|
cin
|
r6 | |||
| // проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно | ||||
| // создать посредника, к которому будут подвызяваться следующие обработчики. | ||||
| // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы | ||||
| // передать через него результаты работы. | ||||
|
cin
|
r101 | var medium = new Promise<TNew>(this); | ||
|
cin
|
r2 | |||
|
cin
|
r106 | Func<T,T> resultHandler = delegate(T result) { | ||
|
cin
|
r19 | if (medium.IsCancelled) | ||
|
cin
|
r106 | return default(T); | ||
|
cin
|
r10 | |||
|
cin
|
r19 | var promise = chained(result); | ||
|
cin
|
r10 | |||
|
cin
|
r104 | promise.On( | ||
|
cin
|
r72 | medium.Resolve, | ||
|
cin
|
r76 | medium.Reject, | ||
| () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка | ||||
|
cin
|
r19 | ); | ||
|
cin
|
r33 | |||
| // notify chained operation that it's not needed anymore | ||||
| // порядок вызова Then, Cancelled важен, поскольку от этого | ||||
| // зависит IsExclusive | ||||
|
cin
|
r104 | medium.On( | ||
|
cin
|
r101 | null, | ||
| null, | ||||
| () => { | ||||
| if (promise.IsExclusive) | ||||
| promise.Cancel(); | ||||
| } | ||||
| ); | ||||
|
cin
|
r106 | |||
| return default(T); | ||||
|
cin
|
r19 | }; | ||
|
cin
|
r101 | Func<Exception,T> errorHandler; | ||
|
cin
|
r76 | |||
| if (error != null) | ||||
| errorHandler = delegate(Exception e) { | ||||
|
cin
|
r72 | try { | ||
|
cin
|
r76 | var promise = error(e); | ||
|
cin
|
r104 | promise.On( | ||
|
cin
|
r76 | medium.Resolve, | ||
| medium.Reject, | ||||
| () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка | ||||
| ); | ||||
| // notify chained operation that it's not needed anymore | ||||
| // порядок вызова Then, Cancelled важен, поскольку от этого | ||||
| // зависит IsExclusive | ||||
| medium.Cancelled(() => { | ||||
| if (promise.IsExclusive) | ||||
| promise.Cancel(); | ||||
| }); | ||||
|
cin
|
r72 | } catch (Exception e2) { | ||
| medium.Reject(e2); | ||||
| } | ||||
|
cin
|
r76 | return default(T); | ||
| }; | ||||
| else | ||||
| errorHandler = err => { | ||||
| medium.Reject(err); | ||||
| return default(T); | ||||
| }; | ||||
| Action cancelHandler; | ||||
| if (cancel != null) | ||||
| cancelHandler = () => { | ||||
| if (cancel != null) | ||||
| cancel(); | ||||
| medium.Cancel(); | ||||
| }; | ||||
| else | ||||
| cancelHandler = medium.Cancel; | ||||
|
cin
|
r19 | |||
|
cin
|
r107 | AddMappers( | ||
|
cin
|
r19 | resultHandler, | ||
| errorHandler, | ||||
|
cin
|
r76 | cancelHandler, | ||
|
cin
|
r104 | null, | ||
| true | ||||
|
cin
|
r19 | ); | ||
|
cin
|
r2 | |||
|
cin
|
r6 | return medium; | ||
| } | ||||
|
cin
|
r101 | public IPromise<TNew> Chain<TNew>(Func<T, IPromise<TNew>> chained, Func<Exception,IPromise<TNew>> error) { | ||
|
cin
|
r76 | return Chain(chained, error, null); | ||
| } | ||||
|
cin
|
r101 | public IPromise<TNew> Chain<TNew>(Func<T, IPromise<TNew>> chained) { | ||
|
cin
|
r76 | return Chain(chained, null, null); | ||
|
cin
|
r6 | } | ||
|
cin
|
r2 | |||
|
cin
|
r26 | public IPromise<T> Cancelled(Action handler) { | ||
|
cin
|
r101 | var medium = new Promise<T>(this); | ||
|
cin
|
r104 | AddHandler(null, null, handler, medium, false); | ||
|
cin
|
r74 | return medium; | ||
|
cin
|
r10 | } | ||
|
cin
|
r25 | /// <summary> | ||
| /// Adds the specified handler for all cases (success, error, cancel) | ||||
| /// </summary> | ||||
| /// <param name="handler">The handler that will be called anyway</param> | ||||
| /// <returns>self</returns> | ||||
|
cin
|
r76 | public IPromise<T> Anyway(Action handler) { | ||
| Safe.ArgumentNotNull(handler, "handler"); | ||||
|
cin
|
r104 | |||
| var medium = new Promise<T>(this); | ||||
|
cin
|
r19 | AddHandler( | ||
|
cin
|
r107 | x => handler(), | ||
|
cin
|
r72 | e => { | ||
| handler(); | ||||
| throw new TransientPromiseException(e); | ||||
| }, | ||||
| handler, | ||||
|
cin
|
r104 | medium, | ||
| true | ||||
|
cin
|
r19 | ); | ||
|
cin
|
r104 | |||
| return medium; | ||||
|
cin
|
r10 | } | ||
|
cin
|
r6 | /// <summary> | ||
|
cin
|
r29 | /// Преобразует результат обещания к нужному типу | ||
| /// </summary> | ||||
| /// <typeparam name="T2"></typeparam> | ||||
| /// <returns></returns> | ||||
| public IPromise<T2> Cast<T2>() { | ||||
|
cin
|
r75 | return Then(x => (T2)(object)x, null); | ||
|
cin
|
r29 | } | ||
| /// <summary> | ||||
|
cin
|
r6 | /// Дожидается отложенного обещания и в случае успеха, возвращает | ||
| /// его, результат, в противном случае бросает исключение. | ||||
| /// </summary> | ||||
| /// <remarks> | ||||
| /// <para> | ||||
| /// Если ожидание обещания было прервано по таймауту, это не значит, | ||||
| /// что обещание было отменено или что-то в этом роде, это только | ||||
| /// означает, что мы его не дождались, однако все зарегистрированные | ||||
| /// обработчики, как были так остались и они будут вызваны, когда | ||||
| /// обещание будет выполнено. | ||||
| /// </para> | ||||
| /// <para> | ||||
| /// Такое поведение вполне оправдано поскольку таймаут может истечь | ||||
| /// в тот момент, когда началась обработка цепочки обработчиков, и | ||||
| /// к тому же текущее обещание может стоять в цепочке обещаний и его | ||||
| /// отклонение может привести к непрогнозируемому результату. | ||||
| /// </para> | ||||
| /// </remarks> | ||||
| /// <param name="timeout">Время ожидания</param> | ||||
| /// <returns>Результат выполнения обещания</returns> | ||||
| public T Join(int timeout) { | ||||
|
cin
|
r10 | var evt = new ManualResetEvent(false); | ||
|
cin
|
r76 | Anyway(() => evt.Set()); | ||
|
cin
|
r2 | |||
|
cin
|
r6 | if (!evt.WaitOne(timeout, true)) | ||
| throw new TimeoutException(); | ||||
|
cin
|
r2 | |||
|
cin
|
r19 | switch (m_state) { | ||
|
cin
|
r71 | case SUCCEEDED_STATE: | ||
|
cin
|
r10 | return m_result; | ||
|
cin
|
r71 | case CANCELLED_STATE: | ||
|
cin
|
r10 | throw new OperationCanceledException(); | ||
|
cin
|
r71 | case REJECTED_STATE: | ||
|
cin
|
r10 | throw new TargetInvocationException(m_error); | ||
| default: | ||||
|
cin
|
r19 | throw new ApplicationException(String.Format("Invalid promise state {0}", m_state)); | ||
|
cin
|
r10 | } | ||
|
cin
|
r6 | } | ||
| public T Join() { | ||||
| return Join(Timeout.Infinite); | ||||
| } | ||||
|
cin
|
r2 | |||
|
cin
|
r107 | void AddMappers<T2>(Func<T,T2> success, Func<Exception,T2> error, Action cancel, Promise<T2> medium, bool inc) { | ||
|
cin
|
r104 | if (inc) | ||
|
cin
|
r33 | Interlocked.Increment(ref m_childrenCount); | ||
|
cin
|
r19 | |||
|
cin
|
r107 | AbstractHandler handler = new RemapDescriptor<T2>(success, error, cancel, medium); | ||
| bool queued; | ||||
| if (!IsResolved) { | ||||
| m_handlers.Enqueue(handler); | ||||
| queued = true; | ||||
| } else { | ||||
| // the promise is in resolved state, just invoke the handled with minimum overhead | ||||
| queued = false; | ||||
| InvokeHandler(handler); | ||||
| } | ||||
| if (queued && IsResolved && m_handlers.TryDequeue(out handler)) | ||||
| // if the promise have been resolved while we was adding handler to the queue | ||||
| // we can't guarantee that someone is still processing it | ||||
| // therefore we will fetch a handler from the queue and execute it | ||||
| // note that fetched handler may be not the one that we have added | ||||
| // even we can fetch no handlers at all :) | ||||
| InvokeHandler(handler); | ||||
| } | ||||
| void AddHandler(Action<T> success, Action<Exception> error, Action cancel, Promise<T> medium, bool inc) { | ||||
| if (inc) | ||||
| Interlocked.Increment(ref m_childrenCount); | ||||
| AbstractHandler handler = new HandlerDescriptor(success, error, cancel, medium); | ||||
|
cin
|
r2 | |||
|
cin
|
r19 | bool queued; | ||
| if (!IsResolved) { | ||||
| m_handlers.Enqueue(handler); | ||||
| queued = true; | ||||
| } else { | ||||
| // the promise is in resolved state, just invoke the handled with minimum overhead | ||||
| queued = false; | ||||
| InvokeHandler(handler); | ||||
|
cin
|
r6 | } | ||
|
cin
|
r2 | |||
|
cin
|
r19 | if (queued && IsResolved && m_handlers.TryDequeue(out handler)) | ||
| // if the promise have been resolved while we was adding handler to the queue | ||||
| // we can't guarantee that someone is still processing it | ||||
| // therefore we will fetch a handler from the queue and execute it | ||||
|
cin
|
r27 | // note that fetched handler may be not the one that we have added | ||
| // even we can fetch no handlers at all :) | ||||
|
cin
|
r6 | InvokeHandler(handler); | ||
| } | ||||
|
cin
|
r2 | |||
|
cin
|
r106 | protected virtual void InvokeHandler(AbstractHandler handler) { | ||
|
cin
|
r10 | switch (m_state) { | ||
|
cin
|
r71 | case SUCCEEDED_STATE: | ||
|
cin
|
r19 | handler.Resolve(m_result); | ||
|
cin
|
r10 | break; | ||
|
cin
|
r71 | case REJECTED_STATE: | ||
|
cin
|
r19 | handler.Reject(m_error); | ||
| break; | ||||
|
cin
|
r71 | case CANCELLED_STATE: | ||
|
cin
|
r19 | handler.Cancel(); | ||
|
cin
|
r10 | break; | ||
| default: | ||||
| // do nothing | ||||
| return; | ||||
|
cin
|
r6 | } | ||
| } | ||||
|
cin
|
r2 | |||
|
cin
|
r65 | void OnStateChanged() { | ||
|
cin
|
r106 | AbstractHandler handler; | ||
|
cin
|
r19 | while (m_handlers.TryDequeue(out handler)) | ||
| InvokeHandler(handler); | ||||
|
cin
|
r11 | } | ||
|
cin
|
r9 | public bool IsExclusive { | ||
| get { | ||||
|
cin
|
r19 | return m_childrenCount <= 1; | ||
|
cin
|
r9 | } | ||
| } | ||||
|
cin
|
r25 | /// <summary> | ||
| /// Объединяет несколько обещаний в одно, результатом которого является массив результатов других обещаний. | ||||
| /// Если хотябы одно из переданных обещаний не будет выполнено, то новое обещение тоже не будет выполнено. | ||||
| /// При отмене нового обещания, переданные обещания также будут отменены, если никто больше на них не подписан. | ||||
| /// </summary> | ||||
| /// <param name="promises">Список обещаний. Если список пустой, то результирующее обещание возвращается уже выполненным.</param> | ||||
| /// <returns>Обещание объединяющее в себе результат переданных обещаний.</returns> | ||||
| /// <exception cref="ArgumentNullException"><paramref name="promises"/> не может быть null</exception> | ||||
|
cin
|
r30 | public static IPromise<T[]> CreateComposite(IList<IPromise<T>> promises) { | ||
|
cin
|
r25 | if (promises == null) | ||
| throw new ArgumentNullException(); | ||||
| // создаем аккумулятор для результатов и результирующее обещание | ||||
| var result = new T[promises.Count]; | ||||
| var promise = new Promise<T[]>(); | ||||
| // special case | ||||
| if (promises.Count == 0) { | ||||
| promise.Resolve(result); | ||||
| return promise; | ||||
| } | ||||
| int pending = promises.Count; | ||||
| for (int i = 0; i < promises.Count; i++) { | ||||
| var dest = i; | ||||
|
cin
|
r33 | if (promises[i] != null) { | ||
|
cin
|
r106 | promises[i].On( | ||
|
cin
|
r33 | x => { | ||
| result[dest] = x; | ||||
| if (Interlocked.Decrement(ref pending) == 0) | ||||
| promise.Resolve(result); | ||||
| }, | ||||
|
cin
|
r106 | promise.Reject | ||
|
cin
|
r33 | ); | ||
| } else { | ||||
| if (Interlocked.Decrement(ref pending) == 0) | ||||
| promise.Resolve(result); | ||||
| } | ||||
|
cin
|
r25 | } | ||
| promise.Cancelled( | ||||
| () => { | ||||
|
cin
|
r33 | foreach (var d in promises) | ||
| if (d != null && d.IsExclusive) | ||||
|
cin
|
r25 | d.Cancel(); | ||
| } | ||||
| ); | ||||
| return promise; | ||||
| } | ||||
|
cin
|
r33 | /// <summary> | ||
| /// Объединяет несколько обещаний в одно. Результирующее обещание будет выполнено при | ||||
| /// выполнении всех указанных обещаний. При этом возвращаемые значения первичных обещаний | ||||
| /// игнорируются. | ||||
| /// </summary> | ||||
| /// <param name="promises">Коллекция первичных обещаний, которые будут объеденены в одно.</param> | ||||
| /// <returns>Новое обещание, объединяющее в себе переданные.</returns> | ||||
| /// <remarks> | ||||
| /// Если в коллекции встречаюься <c>null</c>, то они воспринимаются как выполненные обещания. | ||||
| /// </remarks> | ||||
|
cin
|
r66 | public static IPromise CreateComposite(ICollection<IPromise> promises) { | ||
|
cin
|
r33 | 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; | ||||
| } | ||||
|
cin
|
r25 | public static Promise<T> ResultToPromise(T result) { | ||
| var p = new Promise<T>(); | ||||
| p.Resolve(result); | ||||
| return p; | ||||
| } | ||||
| public static Promise<T> ExceptionToPromise(Exception error) { | ||||
| if (error == null) | ||||
| throw new ArgumentNullException(); | ||||
| var p = new Promise<T>(); | ||||
| p.Reject(error); | ||||
| return p; | ||||
| } | ||||
|
cin
|
r33 | #region IPromiseBase explicit implementation | ||
|
cin
|
r101 | IPromise IPromise.Then(Action success, Action<Exception> error, Action cancel) { | ||
|
cin
|
r76 | return Then( | ||
|
cin
|
r106 | success != null ? new Func<T,T>(x => { | ||
| success(); | ||||
| return x; | ||||
| }) : null, | ||||
|
cin
|
r101 | error != null ? new Func<Exception,T>(e => { | ||
|
cin
|
r76 | error(e); | ||
| return default(T); | ||||
|
cin
|
r96 | }) : null, | ||
|
cin
|
r76 | cancel | ||
| ); | ||||
| } | ||||
|
cin
|
r101 | IPromise IPromise.Then(Action success, Action<Exception> error) { | ||
|
cin
|
r76 | return Then( | ||
|
cin
|
r106 | success != null ? new Func<T,T>(x => { | ||
| success(); | ||||
| return x; | ||||
| }) : null, | ||||
|
cin
|
r101 | error != null ? new Func<Exception,T>(e => { | ||
|
cin
|
r76 | error(e); | ||
| return default(T); | ||||
|
cin
|
r96 | }) : null | ||
|
cin
|
r76 | ); | ||
| } | ||||
| IPromise IPromise.Then(Action success) { | ||||
|
cin
|
r96 | Safe.ArgumentNotNull(success, "success"); | ||
|
cin
|
r106 | return Then(x => { | ||
| success(); | ||||
| return x; | ||||
| }); | ||||
|
cin
|
r76 | } | ||
|
cin
|
r101 | IPromise IPromise.Chain(Func<IPromise> chained, Func<Exception,IPromise> error, Action cancel) { | ||
|
cin
|
r96 | return ChainNoResult(chained, error, cancel); | ||
| } | ||||
|
cin
|
r101 | IPromise ChainNoResult(Func<IPromise> chained, Func<Exception,IPromise> error, Action cancel) { | ||
|
cin
|
r104 | Safe.ArgumentNotNull(chained, "chained"); | ||
|
cin
|
r96 | |||
|
cin
|
r101 | var medium = new Promise<object>(this); | ||
|
cin
|
r96 | |||
|
cin
|
r106 | Func<T,T> resultHandler = delegate { | ||
|
cin
|
r104 | if (medium.IsCancelled) | ||
|
cin
|
r106 | return default(T); | ||
|
cin
|
r96 | |||
|
cin
|
r104 | var promise = chained(); | ||
|
cin
|
r96 | |||
|
cin
|
r104 | promise.On( | ||
| medium.Resolve, | ||||
| medium.Reject, | ||||
| () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка | ||||
| ); | ||||
|
cin
|
r96 | |||
|
cin
|
r104 | // notify chained operation that it's not needed anymore | ||
| // порядок вызова Then, Cancelled важен, поскольку от этого | ||||
| // зависит IsExclusive | ||||
| medium.Cancelled(() => { | ||||
| if (promise.IsExclusive) | ||||
| promise.Cancel(); | ||||
| }); | ||||
|
cin
|
r106 | |||
| return default(T); | ||||
|
cin
|
r104 | }; | ||
|
cin
|
r96 | |||
|
cin
|
r101 | Func<Exception,T> errorHandler; | ||
|
cin
|
r96 | |||
|
cin
|
r104 | if (error != null) | ||
| errorHandler = delegate(Exception e) { | ||||
|
cin
|
r96 | try { | ||
| var promise = error(e); | ||||
|
cin
|
r104 | promise.On( | ||
|
cin
|
r96 | medium.Resolve, | ||
| medium.Reject, | ||||
| () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка | ||||
| ); | ||||
| // notify chained operation that it's not needed anymore | ||||
| // порядок вызова Then, Cancelled важен, поскольку от этого | ||||
| // зависит IsExclusive | ||||
| medium.Cancelled(() => { | ||||
| if (promise.IsExclusive) | ||||
| promise.Cancel(); | ||||
| }); | ||||
| } catch (Exception e2) { | ||||
| medium.Reject(e2); | ||||
| } | ||||
| return default(T); | ||||
| }; | ||||
|
cin
|
r104 | else | ||
| errorHandler = err => { | ||||
|
cin
|
r96 | medium.Reject(err); | ||
| return default(T); | ||||
| }; | ||||
|
cin
|
r104 | Action cancelHandler; | ||
| if (cancel != null) | ||||
| cancelHandler = () => { | ||||
|
cin
|
r96 | if (cancel != null) | ||
| cancel(); | ||||
| medium.Cancel(); | ||||
| }; | ||||
|
cin
|
r104 | else | ||
| cancelHandler = medium.Cancel; | ||||
|
cin
|
r96 | |||
|
cin
|
r107 | AddMappers( | ||
|
cin
|
r104 | resultHandler, | ||
| errorHandler, | ||||
| cancelHandler, | ||||
| null, | ||||
| true | ||||
| ); | ||||
|
cin
|
r96 | |||
|
cin
|
r104 | return medium; | ||
|
cin
|
r96 | } | ||
|
cin
|
r104 | |||
|
cin
|
r101 | IPromise IPromise.Chain(Func<IPromise> chained, Func<Exception,IPromise> error) { | ||
|
cin
|
r96 | return ChainNoResult(chained, error, null); | ||
| } | ||||
|
cin
|
r104 | |||
|
cin
|
r96 | IPromise IPromise.Chain(Func<IPromise> chained) { | ||
| return ChainNoResult(chained, null, null); | ||||
|
cin
|
r104 | } | ||
|
cin
|
r96 | |||
|
cin
|
r104 | void IPromise.On(Action success, Action<Exception> error, Action cancel) { | ||
|
cin
|
r105 | On(success != null ? new Action<T>(x => success()) : null, error, cancel); | ||
|
cin
|
r76 | } | ||
|
cin
|
r104 | void IPromise.On(Action success, Action<Exception> error) { | ||
| On(x => success(), error, null); | ||||
|
cin
|
r76 | } | ||
|
cin
|
r104 | void IPromise.On(Action success) { | ||
| On(x => success(), null, null); | ||||
|
cin
|
r76 | } | ||
|
cin
|
r101 | IPromise IPromise.Error(Action<Exception> error) { | ||
|
cin
|
r33 | return Error(error); | ||
| } | ||||
|
cin
|
r76 | IPromise IPromise.Anyway(Action handler) { | ||
| return Anyway(handler); | ||||
|
cin
|
r33 | } | ||
|
cin
|
r66 | IPromise IPromise.Cancelled(Action handler) { | ||
|
cin
|
r33 | return Cancelled(handler); | ||
| } | ||||
|
cin
|
r66 | void IPromise.Join() { | ||
|
cin
|
r33 | Join(); | ||
| } | ||||
|
cin
|
r66 | void IPromise.Join(int timeout) { | ||
|
cin
|
r33 | Join(timeout); | ||
| } | ||||
| #endregion | ||||
|
cin
|
r6 | } | ||
|
cin
|
r2 | } | ||