pub/ImplabNet: Implab/PromiseT.cs comparison

comparison Implab/PromiseT.cs @ 138:f75cfa58e3d4 v2

added ICancellable.Cancel(Exception) to allow specify the reason of cancellation

author	cin
date	Tue, 17 Feb 2015 18:16:26 +0300
parents	656815cb7147
children	8c0b95069066

comparison

equal deleted inserted replaced

-:238e15580926
+:f75cfa58e3d4
 /// только инициатор обещания иначе могут возникнуть противоречия.
 /// </para>
 /// </remarks>
 public class Promise<T> : AbstractPromise<IDeferred<T>>, IPromise<T>, IDeferred<T> {
-class StubDeferred : IDeferred<T> {
+class StubDeferred : IDeferred, IDeferred<T> {
 public static readonly StubDeferred instance = new StubDeferred();
 StubDeferred() {
 }
 #region IDeferred implementation
 public void Resolve(T value) {
 }
+public void Resolve() {
+}
 public void Reject(Exception error) {
 }
 #endregion
 #region ICancellable implementation
 public void Cancel() {
+}
+public void Cancel(Exception reason) {
 }
 #endregion
 }
 class RemapDescriptor<T2> : IDeferred<T> {
 readonly Func<T,T2> m_remap;
-readonly Func<Exception,T2> m_failed;
+readonly Func<Exception, T2> m_failed;
-readonly Func<T2> m_cancel;
+readonly Func<Exception, T2> m_cancel;
 readonly IDeferred<T2> m_deferred;
-public RemapDescriptor(Func<T,T2> remap, Func<Exception,T2> failed, Func<T2> cancel, IDeferred<T2> deferred ) {
+public RemapDescriptor(Func<T,T2> remap, Func<Exception,T2> failed, Func<Exception, T2> cancel, IDeferred<T2> deferred ) {
 Debug.Assert(deferred != null);
 m_remap = remap;
 m_failed = failed;
 m_cancel = cancel;
 m_deferred = deferred;
 #endregion
 #region ICancellable implementation
+public void Cancel(Exception reason) {
+if (m_cancel != null) {
+try {
+m_deferred.Resolve(m_cancel(reason));
+} catch (Exception ex) {
+Reject(ex);
+}
+} else {
+m_deferred.Cancel(reason);
+}
+}
 public void Cancel() {
-if (m_cancel != null) {
+Cancel(null);
-try {
+}
-m_deferred.Resolve(m_cancel());
-} catch (Exception ex) {
-Reject(ex);
-}
-} else {
-m_deferred.Cancel();
-}
-}
 #endregion
 }
 class ListenerDescriptor : IDeferred<T> {
 readonly Action m_handler;
 #endregion
 #region ICancellable implementation
 public void Cancel() {
+Cancel(null);
+}
+public void Cancel(Exception reason) {
 if (m_events.HasFlag(PromiseEventType.Cancelled)){
 try {
 m_handler();
 // Analysis disable once EmptyGeneralCatchClause
 } catch {
 }
 class ValueEventDescriptor : IDeferred<T> {
 readonly Action<T> m_success;
 readonly Action<Exception> m_failed;
-readonly Action m_cancelled;
+readonly Action<Exception> m_cancelled;
 readonly IDeferred<T> m_deferred;
-public ValueEventDescriptor(Action<T> success, Action<Exception> failed, Action cancelled, IDeferred<T> deferred) {
+public ValueEventDescriptor(Action<T> success, Action<Exception> failed, Action<Exception> cancelled, IDeferred<T> deferred) {
 Debug.Assert(deferred != null);
 m_success = success;
 m_failed = failed;
 m_cancelled = cancelled;
 #endregion
 #region ICancellable implementation
+public void Cancel(Exception reason) {
+if (m_cancelled != null) {
+try {
+m_cancelled(reason);
+m_deferred.Resolve(default(T));
+} catch (Exception ex) {
+Reject(ex);
+}
+} else {
+m_deferred.Cancel(reason);
+}
+}
 public void Cancel() {
-if (m_cancelled != null) {
+Cancel(null);
-try {
-m_cancelled();
-m_deferred.Resolve(default(T));
-} catch(Exception ex) {
-Reject(ex);
-}
-} else {
-m_deferred.Cancel();
-}
 }
 #endregion
 }
 public class EventDescriptor : IDeferred<T> {
 readonly Action m_success;
 readonly Action<Exception> m_failed;
-readonly Action m_cancelled;
+readonly Action<Exception> m_cancelled;
-readonly IDeferred<T> m_deferred;
+readonly IDeferred m_deferred;
-public EventDescriptor(Action success, Action<Exception> failed, Action cancelled, IDeferred<T> deferred) {
+public EventDescriptor(Action success, Action<Exception> failed, Action<Exception> cancelled, IDeferred deferred) {
 Debug.Assert(deferred != null);
 m_success = success;
 m_failed = failed;
 m_cancelled = cancelled;
 public void Resolve(T value) {
 if (m_success != null) {
 try {
 m_success();
-m_deferred.Resolve(value);
+m_deferred.Resolve();
 } catch (Exception ex) {
 Reject(ex);
 }
 }
 }
 public void Reject(Exception error) {
 if (m_failed != null) {
 try {
 m_failed(error);
-m_deferred.Resolve(default(T));
+m_deferred.Resolve();
-}catch (Exception ex)
+} catch (Exception ex) {
-{
 m_deferred.Reject(ex);
 }
 } else {
 m_deferred.Reject(error);
 }
 }
 #endregion
 #region ICancellable implementation
+public void Cancel(Exception reason) {
+if (m_cancelled != null) {
+try {
+m_cancelled(reason);
+m_deferred.Resolve();
+} catch (Exception ex) {
+Reject(ex);
+}
+} else {
+m_deferred.Cancel(reason);
+}
+}
 public void Cancel() {
-if (m_cancelled != null) {
+Cancel(null);
-try {
-m_cancelled();
-m_deferred.Resolve(default(T));
-} catch (Exception ex) {
-Reject(ex);
-}
-} else {
-m_deferred.Cancel();
-}
 }
 #endregion
 }
 public new T Join(int timeout) {
 WaitResult(timeout);
 return m_result;
 }
-public IPromise<T> On(Action<T> success, Action<Exception> error, Action cancel) {
+public IPromise<T> On(Action<T> success, Action<Exception> error, Action<Exception> cancel) {
 AddHandler(new ValueEventDescriptor(success, error, cancel, StubDeferred.instance));
 return this;
 }
 public IPromise<T> On(Action<T> success, Action<Exception> error) {
 public IPromise<T> On(Action handler, PromiseEventType events) {
 Listen(events, handler);
 return this;
 }
-public IPromise<T2> Then<T2>(Func<T, T2> mapper, Func<Exception, T2> error, Func<T2> cancel) {
+public IPromise<T2> Then<T2>(Func<T, T2> mapper, Func<Exception, T2> error, Func<Exception, T2> cancel) {
 var promise = new Promise<T2>();
 if (mapper != null)
-promise.On(Cancel, PromiseEventType.Cancelled);
+promise.On((Action)null, null, Cancel);
 AddHandler(new RemapDescriptor<T2>(mapper, error, cancel, promise));
 return promise;
 }
 public IPromise<T2> Then<T2>(Func<T, T2> mapper, Func<Exception, T2> error) {
 var promise = new Promise<T2>();
 if (mapper != null)
-promise.On(Cancel, PromiseEventType.Cancelled);
+promise.On((Action)null, null, Cancel);
 AddHandler(new RemapDescriptor<T2>(mapper, error, null, promise));
 return promise;
 }
 public IPromise<T2> Then<T2>(Func<T, T2> mapper) {
 var promise = new Promise<T2>();
 if (mapper != null)
-promise.On(Cancel, PromiseEventType.Cancelled);
+promise.On((Action)null, null, Cancel);
 AddHandler(new RemapDescriptor<T2>(mapper, null, null, promise));
 return promise;
 }
-public IPromise<T2> Chain<T2>(Func<T, IPromise<T2>> chained, Func<Exception, IPromise<T2>> error, Func<IPromise<T2>> cancel) {
+public IPromise<T2> Chain<T2>(Func<T, IPromise<T2>> chained, Func<Exception, IPromise<T2>> error, Func<Exception, IPromise<T2>> cancel) {
 // this promise will be resolved when an asyc operation is started
 var promise = new Promise<IPromise<T2>>();
 AddHandler(new RemapDescriptor<IPromise<T2>>(
 chained,
 static void ConnectPromise<T2>(IPromise<T2> result, Promise<T2> medium) {
 if (result != null) {
 result.On(
 medium.Resolve,
 medium.Reject,
-() => medium.Reject(new OperationCanceledException())
+medium.Cancel
 );
 medium.On(result.Cancel, PromiseEventType.Cancelled);
 } else {
 medium.Reject(
 new NullReferenceException(
 public IPromise<T2> Chain<T2>(Func<T, IPromise<T2>> chained) {
 return Chain(chained, null, null);
 }
-public IPromise<T2> Error<T2>(Func<Exception, T2> error) {
+public IPromise Then(Action success, Action<Exception> error, Action<Exception> cancel) {
-var promise = new Promise<T2>();
+var promise = new Promise();
-if (error != null)
-On(
-(Action<T>)null,
-ex => {
-try {
-promise.Resolve(error(ex));
-} catch (Exception ex2) {
-promise.Reject(ex2);
-}
-}
-);
-else
-Listen(PromiseEventType.Error, () => promise.Resolve(default(T2)));
-return promise;
-}
-public IPromise<T2> Cancelled<T2>(Func<T2> handler) {
-var promise = new Promise<T2>();
-if (handler != null)
-On(
-(Action<T>)null,
-null,
-() => {
-try {
-promise.Resolve(handler());
-} catch (Exception ex) {
-promise.Reject(ex);
-}
-});
-else
-Listen(PromiseEventType.Cancelled, () => promise.Resolve(default(T2)));
-return promise;
-}
-public IPromise Then(Action success, Action<Exception> error, Action cancel) {
-var promise = new Promise<T>();
 if (success != null)
-promise.On(Cancel, PromiseEventType.Cancelled);
+promise.On(null, null, Cancel);
 AddHandler(new EventDescriptor(success, error, cancel, promise));
 return promise;
 }
 public IPromise Then(Action success) {
 return Then(success, null, null);
 }
-public IPromise Chain(Func<IPromise> chained, Func<Exception, IPromise> error, Func<IPromise> cancel) {
+public IPromise Chain(Func<IPromise> chained, Func<Exception, IPromise> error, Func<Exception, IPromise> cancel) {
 var promise = new Promise<IPromise>();
 AddHandler(
 new RemapDescriptor<IPromise>(
 x => chained(),
 )
 );
 var medium = new Promise();
 if (chained != null)
-medium.On(Cancel, PromiseEventType.Cancelled);
+medium.On(null, null, Cancel);
 promise.On(
 result => ConnectPromise(result, medium),
 medium.Reject,
 medium.Cancel
 static void ConnectPromise(IPromise result, Promise medium) {
 if (result != null) {
 result.On(
 medium.Resolve,
 medium.Reject,
-() => medium.Reject(new OperationCanceledException())
+medium.Cancel
 );
-medium.On(result.Cancel, PromiseEventType.Cancelled);
+medium.On(null, null, result.Cancel);
 } else {
 medium.Reject(
 new NullReferenceException(
 "The chained asynchronous operation returned" +
 " 'null' where the promise instance is expected"
 public IPromise Chain(Func<IPromise> chained) {
 return Chain(chained, null, null);
 }
-public IPromise On(Action success, Action<Exception> error, Action cancel) {
+public IPromise On(Action success, Action<Exception> error, Action<Exception> cancel) {
 AddHandler(new EventDescriptor(success,error,cancel, StubDeferred.instance));
 return this;
 }
 public IPromise On(Action success, Action<Exception> error) {
 IPromise IPromise.On(Action handler, PromiseEventType events) {
 Listen(events,handler);
 return this;
 }
-public IPromise Error(Action<Exception> error) {
-var promise = new Promise();
-if (error != null)
-On(
-(Action<T>)null,
-ex => {
-try {
-error(ex);
-promise.Resolve();
-} catch (Exception ex2) {
-promise.Reject(ex2);
-}
-});
-else
-Listen(PromiseEventType.Error, promise.Resolve);
-return promise;
-}
-public IPromise Cancelled(Action handler) {
-var promise = new Promise();
-if (handler != null)
-On(
-(Action<T>)null,
-null,
-() => {
-try {
-handler();
-promise.Resolve();
-} catch (Exception ex) {
-promise.Reject(ex);
-}
-});
-else
-Listen(PromiseEventType.Cancelled, promise.Resolve);
-return promise;
-}
 public IPromise<T2> Cast<T2>() {
 return (IPromise<T2>)this;
 }
 #region implemented abstract members of AbstractPromise
 protected override void SignalError(IDeferred<T> handler, Exception error) {
 handler.Reject(error);
 }
-protected override void SignalCancelled(IDeferred<T> handler) {
+protected override void SignalCancelled(IDeferred<T> handler, Exception reason) {
-handler.Cancel();
+handler.Cancel(reason);
 }
 protected override void Listen(PromiseEventType events, Action handler) {
 if (handler != null)
 AddHandler(new ListenerDescriptor(handler, events));

Mercurial > pub > ImplabNet

comparison Implab/PromiseT.cs @ 138:f75cfa58e3d4 v2