# HG changeset patch # User cin # Date 1377781424 -14400 # Node ID aa367305156b01c12b4a00e6ee295bd716edf191 # Parent 6fb3b01ee971a8704df6f0e7a46ed584c2eda4b7 small fixes diff -r 6fb3b01ee971 -r aa367305156b Implab/Implab.csproj --- a/Implab/Implab.csproj Tue Aug 27 08:28:42 2013 +0400 +++ b/Implab/Implab.csproj Thu Aug 29 17:03:44 2013 +0400 @@ -1,43 +1,44 @@ - - - - Debug - AnyCPU - 10.0.0 - 2.0 - {99B95D0D-9CF9-4F70-8ADF-F4D0AA5CB0D9} - Library - Implab - Implab - - - true - full - false - bin\Debug - DEBUG; - prompt - 4 - false - - - full - true - bin\Release - prompt - 4 - false - - - - - - - - - - - - - + + + + Debug + AnyCPU + 10.0.0 + 2.0 + {99B95D0D-9CF9-4F70-8ADF-F4D0AA5CB0D9} + Library + Implab + Implab + + + true + full + false + bin\Debug + DEBUG; + prompt + 4 + false + + + full + true + bin\Release + prompt + 4 + false + + + + + + + + + + + + + + \ No newline at end of file diff -r 6fb3b01ee971 -r aa367305156b Implab/Promise.cs --- a/Implab/Promise.cs Tue Aug 27 08:28:42 2013 +0400 +++ b/Implab/Promise.cs Thu Aug 29 17:03:44 2013 +0400 @@ -1,355 +1,355 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Reflection; -using System.Text; -using System.Diagnostics; -using System.Threading; - -namespace Implab { - - public delegate void ErrorHandler(Exception e); - - public delegate void ResultHandler(T result); - public delegate TNew ResultMapper(TSrc result); - public delegate Promise ChainedOperation(TSrc result); - - ///

- /// Класс для асинхронного получения результатов. Так называемое "обещание". - ///

- /// Тип получаемого результата - /// - /// Сервис при обращении к его методу дает обещаиние о выполнении операции, - /// клиент получив такое обещание может установить ряд обратных вызово для получения - /// событий выполнения обещания, тоесть завершения операции и предоставлении результатов. - /// - /// Обещение может быть как выполнено, так и выполнено с ошибкой. Для подписки на - /// данные события клиент должен использовать методы 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; - } - - ///

- /// Событие, возникающее при отмене асинхронной операции. - ///

- /// - /// Как правило используется для оповещения объекта, выполняющего асинхронную операцию, о том, что ее следует отменить. - /// - public event EventHandler Cancelled; - - ///

- /// Выполняет обещание, сообщая об успешном выполнении. - ///

- /// Результат выполнения. - /// Данное обещание уже выполнено - 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; - } - - ResultHandlerInfo handler; - while (FetchNextHandler(out handler)) - InvokeHandler(handler); - } - - ///

- /// Отменяет операцию, если это возможно. - ///

- /// true Операция была отменена, обработчики не будут вызваны.false отмена не возможна, поскольку обещание уже выполнено и обработчики отработали. - public bool Cancel() { - lock(this) { - if (m_state == State.Unresolved && m_cancellable) { +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using System.Text; +using System.Diagnostics; +using System.Threading; + +namespace Implab { + + public delegate void ErrorHandler(Exception e); + + public delegate void ResultHandler(T result); + public delegate TNew ResultMapper(TSrc result); + public delegate Promise ChainedOperation(TSrc result); + + ///

+ /// Класс для асинхронного получения результатов. Так называемое "обещание". + ///

+ /// Тип получаемого результата + /// + /// Сервис при обращении к его методу дает обещаиние о выполнении операции, + /// клиент получив такое обещание может установить ряд обратных вызово для получения + /// событий выполнения обещания, тоесть завершения операции и предоставлении результатов. + /// + /// Обещение может быть как выполнено, так и выполнено с ошибкой. Для подписки на + /// данные события клиент должен использовать методы 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; + } + + ///

