Promise.cs
459 lines
| 20.5 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; | ||||
| namespace Implab { | ||||
|
cin
|
r6 | public delegate void ErrorHandler(Exception e); | ||
|
cin
|
r10 | public delegate void ResultHandler<in T>(T result); | ||
| public delegate TNew ResultMapper<in TSrc, out TNew>(TSrc result); | ||||
| public delegate Promise<TNew> ChainedOperation<in TSrc, TNew>(TSrc result); | ||||
|
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
|
r9 | public class Promise<T> : IPromise { | ||
|
cin
|
r2 | |||
|
cin
|
r6 | struct ResultHandlerInfo { | ||
| public ResultHandler<T> resultHandler; | ||||
| public ErrorHandler errorHandler; | ||||
| } | ||||
|
cin
|
r10 | readonly IPromise m_parent; | ||
|
cin
|
r9 | |||
| LinkedList<ResultHandlerInfo> m_resultHandlers = new LinkedList<ResultHandlerInfo>(); | ||||
| LinkedList<Action> m_cancelHandlers = new LinkedList<Action>(); | ||||
|
cin
|
r10 | readonly object m_lock = new Object(); | ||
| readonly bool m_cancellable; | ||||
| int m_childrenCount = 0; | ||||
|
cin
|
r9 | |||
|
cin
|
r7 | PromiseState m_state; | ||
|
cin
|
r6 | T m_result; | ||
| Exception m_error; | ||||
|
cin
|
r9 | |||
|
cin
|
r6 | public Promise() { | ||
| m_cancellable = true; | ||||
| } | ||||
|
cin
|
r2 | |||
|
cin
|
r9 | public Promise(IPromise parent, bool cancellable) { | ||
|
cin
|
r7 | m_cancellable = cancellable; | ||
| m_parent = parent; | ||||
|
cin
|
r10 | if (parent != null) | ||
| parent.HandleCancelled(InternalCancel); | ||||
|
cin
|
r7 | } | ||
|
cin
|
r10 | void InternalCancel() { | ||
| // don't try to cancel parent :) | ||||
| Cancel(false); | ||||
| } | ||||
|
cin
|
r2 | |||
|
cin
|
r6 | /// <summary> | ||
| /// Выполняет обещание, сообщая об успешном выполнении. | ||||
| /// </summary> | ||||
| /// <param name="result">Результат выполнения.</param> | ||||
| /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception> | ||||
| public void Resolve(T result) { | ||||
| lock (this) { | ||||
|
cin
|
r7 | if (m_state == PromiseState.Cancelled) | ||
|
cin
|
r6 | return; | ||
|
cin
|
r7 | if (m_state != PromiseState.Unresolved) | ||
|
cin
|
r6 | throw new InvalidOperationException("The promise is already resolved"); | ||
| m_result = result; | ||||
|
cin
|
r7 | m_state = PromiseState.Resolved; | ||
|
cin
|
r6 | } | ||
|
cin
|
r2 | |||
|
cin
|
r10 | OnStateChanged(); | ||
|
cin
|
r6 | } | ||
|
cin
|
r2 | |||
|
cin
|
r6 | /// <summary> | ||
| /// Выполняет обещание, сообщая об ошибке | ||||
| /// </summary> | ||||
| /// <param name="error">Исключение возникшее при выполнении операции</param> | ||||
| /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception> | ||||
| public void Reject(Exception error) { | ||||
| lock (this) { | ||||
|
cin
|
r7 | if (m_state == PromiseState.Cancelled) | ||
|
cin
|
r6 | return; | ||
|
cin
|
r7 | if (m_state != PromiseState.Unresolved) | ||
|
cin
|
r6 | throw new InvalidOperationException("The promise is already resolved"); | ||
| m_error = error; | ||||
|
cin
|
r7 | m_state = PromiseState.Rejected; | ||
|
cin
|
r6 | } | ||
|
cin
|
r2 | |||
|
cin
|
r10 | OnStateChanged(); | ||
|
cin
|
r6 | } | ||
|
cin
|
r2 | |||
|
cin
|
r6 | /// <summary> | ||
| /// Отменяет операцию, если это возможно. | ||||
| /// </summary> | ||||
| /// <returns><c>true</c> Операция была отменена, обработчики не будут вызваны.<c>false</c> отмена не возможна, поскольку обещание уже выполнено и обработчики отработали.</returns> | ||||
| public bool Cancel() { | ||||
|
cin
|
r9 | return Cancel(true); | ||
|
cin
|
r6 | } | ||
|
cin
|
r2 | |||
|
cin
|
r10 | 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; | ||||
| } | ||||
|
cin
|
r6 | /// <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 => { | ||||
|
cin
|
r10 | success(x); | ||
| medium.Resolve(x); | ||||
|
cin
|
r6 | }; | ||
| else | ||||
|
cin
|
r10 | handlerInfo.resultHandler = medium.Resolve; | ||
|
cin
|
r2 | |||
|
cin
|
r6 | if (error != null) | ||
| handlerInfo.errorHandler = x => { | ||||
| try { | ||||
| error(x); | ||||
| } catch { } | ||||
| medium.Reject(x); | ||||
| }; | ||||
| else | ||||
|
cin
|
r10 | handlerInfo.errorHandler = medium.Reject; | ||
|
cin
|
r2 | |||
|
cin
|
r6 | AddHandler(handlerInfo); | ||
|
cin
|
r2 | |||
|
cin
|
r6 | return medium; | ||
| } | ||||
|
cin
|
r2 | |||
|
cin
|
r6 | public Promise<T> Then(ResultHandler<T> success) { | ||
| return Then(success, null); | ||||
| } | ||||
|
cin
|
r2 | |||
|
cin
|
r6 | public Promise<T> Error(ErrorHandler error) { | ||
| return Then(null, error); | ||||
| } | ||||
|
cin
|
r2 | |||
|
cin
|
r6 | public Promise<T> Anyway(Action handler) { | ||
| if (handler == null) | ||||
| return this; | ||||
| var medium = new Promise<T>(); | ||||
|
cin
|
r2 | |||
|
cin
|
r6 | AddHandler(new ResultHandlerInfo { | ||
| resultHandler = x => { | ||||
|
cin
|
r10 | // to avoid handler being called multiple times we handle exception by ourselfs | ||
|
cin
|
r6 | try { | ||
| handler(); | ||||
| medium.Resolve(x); | ||||
| } catch (Exception e) { | ||||
| medium.Reject(e); | ||||
| } | ||||
| }, | ||||
| errorHandler = x => { | ||||
| try { | ||||
| handler(); | ||||
| } catch { } | ||||
| medium.Reject(x); | ||||
| } | ||||
| }); | ||||
|
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> | ||||
| public Promise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler error) { | ||||
| if (mapper == null) | ||||
| throw new ArgumentNullException("mapper"); | ||||
|
cin
|
r2 | |||
|
cin
|
r6 | // создаем прицепленное обещание | ||
|
cin
|
r10 | var chained = new Promise<TNew>(); | ||
|
cin
|
r2 | |||
|
cin
|
r6 | AddHandler(new ResultHandlerInfo() { | ||
|
cin
|
r10 | resultHandler = result => chained.Resolve(mapper(result)), | ||
|
cin
|
r6 | errorHandler = delegate(Exception e) { | ||
| if (error != null) | ||||
|
cin
|
r10 | try { | ||
| error(e); | ||||
| } catch { } | ||||
|
cin
|
r6 | // в случае ошибки нужно передать исключение дальше по цепочке | ||
| chained.Reject(e); | ||||
| } | ||||
| }); | ||||
|
cin
|
r2 | |||
|
cin
|
r6 | return chained; | ||
| } | ||||
| public Promise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper) { | ||||
| return Map(mapper, null); | ||||
| } | ||||
|
cin
|
r2 | |||
|
cin
|
r6 | /// <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) { | ||||
| // проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно | ||||
| // создать посредника, к которому будут подвызяваться следующие обработчики. | ||||
| // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы | ||||
| // передать через него результаты работы. | ||||
|
cin
|
r10 | var medium = new Promise<TNew>(this, true); | ||
|
cin
|
r2 | |||
|
cin
|
r10 | AddHandler(new ResultHandlerInfo { | ||
|
cin
|
r6 | resultHandler = delegate(T result) { | ||
|
cin
|
r10 | if (medium.State == PromiseState.Cancelled) | ||
| return; | ||||
| var promise = chained(result); | ||||
| // notify chained operation that it's not needed | ||||
| medium.Cancelled(() => promise.Cancel()); | ||||
| promise.Then( | ||||
| medium.Resolve, | ||||
| medium.Reject | ||||
| ); | ||||
|
cin
|
r6 | }, | ||
| errorHandler = delegate(Exception e) { | ||||
| if (error != null) | ||||
| error(e); | ||||
| // в случае ошибки нужно передать исключение дальше по цепочке | ||||
| medium.Reject(e); | ||||
| } | ||||
| }); | ||||
|
cin
|
r2 | |||
|
cin
|
r6 | return medium; | ||
| } | ||||
| public Promise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained) { | ||||
| return Chain(chained, null); | ||||
| } | ||||
|
cin
|
r2 | |||
|
cin
|
r10 | 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); | ||||
| } | ||||
|
cin
|
r6 | /// <summary> | ||
| /// Дожидается отложенного обещания и в случае успеха, возвращает | ||||
| /// его, результат, в противном случае бросает исключение. | ||||
| /// </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
|
r10 | switch (State) { | ||
| case PromiseState.Resolved: | ||||
| return m_result; | ||||
| case PromiseState.Cancelled: | ||||
| throw new OperationCanceledException(); | ||||
| case PromiseState.Rejected: | ||||
| throw new TargetInvocationException(m_error); | ||||
| default: | ||||
| throw new ApplicationException(String.Format("Invalid promise state {0}", State)); | ||||
| } | ||||
|
cin
|
r6 | } | ||
| public T Join() { | ||||
| return Join(Timeout.Infinite); | ||||
| } | ||||
|
cin
|
r2 | |||
|
cin
|
r6 | void AddHandler(ResultHandlerInfo handler) { | ||
| bool invokeRequired = false; | ||||
|
cin
|
r2 | |||
|
cin
|
r10 | lock (m_lock) { | ||
| m_childrenCount++; | ||||
| if (m_state == PromiseState.Unresolved) { | ||||
|
cin
|
r9 | m_resultHandlers.AddLast(handler); | ||
|
cin
|
r10 | } else | ||
|
cin
|
r6 | invokeRequired = true; | ||
| } | ||||
|
cin
|
r2 | |||
|
cin
|
r6 | // обработчики не должны блокировать сам объект | ||
| if (invokeRequired) | ||||
| InvokeHandler(handler); | ||||
| } | ||||
|
cin
|
r2 | |||
|
cin
|
r6 | void InvokeHandler(ResultHandlerInfo handler) { | ||
|
cin
|
r10 | 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; | ||||
| case PromiseState.Rejected: | ||||
| try { | ||||
| if (handler.errorHandler != null) | ||||
| handler.errorHandler(m_error); | ||||
| } catch { } | ||||
| break; | ||||
| default: | ||||
| // do nothing | ||||
| return; | ||||
|
cin
|
r6 | } | ||
| } | ||||
|
cin
|
r2 | |||
|
cin
|
r9 | |||
| 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; | ||||
| } | ||||
| } | ||||
|
cin
|
r10 | if (result) | ||
| OnStateChanged(); | ||||
|
cin
|
r9 | |||
|
cin
|
r10 | if (dependencies && m_parent != null && m_parent.IsExclusive) { | ||
| m_parent.Cancel(true); | ||||
|
cin
|
r9 | } | ||
| return result; | ||||
| } | ||||
|
cin
|
r6 | } | ||
|
cin
|
r2 | } | ||