Merge pull request #124 from JacopoWolf/rel/3.1

Stable release 3.1.0

Author: JacopoWolf

.github/dependabot.yml

@@ -6,6 +6,7 @@
 version: 2
 updates:
 
+
     # prod 
   - package-ecosystem: "nuget" 
     directory: "/StackInjector"
@@ -26,10 +27,10 @@ updates:
       - "dependencies"
       - "testing"
 
+
     #todo: add TEST.WhiteBox
 
 
-      
     # ci
   - package-ecosystem: "github-actions"
     # Workflow files stored in the

.github/workflows/dotnetcore.yml

@@ -14,12 +14,12 @@ on:
 
 
 jobs:
-  
   test:
     runs-on: ${{ matrix.os }}
     env:
       DOTNET_NOLOGO: true
     strategy:
+      fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest]
         dotnet: ['3.1.x']

StackInjector/Attributes/ServedAttribute.cs

@@ -13,7 +13,7 @@ public sealed class ServedAttribute : Attribute
         /// <summary>
         /// The target version.
         /// </summary>
-        public double TargetVersion { get; set; } = 0.0;
+        public double TargetVersion { get; set; }
 
         /// <summary>
         /// <para>How the specified TargetVersion should be found.</para>
@@ -31,7 +31,7 @@ public ServedVersionTargetingMethod TargetingMethod
 
 
         private ServedVersionTargetingMethod _targeting;
-        internal bool _targetingDefined = false;
+        internal bool _targetingDefined;
 
     }
 

StackInjector/Attributes/ServiceAttribute.cs

@@ -17,7 +17,11 @@ public sealed class ServiceAttribute : Attribute
         /// <summary>
         /// The instantiation pattern for this service.
         /// </summary>
-        public InstantiationPattern Pattern { get; set; } = InstantiationPattern.Singleton;
+        public InstantiationPattern Pattern
+        {
+            get => this._pattern;
+            set => this._pattern = value;
+        }
 
 
         /// <summary>
@@ -33,8 +37,9 @@ public ServingMethods Serving
             }
         }
 
+        private InstantiationPattern _pattern = InstantiationPattern.Singleton;
         private ServingMethods _serving;
-        internal bool _servingDefined = false;
+        internal bool _servingDefined;
     }
 
 }

StackInjector/Behaviours/IInstancesHolder.cs

@@ -8,6 +8,9 @@ namespace StackInjector.Core
     internal abstract partial class AsyncStackWrapperCore<T> : StackWrapperCore, IAsyncStackWrapperCore<T>
     {
 
+        public event Action<T> OnElaborated;
+
+
         // used to cancel everything
         protected internal readonly CancellationTokenSource cancelPendingTasksSource = new CancellationTokenSource();
 
@@ -16,38 +19,41 @@ public CancellationToken PendingTasksCancellationToken
             => this.cancelPendingTasksSource.Token;
 
         // used to lock access to tasks
-        protected internal readonly object listAccessLock = new object();
+        private readonly object _listAccessLock = new object();
+
+        // used to endure Elaborated() and Elaborate() are called together
+        private bool _exclusiveExecution;
+
+        public bool IsElaborating => this._exclusiveExecution;
 
         // asyncronously waited for new events if TaskList is empty
-        protected internal 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);
-        }
 
 
 
         #region IDisposable Support
 
-        private bool disposedValue = false;
+        private bool disposedValue;
 
         public override void Dispose ()
         {
             if( !this.disposedValue )
             {
 
                 // 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
@@ -61,7 +67,6 @@ public override void Dispose ()
                 this.disposedValue = true;
             }
         }
-
         #endregion
     }
 

StackInjector/Behaviours/SingleInstanceHolder.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using StackInjector.Settings;
@@ -8,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.
@@ -24,22 +23,33 @@ public void Submit ( Task<T> work )
                 this.ReleaseListAwaiter();
         }
 
+
         public bool AnyTaskLeft ()
         {
-            lock( this.listAccessLock )
+            lock( this._listAccessLock )
                 return this.tasks.Any();
         }
 
+        public bool AnyTaskCompleted ()
+        {
+            lock( this._listAccessLock )
+                return this.tasks.Any(t => t.IsCompleted);
+        }
+
         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;
@@ -51,14 +61,25 @@ public async IAsyncEnumerable<T> Elaborated ()
                         break;
                 }
             }
+
+            lock( this._listAccessLock )
+                this._exclusiveExecution = false;
+
+        }
+
+        public async Task Elaborate ()
+        {
+            await foreach( var res in this.Elaborated() )
+                this.OnElaborated?.Invoke(res);
         }
 
+
         // true if outher loop is to break
         private async Task<bool> OnNoTasksLeft ()
         {
             // to not repeat code
             Task listAwaiter ()
-                => this.emptyListAwaiter.WaitAsync();
+                => this._emptyListAwaiter.WaitAsync();
 
 
             switch( this.Settings._asyncWaitingMethod )
@@ -86,10 +107,18 @@ Task listAwaiter ()
             }
         }
 
+        private void EnsureExclusiveExecution ( bool set = false )
+        {
+            lock( this._listAccessLock ) // reused lock
+            {
+                if( this._exclusiveExecution )
+                    throw new InvalidOperationException();
+
+                if( set )
+                    this._exclusiveExecution = set;
+            }
+        }
 
-        public bool AnyTaskCompleted ()
-            =>
-                this.tasks.Any(t => t.IsCompleted);
 
 
     }

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;