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);
-                         base.Dispose(disposing, lastError);
+                             MockDispose(disposing);
+                         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, error) => {
+                         comp.MockDispose = (disposing) => {
                              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>
-                     /// Starts this instance.
+                 /// 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
                      /// </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 +7 -14

              using System;
+             using System.Diagnostics.CodeAnalysis;
              namespace Implab.Components {
                  public abstract class RunnableComponent : IDisposable, IRunnable, IInitializable {
                      /// 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) {
-                             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);
+                         }
+                         Dispose(true);
                      }
                      ~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>
-                     protected virtual void Dispose(bool disposing, Exception lastError) {
+                     /// <param name="pending">The operation which is currenty pending</param>
+                     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 +30 -2

                      }
                      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) {
                      }
                      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;
+                         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