Merge pull request #118 from JacopoWolf/dev/optimization

Optimizations

Author: JacopoWolf

StackInjector/Behaviours/IInstancesHolder.cs

@@ -19,23 +19,23 @@ public CancellationToken PendingTasksCancellationToken
             => this.cancelPendingTasksSource.Token;
 
         // used to lock access to tasks
-        private readonly object listAccessLock = new object();
+        private readonly object _listAccessLock = new object();
 
         // used to endure Elaborated() and Elaborate() are called together
-        private bool exclusiveExecution;
+        private bool _exclusiveExecution;
+
+        public bool IsElaborating => this._exclusiveExecution;
 
         // asyncronously waited for new events if TaskList is empty
-        private readonly SemaphoreSlim emptyListAwaiter = new SemaphoreSlim(0);
+        private readonly SemaphoreSlim _emptyListAwaiter = new SemaphoreSlim(0);
 
         // pending tasks
         protected internal LinkedList<Task<T>> tasks = new LinkedList<Task<T>>();
 
 
-        internal AsyncStackWrapperCore ( InjectionCore core, Type toRegister ) : base(core, toRegister)
-        {
-            // register an event that in case the list is empty, release the empty event listener.
+        // register an event that in case the list is empty, release the empty event listener.
+        internal AsyncStackWrapperCore ( InjectionCore core, Type toRegister ) : base(core, toRegister) =>
             this.cancelPendingTasksSource.Token.Register(this.ReleaseListAwaiter);
-        }
 
 
 
