diff --git a/Implab.Fx/Animation.cs b/Implab.Fx/Animation.cs --- a/Implab.Fx/Animation.cs +++ b/Implab.Fx/Animation.cs @@ -51,7 +51,7 @@ namespace Implab.Fx { var timer = new Timer(m_delay); - timer.AutoReset = true; + timer.AutoReset = false; timer.SynchronizingObject = m_syncronizationObject; timer.Elapsed += new ElapsedEventHandler(timer_Elapsed); diff --git a/Implab.suo b/Implab.suo index b05584cb87294b827c30a9fda45191a622c8d457..61301b443c112c10f3b3ee2fe11cecb25781ac9c GIT binary patch literal 41472 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 diff --git a/Implab/Promise.cs b/Implab/Promise.cs --- a/Implab/Promise.cs +++ b/Implab/Promise.cs @@ -8,348 +8,390 @@ using System.Threading; namespace Implab { - public delegate void ErrorHandler(Exception e); + public delegate void ErrorHandler(Exception e); + + public delegate void ResultHandler(T result); + public delegate TNew ResultMapper(TSrc result); + public delegate Promise ChainedOperation(TSrc result); - public delegate void ResultHandler(T result); - public delegate TNew ResultMapper(TSrc result); - public delegate Promise ChainedOperation(TSrc result); + /// + /// Класс для асинхронного получения результатов. Так называемое "обещание". + /// + /// Тип получаемого результата + /// + /// Сервис при обращении к его методу дает обещаиние о выполнении операции, + /// клиент получив такое обещание может установить ряд обратных вызово для получения + /// событий выполнения обещания, тоесть завершения операции и предоставлении результатов. + /// + /// Обещение может быть как выполнено, так и выполнено с ошибкой. Для подписки на + /// данные события клиент должен использовать методы Then. + /// + /// + /// Сервис, в свою очередь, по окончанию выполнения операции (возможно с ошибкой), + /// использует методы Resolve либо Reject для оповещения клиетна о + /// выполнении обещания. + /// + /// + /// Если сервер успел выполнить обещание еще до того, как клиент на него подписался, + /// то в момент подписки клиента будут вызваны соответсвующие события в синхронном + /// режиме и клиент будет оповещен в любом случае. Иначе, обработчики добавляются в + /// список в порядке подписания и в этом же порядке они будут вызваны при выполнении + /// обещания. + /// + /// + /// Обрабатывая результаты обещания можно преобразовывать результаты либо инициировать + /// связанные асинхронные операции, которые также возвращают обещания. Для этого следует + /// использовать соответствующую форму методе Then. + /// + /// + /// Также хорошим правилом является то, что Resolve и Reject должен вызывать + /// только инициатор обещания иначе могут возникнуть противоречия. + /// + /// + public class Promise { - /// - /// Класс для асинхронного получения результатов. Так называемое "обещание". - /// - /// Тип получаемого результата - /// - /// Сервис при обращении к его методу дает обещаиние о выполнении операции, - /// клиент получив такое обещание может установить ряд обратных вызово для получения - /// событий выполнения обещания, тоесть завершения операции и предоставлении результатов. - /// - /// Обещение может быть как выполнено, так и выполнено с ошибкой. Для подписки на - /// данные события клиент должен использовать методы Then. - /// - /// - /// Сервис, в свою очередь, по окончанию выполнения операции (возможно с ошибкой), - /// использует методы Resolve либо Reject для оповещения клиетна о - /// выполнении обещания. - /// - /// - /// Если сервер успел выполнить обещание еще до того, как клиент на него подписался, - /// то в момент подписки клиента будут вызваны соответсвующие события в синхронном - /// режиме и клиент будет оповещен в любом случае. Иначе, обработчики добавляются в - /// список в порядке подписания и в этом же порядке они будут вызваны при выполнении - /// обещания. - /// - /// - /// Обрабатывая результаты обещания можно преобразовывать результаты либо инициировать - /// связанные асинхронные операции, которые также возвращают обещания. Для этого следует - /// использовать соответствующую форму методе Then. - /// - /// - /// Также хорошим правилом является то, что Resolve и Reject должен вызывать - /// только инициатор обещания иначе могут возникнуть противоречия. - /// - /// - public class Promise { + struct ResultHandlerInfo { + public ResultHandler resultHandler; + public ErrorHandler errorHandler; + } + + enum State { + Unresolved, + Resolving, + Resolved, + Cancelled + } + + LinkedList m_handlersChain = new LinkedList(); + State m_state; + bool m_cancellable; + T m_result; + Exception m_error; + + public Promise() { + m_cancellable = true; + } - struct ResultHandlerInfo { - public ResultHandler resultHandler; - public ErrorHandler errorHandler; - } - - enum State { - Unresolved, - Resolving, - Resolved, - Cancelled - } + /// + /// Событие, возникающее при отмене асинхронной операции. + /// + /// + /// Как правило используется для оповещения объекта, выполняющего асинхронную операцию, о том, что ее следует отменить. + /// + public event EventHandler Cancelled; - LinkedList m_handlersChain = new LinkedList(); - State m_state; - bool m_cancellable; - T m_result; - Exception m_error; + /// + /// Выполняет обещание, сообщая об успешном выполнении. + /// + /// Результат выполнения. + /// Данное обещание уже выполнено + public void Resolve(T result) { + lock (this) { + if (m_state == State.Cancelled) + return; + if (m_state != State.Unresolved) + throw new InvalidOperationException("The promise is already resolved"); + m_result = result; + m_state = State.Resolving; + } - public Promise() { - m_cancellable = true; - } - - /// - /// Событие, возникающее при отмене асинхронной операции. - /// - /// - /// Как правило используется для оповещения объекта, выполняющего асинхронную операцию, о том, что ее следует отменить. - /// - public event EventHandler Cancelled; + ResultHandlerInfo handler; + while (FetchNextHandler(out handler)) + InvokeHandler(handler); + } - /// - /// Выполняет обещание, сообщая об успешном выполнении. - /// - /// Результат выполнения. - /// Данное обещание уже выполнено - public void Resolve(T result) { - lock (this) { - if (m_state == State.Cancelled) - return; - if (m_state != State.Unresolved) - throw new InvalidOperationException("The promise is already resolved"); - m_result = result; - m_state = State.Resolving; - } - - ResultHandlerInfo handler; - while (FetchNextHandler(out handler)) - InvokeHandler(handler); - } + /// + /// Выполняет обещание, сообщая об ошибке + /// + /// Исключение возникшее при выполнении операции + /// Данное обещание уже выполнено + public void Reject(Exception error) { + lock (this) { + if (m_state == State.Cancelled) + return; + if (m_state != State.Unresolved) + throw new InvalidOperationException("The promise is already resolved"); + m_error = error; + m_state = State.Resolving; + } - /// - /// Выполняет обещание, сообщая об ошибке - /// - /// Исключение возникшее при выполнении операции - /// Данное обещание уже выполнено - public void Reject(Exception error) { - lock (this) { - if (m_state == State.Cancelled) - return; - if (m_state != State.Unresolved) - throw new InvalidOperationException("The promise is already resolved"); - m_error = error; - m_state = State.Resolving; - } + ResultHandlerInfo handler; + while (FetchNextHandler(out handler)) + InvokeHandler(handler); + } - ResultHandlerInfo handler; - while (FetchNextHandler(out handler)) - InvokeHandler(handler); - } + /// + /// Отменяет операцию, если это возможно. + /// + /// true Операция была отменена, обработчики не будут вызваны.false отмена не возможна, поскольку обещание уже выполнено и обработчики отработали. + public bool Cancel() { + lock (this) { + if (m_state == State.Unresolved && m_cancellable) { + m_state = State.Cancelled; + EventHandler temp = Cancelled; + + if (temp != null) + temp(this, new EventArgs()); + + return true; + } else + return false; + } + } - /// - /// Отменяет операцию, если это возможно. - /// - /// true Операция была отменена, обработчики не будут вызваны.false отмена не возможна, поскольку обещание уже выполнено и обработчики отработали. - public bool Cancel() { - lock(this) { - if (m_state == State.Unresolved && m_cancellable) { - m_state = State.Cancelled; - EventHandler temp = Cancelled; - - if (temp != null) - temp(this,new EventArgs()); - - return true; - } else - return false; - } - } + /// + /// Добавляет обработчики событий выполнения обещания. + /// + /// Обработчик успешного выполнения обещания. + /// Данному обработчику будет передан результат выполнения операции. + /// Обработчик ошибки. Данный обработчик получит + /// исключение возникшее при выполнении операции. + /// Само обещание + public Promise Then(ResultHandler success, ErrorHandler error) { + if (success == null && error == null) + return this; + + var medium = new Promise(); + + 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); - /// - /// Добавляет обработчики событий выполнения обещания. - /// - /// Обработчик успешного выполнения обещания. - /// Данному обработчику будет передан результат выполнения операции. - /// Обработчик ошибки. Данный обработчик получит - /// исключение возникшее при выполнении операции. - /// Само обещание - public Promise Then(ResultHandler success, ErrorHandler error) { - if (success == null && error == null) - return this; + if (error != null) + handlerInfo.errorHandler = x => { + try { + error(x); + } catch { } + medium.Reject(x); + }; + else + handlerInfo.errorHandler = x => medium.Reject(x); - AddHandler(new ResultHandlerInfo() { - resultHandler = success, - errorHandler = error - }); + AddHandler(handlerInfo); - return this; - } + return medium; + } - public Promise Then(ResultHandler success) { - return Then (success, null); - } + public Promise Then(ResultHandler success) { + return Then(success, null); + } - public Promise Anyway(Action handler) { - if (handler == null) - return this; - AddHandler(new ResultHandlerInfo { - resultHandler = x => handler(), - errorHandler = x => handler() - }); + public Promise Error(ErrorHandler error) { + return Then(null, error); + } - return this; - } + public Promise Anyway(Action handler) { + if (handler == null) + return this; + + var medium = new Promise(); - /// - /// Позволяет преобразовать результат выполения операции к новому типу. - /// - /// Новый тип результата. - /// Преобразование результата к новому типу. - /// Обработчик ошибки. Данный обработчик получит - /// исключение возникшее при выполнении операции. - /// Новое обещание, которое будет выполнено при выполнении исходного обещания. - public Promise Map(ResultMapper mapper, ErrorHandler error) { - if (mapper == null) - throw new ArgumentNullException("mapper"); - - // создаем прицепленное обещание - Promise chained = new Promise(); + AddHandler(new ResultHandlerInfo { + resultHandler = x => { + try { + handler(); + medium.Resolve(x); + } catch (Exception e) { + medium.Reject(e); + } + }, + errorHandler = x => { + try { + handler(); + } catch { } + medium.Reject(x); + } + }); - AddHandler(new ResultHandlerInfo() { - resultHandler = delegate(T result) { - try { - // если преобразование выдаст исключение, то сработает reject сцепленного deferred - chained.Resolve(mapper(result)); - } catch (Exception e) { - chained.Reject(e); - } - }, - errorHandler = delegate(Exception e) { - if (error != null) - error(e); - // в случае ошибки нужно передать исключение дальше по цепочке - chained.Reject(e); - } - }); + return medium; + } - return chained; - } + /// + /// Позволяет преобразовать результат выполения операции к новому типу. + /// + /// Новый тип результата. + /// Преобразование результата к новому типу. + /// Обработчик ошибки. Данный обработчик получит + /// исключение возникшее при выполнении операции. + /// Новое обещание, которое будет выполнено при выполнении исходного обещания. + public Promise Map(ResultMapper mapper, ErrorHandler error) { + if (mapper == null) + throw new ArgumentNullException("mapper"); - public Promise Map(ResultMapper mapper) { - return Map (mapper, null); - } + // создаем прицепленное обещание + Promise chained = new Promise(); - /// - /// Сцепляет несколько аснхронных операций. Указанная асинхронная операция будет вызвана после - /// выполнения текущей, а результат текущей операции может быть использован для инициализации - /// новой операции. - /// - /// Тип результата указанной асинхронной операции. - /// Асинхронная операция, которая должна будет начаться после выполнения текущей. - /// Обработчик ошибки. Данный обработчик получит - /// исключение возникшее при выполнении текуещй операции. - /// Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции. - public Promise Chain(ChainedOperation chained, ErrorHandler error) { + AddHandler(new ResultHandlerInfo() { + resultHandler = delegate(T result) { + try { + // если преобразование выдаст исключение, то сработает reject сцепленного deferred + chained.Resolve(mapper(result)); + } catch (Exception e) { + chained.Reject(e); + } + }, + errorHandler = delegate(Exception e) { + if (error != null) + error(e); + // в случае ошибки нужно передать исключение дальше по цепочке + chained.Reject(e); + } + }); - // проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно - // создать посредника, к которому будут подвызяваться следующие обработчики. - // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы - // передать через него результаты работы. - Promise medium = new Promise(); + return chained; + } + + public Promise Map(ResultMapper mapper) { + return Map(mapper, null); + } - AddHandler(new ResultHandlerInfo() { - resultHandler = delegate(T result) { - try { - chained(result).Then( - x => medium.Resolve(x), - e => medium.Reject(e) - ); - } catch(Exception e) { - // если сцепленное действие выдало исключение вместо обещания, то передаем ошибку по цепочке - medium.Reject(e); - } - }, - errorHandler = delegate(Exception e) { - if (error != null) - error(e); - // в случае ошибки нужно передать исключение дальше по цепочке - medium.Reject(e); - } - }); + /// + /// Сцепляет несколько аснхронных операций. Указанная асинхронная операция будет вызвана после + /// выполнения текущей, а результат текущей операции может быть использован для инициализации + /// новой операции. + /// + /// Тип результата указанной асинхронной операции. + /// Асинхронная операция, которая должна будет начаться после выполнения текущей. + /// Обработчик ошибки. Данный обработчик получит + /// исключение возникшее при выполнении текуещй операции. + /// Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции. + public Promise Chain(ChainedOperation chained, ErrorHandler error) { + + // проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно + // создать посредника, к которому будут подвызяваться следующие обработчики. + // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы + // передать через него результаты работы. + Promise medium = new Promise(); - return medium; - } - - public Promise Chain(ChainedOperation chained) { - return Chain (chained, null); - } + AddHandler(new ResultHandlerInfo() { + resultHandler = delegate(T result) { + try { + chained(result).Then( + x => medium.Resolve(x), + e => medium.Reject(e) + ); + } catch (Exception e) { + // если сцепленное действие выдало исключение вместо обещания, то передаем ошибку по цепочке + medium.Reject(e); + } + }, + errorHandler = delegate(Exception e) { + if (error != null) + error(e); + // в случае ошибки нужно передать исключение дальше по цепочке + medium.Reject(e); + } + }); - /// - /// Дожидается отложенного обещания и в случае успеха, возвращает - /// его, результат, в противном случае бросает исключение. - /// - /// - /// - /// Если ожидание обещания было прервано по таймауту, это не значит, - /// что обещание было отменено или что-то в этом роде, это только - /// означает, что мы его не дождались, однако все зарегистрированные - /// обработчики, как были так остались и они будут вызваны, когда - /// обещание будет выполнено. - /// - /// - /// Такое поведение вполне оправдано поскольку таймаут может истечь - /// в тот момент, когда началась обработка цепочки обработчиков, и - /// к тому же текущее обещание может стоять в цепочке обещаний и его - /// отклонение может привести к непрогнозируемому результату. - /// - /// - /// Время ожидания - /// Результат выполнения обещания - public T Join(int timeout) { - ManualResetEvent evt = new ManualResetEvent(false); - Anyway(() => evt.Set()); + return medium; + } + + public Promise Chain(ChainedOperation chained) { + return Chain(chained, null); + } - if (!evt.WaitOne(timeout, true)) - throw new TimeoutException(); + /// + /// Дожидается отложенного обещания и в случае успеха, возвращает + /// его, результат, в противном случае бросает исключение. + /// + /// + /// + /// Если ожидание обещания было прервано по таймауту, это не значит, + /// что обещание было отменено или что-то в этом роде, это только + /// означает, что мы его не дождались, однако все зарегистрированные + /// обработчики, как были так остались и они будут вызваны, когда + /// обещание будет выполнено. + /// + /// + /// Такое поведение вполне оправдано поскольку таймаут может истечь + /// в тот момент, когда началась обработка цепочки обработчиков, и + /// к тому же текущее обещание может стоять в цепочке обещаний и его + /// отклонение может привести к непрогнозируемому результату. + /// + /// + /// Время ожидания + /// Результат выполнения обещания + public T Join(int timeout) { + ManualResetEvent evt = new ManualResetEvent(false); + Anyway(() => evt.Set()); - if (m_error != null) - throw new TargetInvocationException( m_error ); - else - return m_result; - } + if (!evt.WaitOne(timeout, true)) + throw new TimeoutException(); - public T Join() { - return Join(Timeout.Infinite); - } + if (m_error != null) + throw new TargetInvocationException(m_error); + else + return m_result; + } + + public T Join() { + return Join(Timeout.Infinite); + } - /// - /// Данный метод последовательно извлекает обработчики обещания и когда - /// их больше не осталось - ставит состояние "разрешено". - /// - /// Информация об обработчике - /// Признак того, что еще остались обработчики в очереди - bool FetchNextHandler(out ResultHandlerInfo handler) { - handler = default(ResultHandlerInfo); + /// + /// Данный метод последовательно извлекает обработчики обещания и когда + /// их больше не осталось - ставит состояние "разрешено". + /// + /// Информация об обработчике + /// Признак того, что еще остались обработчики в очереди + bool FetchNextHandler(out ResultHandlerInfo handler) { + handler = default(ResultHandlerInfo); - lock (this) { - Debug.Assert(m_state == State.Resolving); + lock (this) { + Debug.Assert(m_state == State.Resolving); - if (m_handlersChain.Count > 0) { - handler = m_handlersChain.First.Value; - m_handlersChain.RemoveFirst(); - return true; - } else { - m_state = State.Resolved; - return false; - } - } - } + if (m_handlersChain.Count > 0) { + handler = m_handlersChain.First.Value; + m_handlersChain.RemoveFirst(); + return true; + } else { + m_state = State.Resolved; + return false; + } + } + } - void AddHandler(ResultHandlerInfo handler) { - bool invokeRequired = false; + void AddHandler(ResultHandlerInfo handler) { + bool invokeRequired = false; - lock (this) { - if (m_state != State.Resolved) - m_handlersChain.AddLast(handler); - else - invokeRequired = true; - } + lock (this) { + if (m_state != State.Resolved) + m_handlersChain.AddLast(handler); + else + invokeRequired = true; + } - // обработчики не должны блокировать сам объект - if (invokeRequired) - InvokeHandler(handler); - } + // обработчики не должны блокировать сам объект + if (invokeRequired) + InvokeHandler(handler); + } - void InvokeHandler(ResultHandlerInfo handler) { - if (m_error == null) { - try { - if (handler.resultHandler != null) - handler.resultHandler(m_result); - } catch { } - } + void InvokeHandler(ResultHandlerInfo handler) { + if (m_error == null) { + try { + if (handler.resultHandler != null) + handler.resultHandler(m_result); + } catch { } + } - if (m_error != null) { - try { - if (handler.errorHandler !=null) - handler.errorHandler(m_error); - } catch { } - } - } + if (m_error != null) { + try { + if (handler.errorHandler != null) + handler.errorHandler(m_error); + } catch { } + } + } - } + } }