+ /// Событие, возникающее при отмене асинхронной операции. + ///

+ /// + /// Как правило используется для оповещения объекта, выполняющего асинхронную операцию, о том, что ее следует отменить. + /// + public event EventHandler Cancelled; + + ///

+ /// Выполняет обещание, сообщая об успешном выполнении. + ///

+ /// Результат выполнения. + /// Данное обещание уже выполнено + 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; + } + + 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; - } - } - - ///

- /// Добавляет обработчики событий выполнения обещания. - ///

- /// Обработчик успешного выполнения обещания. - /// Данному обработчику будет передан результат выполнения операции. - /// Обработчик ошибки. Данный обработчик получит - /// исключение возникшее при выполнении операции. - /// Само обещание - public Promise Then(ResultHandler success, ErrorHandler error) { - if (success == null && error == null) - return this; - - AddHandler(new ResultHandlerInfo() { - resultHandler = success, - errorHandler = error - }); - - return this; - } - - 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() - }); - - return this; - } - - ///

- /// Позволяет преобразовать результат выполения операции к новому типу. - ///

- /// Новый тип результата. - /// Преобразование результата к новому типу. - /// Обработчик ошибки. Данный обработчик получит - /// исключение возникшее при выполнении операции. - /// Новое обещание, которое будет выполнено при выполнении исходного обещания. - public Promise Map(ResultMapper mapper, ErrorHandler error) { - if (mapper == null) - throw new ArgumentNullException("mapper"); - - // создаем прицепленное обещание - Promise chained = new Promise(); - - 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 chained; - } - - public Promise Map(ResultMapper mapper) { - return Map (mapper, null); - } - - ///

- /// Сцепляет несколько аснхронных операций. Указанная асинхронная операция будет вызвана после - /// выполнения текущей, а результат текущей операции может быть использован для инициализации - /// новой операции. - ///

- /// Тип результата указанной асинхронной операции. - /// Асинхронная операция, которая должна будет начаться после выполнения текущей. - /// Обработчик ошибки. Данный обработчик получит - /// исключение возникшее при выполнении текуещй операции. - /// Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции. - public Promise Chain(ChainedOperation chained, ErrorHandler error) { - - // проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно - // создать посредника, к которому будут подвызяваться следующие обработчики. - // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы - // передать через него результаты работы. - Promise medium = new Promise(); - - 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); - } - }); - - return medium; - } - - public Promise Chain(ChainedOperation chained) { - return Chain (chained, null); - } - - ///

- /// Дожидается отложенного обещания и в случае успеха, возвращает - /// его, результат, в противном случае бросает исключение. - ///

- /// - /// - /// Если ожидание обещания было прервано по таймауту, это не значит, - /// что обещание было отменено или что-то в этом роде, это только - /// означает, что мы его не дождались, однако все зарегистрированные - /// обработчики, как были так остались и они будут вызваны, когда - /// обещание будет выполнено. - /// - /// - /// Такое поведение вполне оправдано поскольку таймаут может истечь - /// в тот момент, когда началась обработка цепочки обработчиков, и - /// к тому же текущее обещание может стоять в цепочке обещаний и его - /// отклонение может привести к непрогнозируемому результату. - /// - /// - /// Время ожидания - /// Результат выполнения обещания - public T Join(int timeout) { - ManualResetEvent evt = new ManualResetEvent(false); - Anyway(() => evt.Set()); - - if (!evt.WaitOne(timeout, true)) - throw new TimeoutException(); - - 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); - - 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; - } - } - } - - void AddHandler(ResultHandlerInfo handler) { - bool invokeRequired = false; - - lock (this) { - if (m_state != State.Resolved) - m_handlersChain.AddLast(handler); - else - invokeRequired = true; - } - - // обработчики не должны блокировать сам объект - if (invokeRequired) - InvokeHandler(handler); - } - - 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 { } - } - } - - - } -} + + return true; + } else + return false; + } + } + + ///

+ /// Добавляет обработчики событий выполнения обещания. + ///

