implab/ImplabNet Commit - r208:7d07503621fe

RunnableComponent.Dispose(bool,Exception) changed to standart Dispose(bool)...

cin -

r208:7d07503621fe v2

parent child

Context file:

r208:7d07503621fe

Collapse all files

Implab.Test/Mock/MockRunnableComponent.cs +4 -4

                         set;
                     }
-                    public Action<bool, Exception> MockDispose {
+                    public Action<bool> MockDispose {
                         get;
                         set;
                     }
                             MockInit();
                     }
-                    protected override void Dispose(bool disposing, Exception lastError) {
+                    protected override void Dispose(bool disposing) {
                         if (MockDispose != null)
-                            MockDispose(disposing, lastError);
+                            MockDispose(disposing);
-                        base.Dispose(disposing, lastError);
+                        base.Dispose(disposing);
                     }
                 }
             }

Implab.Test/RunnableComponentTests.cs +3 -5

                         var comp = new MockRunnableComponent(true);
                         bool disposed = false;
-                        comp.MockDispose = (disposing, error) => {
+                        comp.MockDispose = (disposing) => {
                             disposed = true;
                         };
                         var comp = new MockRunnableComponent(true, true);
                         bool disposed = false;
-                        comp.MockDispose = (disposing, error) => {
+                        comp.MockDispose = (disposing) => {
                             disposed = true;
                         };
                         var comp = new MockRunnableComponent(true, true);
                         bool disposed = false;
-                        Exception lastError = null;
+                        comp.MockDispose = (disposing) => {
-                        comp.MockDispose = (disposing, error) => {
                             disposed = true;
-                            lastError = error;
                         };
                         comp.Start().Join(1000);

Implab/Components/Disposable.cs +2 0

             using Implab.Diagnostics;
             using System;
+            using System.Diagnostics.CodeAnalysis;
             using System.Threading;
             namespace Implab.Components {
                         }
                     }
+                    [SuppressMessage("Microsoft.Design", "CA1063:ImplementIDisposableCorrectly", Justification = "Dipose(bool) and GC.SuppessFinalize are called")]
                     public void Dispose() {
                         if (Interlocked.Increment(ref m_disposed) == 1) {
                             Dispose(true);

Implab/Components/IRunnable.cs +11 -3

             using System;
             namespace Implab.Components {
-                public interface IRunnable {
+                /// <summary>
+                /// Interface for the component which performs a long running task.
+                /// </summary>
+                /// <remarks>
+                /// <para>The component also should implement <see cref="IDisposable"/> interface to be able to release used resources.</para>
+                /// <para>All methods of this interface must be a thread safe. If the operation is not applicable in the current state the
+                /// method should throw an exception and keep the current state unchanged.</para>
+                /// </remarks>
+                public interface IRunnable : IDisposable {
                     /// <summary>
-                    /// Starts this instance.
+                    /// Starts this instance
                     /// </summary>
                     IPromise Start();
                     /// <summary>
-                    /// Stops this instance. After the instance is stopped it can't be started again, stopping should be treated as gracefull and async dispose.
+                    /// Stops this instance, after the instance is stopped it can move to Failed, Ready or Disposed state, in case with the last it can't be reused.
                     /// </summary>
                     IPromise Stop();

Implab/Components/PollingComponent.cs +3 -3

                         return base.OnStop();
                     }
-                    protected override void Dispose(bool disposing, Exception lastError) {
+                    protected override void Dispose(bool disposing) {
                         if (disposing)
-                            Safe.Dispose(m_timer);
+                            m_timer.Dispose();
-                        base.Dispose(disposing, lastError);
+                        base.Dispose(disposing);
                     }
                 }
             }

Implab/Components/RunnableComponent.cs +8 -15

             using System;
+            using System.Diagnostics.CodeAnalysis;
             namespace Implab.Components {
                 public abstract class RunnableComponent : IDisposable, IRunnable, IInitializable {
                     enum Commands {
                     /// especially if <see cref="Stop"/> method is failed. Using this method insted of <see cref="Stop()"/> may
                     /// lead to the data loss by the component.
                     /// </para></remarks>
+                    [SuppressMessage("Microsoft.Design", "CA1063:ImplementIDisposableCorrectly", Justification = "Dipose(bool) and GC.SuppessFinalize are called")]
                     public void Dispose() {
                         IPromise pending;
                         lock (m_stateMachine) {
                             if (m_stateMachine.State == ExecutionState.Disposed)
                                 return;
-                            pending = Move(Commands.Dispose, null, null);
+                            Move(Commands.Dispose, null, null);
                         }
                         GC.SuppressFinalize(this);
-                        if (pending != null) {
+                        Dispose(true);
-                            pending.Cancel();
-                            pending.Timeout(DisposeTimeout).On(
-                                () => Dispose(true, null),
-                                err => Dispose(true, err),
-                                reason => Dispose(true, new OperationCanceledException("The operation is cancelled", reason))
-                            );
-                        } else {
-                            Dispose(true, null);
                     }
                     ~RunnableComponent() {
-                        Dispose(false, null);
+                        Dispose(false);
                     }
                     #endregion
                     /// Releases all resources used by the component, called automatically, override this method to implement your cleanup.
                     /// </summary>
                     /// <param name="disposing">true if this method is called during normal dispose process.</param>
-                    /// <param name="lastError">The last error which occured during the component stop.</param>
+                    /// <param name="pending">The operation which is currenty pending</param>
-                    protected virtual void Dispose(bool disposing, Exception lastError) {
+                    protected virtual void Dispose(bool disposing) {
                     }

Implab/Formats/JSON/JSONParser.cs +1 -1

                     protected override void Dispose(bool disposing) {
                         if (disposing)
-                            Safe.Dispose(m_scanner);
+                            m_scanner.Dispose();
                     }
                     /// <summary>

Implab/Formats/JSON/JSONScanner.cs +1 -1

                     protected override void Dispose(bool disposing) {
                         if (disposing)
-                            Safe.Dispose(m_scanner);
+                            m_scanner.Dispose();
                         base.Dispose(disposing);
                     }
                 }

Implab/PromiseExtensions.cs +33 -5

                     }
                     public static IPromise<T[]> PromiseAll<T>(this IEnumerable<IPromise<T>> that) {
+                        return PromiseAll(that, null);
+                    }
+                    public static IPromise<T[]> PromiseAll<T>(this IEnumerable<IPromise<T>> that, Action<T> cleanup) {
                         Safe.ArgumentNotNull(that, "that");
-                        return PromiseAll(that.ToList());
+                        return PromiseAll(that.ToList(), cleanup);
                     }
                     public static IPromise PromiseAll(this ICollection<IPromise> that) {
                         return medium;
                     }
                     public static IPromise<T[]> PromiseAll<T>(this ICollection<IPromise<T>> that) {
+                        return PromiseAll(that, null);
+                    }
+                    /// <summary>
+                    /// Creates a new promise which will be satisfied when all promises are satisfied.
+                    /// </summary>
+                    /// <typeparam name="T"></typeparam>
+                    /// <param name="that"></param>
+                    /// <param name="cleanup">A callback used to cleanup already resolved promises in case of an error</param>
+                    /// <returns></returns>
+                    public static IPromise<T[]> PromiseAll<T>(this ICollection<IPromise<T>> that, Action<T> cleanup) {
                         Safe.ArgumentNotNull(that, "that");
+                        int count = that.Count;
-                        int count = that.Count;
+                        if (count == 0)
+                            return Promise<T[]>.FromResult(new T[0]);
                         int errors = 0;
                         var medium = new Promise<T[]>();
                         var results = new T[that.Count];
                         medium.On(() => {
-                            foreach (var p2 in that)
+                            foreach (var p2 in that) {
                                 p2.Cancel();
+                                if (cleanup != null)
+                                    p2.On(cleanup);
+                            }
                         }, PromiseEventType.ErrorOrCancel);
                         int i = 0;
                         return new PromiseAwaiter<T>(that);
                     }
+                    public static PromiseAwaiter GetAwaiter(this IPromise that) {
+                        Safe.ArgumentNotNull(that, "that");
+                        return new PromiseAwaiter(that);
+                    }
             #endif
                 }
             }

General Comments 3

sergey

|

Auto status change to "Under Review"

sergey

|

ok, latest stable version should be in default

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages