Merge pull request #109 from JacopoWolf/dev/3.1

Preparing 3.1 release branch

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

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

@@ -34,7 +34,7 @@ public ServingMethods Serving
         }
 
         private ServingMethods _serving;
-        internal bool _servingDefined = false;
+        internal bool _servingDefined;
     }
 
 }

StackInjector/Core/AsyncStackWrapperCore.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,10 +19,13 @@ 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;
 
         // 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>>();
@@ -35,7 +41,7 @@ internal AsyncStackWrapperCore ( InjectionCore core, Type toRegister ) : base(co
 
         #region IDisposable Support
 
-        private bool disposedValue = false;
+        private bool disposedValue;
 
         public override void Dispose ()
         {
@@ -61,7 +67,6 @@ public override void Dispose ()
                 this.disposedValue = true;
             }
         }
-
         #endregion
     }
 

StackInjector/Core/AsyncStackWrapperCore.logic.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;
@@ -30,8 +31,17 @@ public bool AnyTaskLeft ()
                 return this.tasks.Any();
         }
 
+        public bool AnyTaskCompleted ()
+        {
+            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 
@@ -51,8 +61,28 @@ public async IAsyncEnumerable<T> Elaborated ()
                         break;
                 }
             }
+
+            lock( this.listAccessLock )
+                this.exclusiveExecution = false;
+
+        }
+
+        public Task Elaborate ()
+        {
+            // must run syncronously
+            this.EnsureExclusiveExecution();
+
+            return
+                Task.Run(async () =>
+                {
+
+                    await foreach( var res in this.Elaborated() )
+                        this.OnElaborated?.Invoke(res);
+                });
+
         }
 
+
         // true if outher loop is to break
         private async Task<bool> OnNoTasksLeft ()
         {
@@ -86,10 +116,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/IAsyncStackWrapperCore.cs

@@ -11,13 +11,16 @@ namespace StackInjector.Core
     /// <typeparam name="T">the type tasks will return</typeparam>
     public interface IAsyncStackWrapperCore<T> : IStackWrapperCore
     {
+        /// <summary>
+        /// called when a new element has been elaborated
+        /// </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>
@@ -30,8 +33,17 @@ public interface IAsyncStackWrapperCore<T> : IStackWrapperCore
         /// this will wait indefinitively.
         /// </summary>
         /// <returns>An asyncronous enumerable of completed tasks</returns>
+        /// <exception cref="InvalidOperationException"></exception>
         IAsyncEnumerable<T> Elaborated ();
 
+        /// <summary>
+        /// Calling this method will begin the elaboration loop.<br/>
+        /// If a concurrent call to the <see cref="Elaborated"/> is made, this will return an exception
+        /// </summary>
+        /// <returns>a task rappresenting the elaboration loop</returns>
+        /// <exception cref="InvalidOperationException"></exception>
+        Task Elaborate ();
+
         /// <summary>
         /// check if there are tasks left to elaborate
         /// </summary>

StackInjector/Core/InjectionCore.logic.cs

@@ -26,7 +26,7 @@ internal void ServeAll ()
                     var next = toInject.Dequeue();
                     var usedServices = this.InjectServicesInto(next);
 
-                    // this object has been ionjected
+                    // this object has been injected
                     this.instances.SetInjectionStatus(next);
 
                     // foreach injected object check if it has already been injected. 

StackInjector/Core/StackWrapperCore.cs

@@ -23,7 +23,7 @@ public StackWrapperCore ( InjectionCore core, Type toRegister )
             this.Core = core;
 
             // setting for referencing the calling wrapper as a service
-            if( this.Core.settings._registerSelf )
+            if( this.Core.settings._registerWrapAsService )
                 this.Core.instances.AddInstance(toRegister, this);
         }
 

StackInjector/Exceptions/StackInjectorException.cs

@@ -10,7 +10,7 @@ public abstract class StackInjectorException : Exception
         /// <summary>
         /// The source type of the exception
         /// </summary>
-        public Type SourceType { get; private protected set; } = null;
+        public Type SourceType { get; private protected set; }
 
         internal StackInjectorException ( Type type, string message ) : this(message)
         {

StackInjector/Injector.defaults.cs

@@ -24,6 +24,12 @@ public static class Defaults
             /// </summary>
             public const ServingMethods ServeAll =
                 ( ServingMethods.Fields | ServingMethods.Properties );
+
+
+            /// <summary>
+            /// Default regex to filter system assemblies
+            /// </summary>
+            public const string AssemblyRegexFilter = "^(System)|(Microsoft)";
         }
     }
 }