Promise.cs
731 lines
| 30.7 KiB
| text/x-csharp
|
CSharpLexer
/ Implab / Promise.cs
cin
|
r2 | using System; | ||
| using System.Collections.Generic; | ||||
| using System.Reflection; | ||||
| using System.Diagnostics; | ||||
| using System.Threading; | ||||
|
cin
|
r19 | using Implab.Parallels; | ||
|
cin
|
r2 | |||
| namespace Implab { | ||||
|
cin
|
r6 | public delegate void ErrorHandler(Exception e); | ||
|
cin
|
r11 | public delegate T ErrorHandler<out T>(Exception e); | ||
|
cin
|
r10 | public delegate void ResultHandler<in T>(T result); | ||
|
cin
|
r72 | public delegate TNew ResultMapper<in TSrc,out TNew>(TSrc result); | ||
| public delegate IPromise<TNew> ChainedOperation<in TSrc,TNew>(TSrc result); | ||||
|
cin
|
r2 | |||
|
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
|
r28 | protected struct HandlerDescriptor { | ||
|
cin
|
r6 | public ResultHandler<T> resultHandler; | ||
|
cin
|
r72 | public ErrorHandler<T> errorHandler; | ||
|
cin
|
r19 | public Action cancellHandler; | ||
|
cin
|
r72 | public Promise<T> medium; | ||
|
cin
|
r19 | |||
| public void Resolve(T result) { | ||||
|
cin
|
r72 | if (resultHandler != null) { | ||
|
cin
|
r19 | try { | ||
| resultHandler(result); | ||||
| } catch (Exception e) { | ||||
| Reject(e); | ||||
|
cin
|
r72 | return; | ||
|
cin
|
r19 | } | ||
|
cin
|
r72 | } | ||
| if (medium != null) | ||||
| medium.Resolve(result); | ||||
|
cin
|
r19 | } | ||
| public void Reject(Exception err) { | ||||
|
cin
|
r72 | if (errorHandler != null) { | ||
|
cin
|
r19 | try { | ||
|
cin
|
r72 | var res = errorHandler(err); | ||
| if (medium != null) | ||||
| medium.Resolve(res); | ||||
| } catch (TransientPromiseException err2) { | ||||
| if (medium != null) | ||||
| medium.Reject(err2.InnerException); | ||||
| } catch (Exception err2) { | ||||
| if (medium != null) | ||||
| medium.Reject(err2); | ||||
|
cin
|
r19 | } | ||
|
cin
|
r72 | } else if (medium != null) | ||
| medium.Reject(err); | ||||
|
cin
|
r19 | } | ||
| public void Cancel() { | ||||
|
cin
|
r72 | if (cancellHandler != null) { | ||
|
cin
|
r19 | try { | ||
| cancellHandler(); | ||||
|
cin
|
r72 | } catch (Exception err) { | ||
| Reject(err); | ||||
| return; | ||||
|
cin
|
r19 | } | ||
|
cin
|
r72 | } | ||
| if (medium != null) | ||||
| 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 | |||
| readonly bool m_cancellable; | ||||
|
cin
|
r9 | |||
|
cin
|
r10 | int m_childrenCount = 0; | ||
|
cin
|
r19 | int m_state; | ||
|
cin
|
r6 | T m_result; | ||
| Exception m_error; | ||||
|
cin
|
r9 | |||
|
cin
|
r19 | readonly MTQueue<HandlerDescriptor> m_handlers = new MTQueue<HandlerDescriptor>(); | ||
|
cin
|
r6 | public Promise() { | ||
| m_cancellable = true; | ||||
| } | ||||
|
cin
|
r2 | |||
|
cin
|
r66 | public Promise(IPromise parent, bool cancellable) { | ||
|
cin
|
r7 | m_cancellable = cancellable; | ||
|
cin
|
r33 | if (parent != null) | ||
|
cin
|
r72 | Cancelled(() => { | ||
| if (parent.IsExclusive) | ||||
| parent.Cancel(); | ||||
| }); | ||||
|
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
|
r25 | /* noop */ | ||
| } | ||||
| } | ||||
|
cin
|
r19 | public bool IsResolved { | ||
| get { | ||||
| return m_state > 1; | ||||
| } | ||||
| } | ||||
| public bool IsCancelled { | ||||
| get { | ||||
|
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
|
r6 | m_error = 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> | ||||
| /// <returns><c>true</c> Операция была отменена, обработчики не будут вызваны.<c>false</c> отмена не возможна, поскольку обещание уже выполнено и обработчики отработали.</returns> | ||||
| public bool Cancel() { | ||||
|
cin
|
r72 | if (m_cancellable && BeginTransit()) { | ||
|
cin
|
r71 | CompleteTransit(CANCELLED_STATE); | ||
|
cin
|
r33 | OnStateChanged(); | ||
| return true; | ||||
| } | ||||
|
cin
|
r72 | return false; | ||
|
cin
|
r33 | } | ||
| // сделано для возвращаемого типа void | ||||
| protected void InternalCancel() { | ||||
| Cancel(); | ||||
|
cin
|
r6 | } | ||
|
cin
|
r2 | |||
|
cin
|
r6 | /// <summary> | ||
|
cin
|
r11 | /// Adds new handlers to this promise. | ||
|
cin
|
r6 | /// </summary> | ||
|
cin
|
r11 | /// <param name="success">The handler of the successfully completed operation. | ||
| /// This handler will recieve an operation result as a parameter.</param> | ||||
| /// <param name="error">Handles an exception that may occur during the operation and returns the value which will be used as the result of the operation.</param> | ||||
| /// <returns>The new promise chained to this one.</returns> | ||||
|
cin
|
r26 | public IPromise<T> Then(ResultHandler<T> success, ErrorHandler<T> error) { | ||
|
cin
|
r11 | if (success == null && error == null) | ||
| return this; | ||||
| var medium = new Promise<T>(this, true); | ||||
|
cin
|
r72 | AddHandler(success, error, null, medium); | ||
|
cin
|
r11 | |||
| return medium; | ||||
| } | ||||
|
cin
|
r72 | public IPromise Then(Action success, ErrorHandler error) { | ||
| return Then( | ||||
| x => success(), | ||||
| e => { | ||||
| error(e); | ||||
| return default(T); | ||||
| } | ||||
| ); | ||||
| } | ||||
| public IPromise Then(Action success) { | ||||
| return Then(x => success()); | ||||
| } | ||||
|
cin
|
r11 | |||
|
cin
|
r26 | public IPromise<T> Then(ResultHandler<T> success) { | ||
|
cin
|
r11 | if (success == null) | ||
| return this; | ||||
| var medium = new Promise<T>(this, true); | ||||
|
cin
|
r72 | AddHandler(success, null, null, medium); | ||
|
cin
|
r11 | |||
| return medium; | ||||
|
cin
|
r6 | } | ||
|
cin
|
r2 | |||
|
cin
|
r72 | public IPromise Error(ErrorHandler error) { | ||
| if (error == null) | ||||
| return this; | ||||
| var medium = new Promise<T>(this, true); | ||||
| AddHandler( | ||||
| null, | ||||
| e => { | ||||
| error(e); | ||||
| return default(T); | ||||
| }, | ||||
| null, | ||||
| medium | ||||
| ); | ||||
| 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
|
r26 | public IPromise<T> Error(ErrorHandler<T> handler) { | ||
|
cin
|
r11 | if (handler == null) | ||
| return this; | ||||
| var medium = new Promise<T>(this, true); | ||||
|
cin
|
r72 | AddHandler(null, handler, null, medium); | ||
|
cin
|
r11 | |||
| return medium; | ||||
| } | ||||
|
cin
|
r26 | public IPromise<T> Anyway(Action handler) { | ||
|
cin
|
r6 | if (handler == null) | ||
| return this; | ||||
|
cin
|
r72 | var medium = new Promise<T>(this, true); | ||
|
cin
|
r2 | |||
|
cin
|
r19 | AddHandler( | ||
|
cin
|
r72 | x => handler(), | ||
| e => { | ||||
| handler(); | ||||
| throw new TransientPromiseException(e); | ||||
|
cin
|
r6 | }, | ||
|
cin
|
r72 | null, | ||
| medium | ||||
|
cin
|
r19 | ); | ||
|
cin
|
r2 | |||
|
cin
|
r6 | return medium; | ||
| } | ||||
|
cin
|
r2 | |||
|
cin
|
r6 | /// <summary> | ||
| /// Позволяет преобразовать результат выполения операции к новому типу. | ||||
| /// </summary> | ||||
| /// <typeparam name="TNew">Новый тип результата.</typeparam> | ||||
| /// <param name="mapper">Преобразование результата к новому типу.</param> | ||||
| /// <param name="error">Обработчик ошибки. Данный обработчик получит | ||||
| /// исключение возникшее при выполнении операции.</param> | ||||
| /// <returns>Новое обещание, которое будет выполнено при выполнении исходного обещания.</returns> | ||||
|
cin
|
r72 | public IPromise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler<T> error) { | ||
|
cin
|
r6 | if (mapper == null) | ||
| throw new ArgumentNullException("mapper"); | ||||
|
cin
|
r2 | |||
|
cin
|
r6 | // создаем прицепленное обещание | ||
|
cin
|
r72 | var chained = new Promise<TNew>(this, true); | ||
|
cin
|
r2 | |||
|
cin
|
r19 | ResultHandler<T> resultHandler = result => chained.Resolve(mapper(result)); | ||
|
cin
|
r72 | ErrorHandler<T> errorHandler; | ||
| if (error != null) | ||||
| errorHandler = e => { | ||||
|
cin
|
r19 | try { | ||
|
cin
|
r72 | return error(e); | ||
| } catch (Exception e2) { | ||||
| // в случае ошибки нужно передать исключение дальше по цепочке | ||||
| chained.Reject(e2); | ||||
| } | ||||
| return default(T); | ||||
| }; | ||||
| else | ||||
| errorHandler = e => { | ||||
| chained.Reject(e); | ||||
| return default(T); | ||||
| }; | ||||
|
cin
|
r19 | |||
| AddHandler( | ||||
| resultHandler, | ||||
| errorHandler, | ||||
|
cin
|
r72 | chained.InternalCancel, | ||
| null | ||||
|
cin
|
r19 | ); | ||
|
cin
|
r2 | |||
|
cin
|
r6 | return chained; | ||
| } | ||||
|
cin
|
r26 | public IPromise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper) { | ||
|
cin
|
r6 | return Map(mapper, null); | ||
| } | ||||
|
cin
|
r2 | |||
|
cin
|
r6 | /// <summary> | ||
| /// Сцепляет несколько аснхронных операций. Указанная асинхронная операция будет вызвана после | ||||
| /// выполнения текущей, а результат текущей операции может быть использован для инициализации | ||||
| /// новой операции. | ||||
| /// </summary> | ||||
| /// <typeparam name="TNew">Тип результата указанной асинхронной операции.</typeparam> | ||||
| /// <param name="chained">Асинхронная операция, которая должна будет начаться после выполнения текущей.</param> | ||||
| /// <param name="error">Обработчик ошибки. Данный обработчик получит | ||||
| /// исключение возникшее при выполнении текуещй операции.</param> | ||||
| /// <returns>Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции.</returns> | ||||
|
cin
|
r72 | public IPromise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained, ErrorHandler<T> error) { | ||
|
cin
|
r6 | |||
| // проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно | ||||
| // создать посредника, к которому будут подвызяваться следующие обработчики. | ||||
| // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы | ||||
| // передать через него результаты работы. | ||||
|
cin
|
r10 | var medium = new Promise<TNew>(this, true); | ||
|
cin
|
r2 | |||
|
cin
|
r19 | ResultHandler<T> resultHandler = delegate(T result) { | ||
| if (medium.IsCancelled) | ||||
| return; | ||||
|
cin
|
r10 | |||
|
cin
|
r19 | var promise = chained(result); | ||
|
cin
|
r10 | |||
|
cin
|
r19 | promise.Then( | ||
|
cin
|
r72 | medium.Resolve, | ||
| err => { | ||||
| medium.Reject(err); | ||||
| throw new TransientPromiseException(err); | ||||
| } | ||||
|
cin
|
r19 | ); | ||
|
cin
|
r33 | |||
| // notify chained operation that it's not needed anymore | ||||
| // порядок вызова Then, Cancelled важен, поскольку от этого | ||||
| // зависит IsExclusive | ||||
| medium.Cancelled(() => { | ||||
|
cin
|
r72 | if (promise.IsExclusive) | ||
|
cin
|
r33 | promise.Cancel(); | ||
| }); | ||||
| // внешняя отмена связанной операции рассматривается как ошибка | ||||
| promise.Cancelled(() => medium.Reject(new OperationCanceledException())); | ||||
|
cin
|
r19 | }; | ||
|
cin
|
r72 | ErrorHandler<T> errorHandler = delegate(Exception e) { | ||
| if (error != null) { | ||||
| try { | ||||
| return error(e); | ||||
| } catch (Exception e2) { | ||||
| medium.Reject(e2); | ||||
| return default(T); | ||||
| } | ||||
| } | ||||
|
cin
|
r19 | // в случае ошибки нужно передать исключение дальше по цепочке | ||
| medium.Reject(e); | ||||
|
cin
|
r72 | return default(T); | ||
|
cin
|
r19 | }; | ||
| AddHandler( | ||||
| resultHandler, | ||||
| errorHandler, | ||||
|
cin
|
r72 | medium.InternalCancel, | ||
| null | ||||
|
cin
|
r19 | ); | ||
|
cin
|
r2 | |||
|
cin
|
r6 | return medium; | ||
| } | ||||
|
cin
|
r26 | public IPromise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained) { | ||
|
cin
|
r6 | return Chain(chained, null); | ||
| } | ||||
|
cin
|
r2 | |||
|
cin
|
r26 | public IPromise<T> Cancelled(Action handler) { | ||
|
cin
|
r72 | AddHandler(null, null, handler, null); | ||
|
cin
|
r10 | return this; | ||
| } | ||||
|
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
|
r26 | public IPromise<T> Finally(Action handler) { | ||
|
cin
|
r19 | if (handler == null) | ||
| throw new ArgumentNullException("handler"); | ||||
| AddHandler( | ||||
| x => handler(), | ||||
|
cin
|
r72 | e => { | ||
| handler(); | ||||
| throw new TransientPromiseException(e); | ||||
| }, | ||||
| handler, | ||||
| null | ||||
|
cin
|
r19 | ); | ||
| return this; | ||||
|
cin
|
r10 | } | ||
|
cin
|
r6 | /// <summary> | ||
|
cin
|
r29 | /// Преобразует результат обещания к нужному типу | ||
| /// </summary> | ||||
| /// <typeparam name="T2"></typeparam> | ||||
| /// <returns></returns> | ||||
| public IPromise<T2> Cast<T2>() { | ||||
| return Map(x => (T2)(object)x, null); | ||||
| } | ||||
| /// <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
|
r6 | Anyway(() => evt.Set()); | ||
|
cin
|
r10 | Cancelled(() => 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
|
r72 | void AddHandler(ResultHandler<T> success, ErrorHandler<T> error, Action cancel, Promise<T> medium) { | ||
|
cin
|
r33 | if (success != null || error != null) | ||
| Interlocked.Increment(ref m_childrenCount); | ||||
|
cin
|
r19 | |||
|
cin
|
r72 | var handler = new HandlerDescriptor { | ||
|
cin
|
r19 | resultHandler = success, | ||
| errorHandler = error, | ||||
|
cin
|
r72 | cancellHandler = cancel, | ||
| medium = medium | ||||
|
cin
|
r19 | }; | ||
|
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
|
r27 | protected virtual void InvokeHandler(HandlerDescriptor 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
|
r19 | HandlerDescriptor handler; | ||
| 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) { | ||
| promises[i].Then( | ||||
| x => { | ||||
| result[dest] = x; | ||||
| if (Interlocked.Decrement(ref pending) == 0) | ||||
| promise.Resolve(result); | ||||
| }, | ||||
|
cin
|
r72 | e => { | ||
| promise.Reject(e); | ||||
| return default(T); | ||||
| } | ||||
|
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
|
r66 | IPromise IPromise.Error(ErrorHandler error) { | ||
|
cin
|
r33 | return Error(error); | ||
| } | ||||
|
cin
|
r66 | IPromise IPromise.Anyway(Action handler) { | ||
|
cin
|
r33 | return Anyway(handler); | ||
| } | ||||
|
cin
|
r66 | IPromise IPromise.Finally(Action handler) { | ||
|
cin
|
r33 | return Finally(handler); | ||
| } | ||||
|
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 | } | ||