+ /// Обработчик успешного выполнения обещания. + /// Данному обработчику будет передан результат выполнения операции. + /// Обработчик ошибки. Данный обработчик получит + /// исключение возникшее при выполнении операции. + /// Само обещание + public Promise Then(ResultHandler success, ErrorHandler error) { + if (success == null && error == null) + return this; + + AddHandler(new ResultHandlerInfo() { + resultHandler = success, + errorHandler = error + }); + + return this; + } + + 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() + }); + + return this; + } + + ///

+ /// Позволяет преобразовать результат выполения операции к новому типу. + ///

+ /// Новый тип результата. + /// Преобразование результата к новому типу. + /// Обработчик ошибки. Данный обработчик получит + /// исключение возникшее при выполнении операции. + /// Новое обещание, которое будет выполнено при выполнении исходного обещания. + public Promise Map(ResultMapper mapper, ErrorHandler error) { + if (mapper == null) + throw new ArgumentNullException("mapper"); + + // создаем прицепленное обещание + Promise chained = new Promise(); + + 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 chained; + } + + public Promise Map(ResultMapper mapper) { + return Map (mapper, null); + } + + ///

+ /// Сцепляет несколько аснхронных операций. Указанная асинхронная операция будет вызвана после + /// выполнения текущей, а результат текущей операции может быть использован для инициализации + /// новой операции. + ///

+ /// Тип результата указанной асинхронной операции. + /// Асинхронная операция, которая должна будет начаться после выполнения текущей. + /// Обработчик ошибки. Данный обработчик получит + /// исключение возникшее при выполнении текуещй операции. + /// Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции. + public Promise Chain(ChainedOperation chained, ErrorHandler error) { + + // проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно + // создать посредника, к которому будут подвызяваться следующие обработчики. + // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы + // передать через него результаты работы. + Promise medium = new Promise(); + + 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); + } + }); + + return medium; + } + + public Promise Chain(ChainedOperation chained) { + return Chain (chained, null); + } + + ///

+ /// Дожидается отложенного обещания и в случае успеха, возвращает + /// его, результат, в противном случае бросает исключение. + ///

+ /// + /// + /// Если ожидание обещания было прервано по таймауту, это не значит, + /// что обещание было отменено или что-то в этом роде, это только + /// означает, что мы его не дождались, однако все зарегистрированные + /// обработчики, как были так остались и они будут вызваны, когда + /// обещание будет выполнено. + /// + /// + /// Такое поведение вполне оправдано поскольку таймаут может истечь + /// в тот момент, когда началась обработка цепочки обработчиков, и + /// к тому же текущее обещание может стоять в цепочке обещаний и его + /// отклонение может привести к непрогнозируемому результату. + /// + /// + /// Время ожидания + /// Результат выполнения обещания + public T Join(int timeout) { + ManualResetEvent evt = new ManualResetEvent(false); + Anyway(() => evt.Set()); + + if (!evt.WaitOne(timeout, true)) + throw new TimeoutException(); + + 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); + + 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; + } + } + } + + void AddHandler(ResultHandlerInfo handler) { + bool invokeRequired = false; + + lock (this) { + if (m_state != State.Resolved) + m_handlersChain.AddLast(handler); + else + invokeRequired = true; + } + + // обработчики не должны блокировать сам объект + if (invokeRequired) + InvokeHandler(handler); + } + + 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 { } + } + } + + + } +} diff -r 6fb3b01ee971 -r aa367305156b Implab/Safe.cs --- a/Implab/Safe.cs Tue Aug 27 08:28:42 2013 +0400 +++ b/Implab/Safe.cs Thu Aug 29 17:03:44 2013 +0400 @@ -7,11 +7,12 @@ { public static class Safe { - public static void Dispose(ref T obj) where T : IDisposable + public static void Dispose(ref T obj) where T : class { - if (obj != null) + var disp = obj as IDisposable; + if (disp != null) { - obj.Dispose(); + disp.Dispose(); obj = default(T); } }