@@ -49,11 +49,11 @@ public override void Dispose ()
             {
 
                 // managed resources
-                this.cancelPendingTasksSource.Cancel();
+                this.cancelPendingTasksSource.Cancel(); // cancel all pending tasks
                 this.ReleaseListAwaiter();  // in case it's waiting on the empty list
 
                 this.cancelPendingTasksSource.Dispose();
-                this.emptyListAwaiter.Dispose();
+                this._emptyListAwaiter.Dispose();
 
 
                 // big objects

StackInjector/Behaviours/SingleInstanceHolder.cs

@@ -9,14 +9,12 @@ namespace StackInjector.Core
     internal abstract partial class AsyncStackWrapperCore<T>
     {
         // call the semaphore
-        protected internal void ReleaseListAwaiter ()
-        {
-            this.emptyListAwaiter.Release();
-        }
+        protected internal void ReleaseListAwaiter () => this._emptyListAwaiter.Release();
+
 
-        public void Submit ( Task<T> work )
+        internal void Submit ( Task<T> work )
         {
-            lock( this.listAccessLock )
+            lock( this._listAccessLock )
                 this.tasks.AddLast(work);
 
             // if the list was empty just an item ago, signal it's not anymore.
@@ -25,31 +23,35 @@ public void Submit ( Task<T> work )
                 this.ReleaseListAwaiter();
         }
 
+
         public bool AnyTaskLeft ()
         {
-            lock( this.listAccessLock )
+            lock( this._listAccessLock )
                 return this.tasks.Any();
         }
 
         public bool AnyTaskCompleted ()
         {
-            return this.tasks.Any(t => t.IsCompleted);
+            lock( this._listAccessLock )
+                return this.tasks.Any(t => t.IsCompleted);
         }
 
         // todo add a method to safely exit the await loop to be able to re-join later or maybe an Unloack() of some sort
         //! should check if exiting an await foreach loop and re-entering will not hack the control or lose data
         public async IAsyncEnumerable<T> Elaborated ()
         {
             this.EnsureExclusiveExecution(true);
-
+            
             while( !this.cancelPendingTasksSource.IsCancellationRequested )
             {
                 // avoid deadlocks 
                 if( this.AnyTaskLeft() )
                 {
                     var completed = await Task.WhenAny(this.tasks).ConfigureAwait(false);
 
-                    lock( this.listAccessLock )
+
+
+                    lock( this._listAccessLock )
                         this.tasks.Remove(completed);
 
                     yield return completed.Result;
@@ -62,24 +64,15 @@ public async IAsyncEnumerable<T> Elaborated ()
                 }
             }
 
-            lock( this.listAccessLock )
-                this.exclusiveExecution = false;
+            lock( this._listAccessLock )
+                this._exclusiveExecution = false;
 
         }
 
-        public Task Elaborate ()
+        public async Task Elaborate ()
         {
-            // must run syncronously
-            this.EnsureExclusiveExecution();
-
-            return
-                Task.Run(async () =>
-                {
-
-                    await foreach( var res in this.Elaborated() )
-                        this.OnElaborated?.Invoke(res);
-                });
-
+            await foreach( var res in this.Elaborated() )
+                this.OnElaborated?.Invoke(res);
         }
 
 
@@ -88,7 +81,7 @@ private async Task<bool> OnNoTasksLeft ()
         {
             // to not repeat code
             Task listAwaiter ()
-                => this.emptyListAwaiter.WaitAsync();
+                => this._emptyListAwaiter.WaitAsync();
 
 
             switch( this.Settings._asyncWaitingMethod )
@@ -118,13 +111,13 @@ Task listAwaiter ()
 
         private void EnsureExclusiveExecution ( bool set = false )
         {
-            lock( this.listAccessLock ) // reused lock
+            lock( this._listAccessLock ) // reused lock
             {
-                if( this.exclusiveExecution )
+                if( this._exclusiveExecution )
                     throw new InvalidOperationException();
 
                 if( set )
-                    this.exclusiveExecution = set;
+                    this._exclusiveExecution = set;
             }
         }
 

StackInjector/Core/AsyncStackWrapperCore.cs

@@ -19,7 +19,7 @@ public IAsyncStackWrapper<TEntry, TIn, TOut> ToAsyncWrapper<TEntry, TIn, TOut> (
                 StackDigest = digest
             };
 
-            this.clonedCore.EntryPoint = typeof(TEntry);
+            this.clonedCore.EntryType = typeof(TEntry);
             this.clonedCore.ServeAll();
 
             return wrapper;
@@ -29,7 +29,7 @@ public IStackWrapper<T> ToWrapper<T> ()
         {
             var wrapper = new StackWrapper<T>(this.clonedCore);
 
-            this.clonedCore.EntryPoint = typeof(T);
+            this.clonedCore.EntryType = typeof(T);
             this.clonedCore.ServeAll();
 
             return wrapper;

StackInjector/Core/AsyncStackWrapperCore.logic.cs

@@ -16,17 +16,12 @@ public interface IAsyncStackWrapperCore<T> : IStackWrapperCore
         /// </summary>
         event Action<T> OnElaborated;
 
+
         /// <summary>
         /// Used to signal cancellation of every pending task
         /// </summary>
         CancellationToken PendingTasksCancellationToken { get; }
 
-        /// <summary>
-        /// submit new work to this wrapper
-        /// </summary>
-        /// <param name="work"></param>
-        void Submit ( Task<T> work );
-
         /// <summary>
         /// The loop you ca use to <c>await foreach</c> tasks in elaboration, converted to the specified type.
         /// When the pending tasks list is empty, unless <see cref="IDisposable.Dispose"/> is explocitly called
@@ -44,6 +39,16 @@ public interface IAsyncStackWrapperCore<T> : IStackWrapperCore
         /// <exception cref="InvalidOperationException"></exception>
         Task Elaborate ();
 
+        
+
+
+        /// <summary>
+        /// is this wrapper is already elaborating queued tasks.<br/>
+        /// If true, then calling <see cref="Elaborate"/> or <see cref="Elaborated"/>
+        /// will throw a <see cref="InvalidOperationException"/>
+        /// </summary>
+        bool IsElaborating { get; }
+
         /// <summary>
         /// check if there are tasks left to elaborate
         /// </summary>

StackInjector/Core/Cloning/ClonedCore.cs

@@ -24,7 +24,11 @@ public StackWrapperCore ( InjectionCore core, Type toRegister )
 
             // setting for referencing the calling wrapper as a service
             if( this.Core.settings._registerWrapAsService )
-                this.Core.instances.AddInstance(toRegister, this);
+            {
+                this.Core.instances.AddType(toRegister);
+                this.Core.instances[toRegister].Clear();
+                this.Core.instances[toRegister].AddFirst(this);
+            }
         }
 
 

StackInjector/Core/IAsyncStackWrapperCore.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Reflection;
 using StackInjector.Attributes;
-using StackInjector.Behaviours;
 using StackInjector.Exceptions;
 using StackInjector.Settings;
 
@@ -15,27 +14,26 @@ namespace StackInjector.Core
     internal partial class InjectionCore
     {
         // entry point object of this core
-        private Type _entryPoint;
-        internal Type EntryPoint
+        private Type _entryType;
+        internal Type EntryType
         {
             get
-                => this._entryPoint;
+                => this._entryType;
             set
             {
                 var serviceAtt = value.GetCustomAttribute<ServiceAttribute>();
                 if( serviceAtt != null && serviceAtt.Pattern == InstantiationPattern.AlwaysCreate )
                     throw new InvalidEntryTypeException(value, $"Entry point {value.Name} cannot have {InstantiationPattern.AlwaysCreate} as instantiation pattern.");
 
-                this._entryPoint = value;
+                this._entryType = value;
             }
         }
 
-
         // manage settings
         internal StackWrapperSettings settings;
 
         // holds instances
-        internal IInstancesHolder instances;
+        internal InstancesHolder instances;
 
         // tracks instantiated objects
         internal readonly List<object> instancesDiff;
@@ -49,7 +47,7 @@ internal InjectionCore ( StackWrapperSettings settings )
         {
             this.settings = settings;
 
-            this.instances = new SingleInstanceHolder();
+            this.instances = new InstancesHolder();
 
             if( this.settings._trackInstancesDiff )
                 this.instancesDiff = new List<object>();