Fix: Code Cleanup

Author: AnnaSasDev

src/CodeOfChaos.Types.DataSeeder/CodeOfChaos.Types.DataSeeder.csproj

@@ -23,19 +23,19 @@
     </PropertyGroup>
 
     <ItemGroup Label="InternalsVisibleTo">
-        <InternalsVisibleTo Include="Tests.CodeOfChaos.Types.DataSeeder" />
-        <InternalsVisibleTo Include="DynamicProxyGenAssembly2" />
+        <InternalsVisibleTo Include="Tests.CodeOfChaos.Types.DataSeeder"/>
+        <InternalsVisibleTo Include="DynamicProxyGenAssembly2"/>
     </ItemGroup>
 
     <ItemGroup>
-        <None Include="../../LICENSE" Pack="true" PackagePath="" Visible="false" />
-        <None Include="../../README.md" Pack="true" PackagePath="" Visible="false" />
-        <None Include="../../assets/icon.png" Pack="true" PackagePath="" Visible="false" />
+        <None Include="../../LICENSE" Pack="true" PackagePath="" Visible="false"/>
+        <None Include="../../README.md" Pack="true" PackagePath="" Visible="false"/>
+        <None Include="../../assets/icon.png" Pack="true" PackagePath="" Visible="false"/>
     </ItemGroup>
 
     <ItemGroup>
-        <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.0" />
-        <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="9.0.0" />
+        <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.0"/>
+        <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="9.0.0"/>
     </ItemGroup>
 
 </Project>

src/CodeOfChaos.Types.DataSeeder/IDataSeeder.cs

@@ -10,55 +10,56 @@ namespace CodeOfChaos.Types;
 // ---------------------------------------------------------------------------------------------------------------------
 public interface IDataSeederService : IHostedService {
     /// <summary>
-    /// Adds a seeder of type TSeeder to the data seeder service.
-    /// TSeeder must implement the ISeeder interface.
+    ///     Adds a seeder of type TSeeder to the data seeder service.
+    ///     TSeeder must implement the ISeeder interface.
     /// </summary>
     /// <typeparam name="TSeeder">The type of the seeder to be added.</typeparam>
     /// <returns>An instance of IDataSeederService to allow method chaining.</returns>
     IDataSeederService AddSeeder<TSeeder>() where TSeeder : ISeeder;
-    
+
     /// <summary>
-    /// Adds a group of seeders to the seeder service using the specified <paramref name="group"/> configuration callback.
+    ///     Adds a group of seeders to the seeder service using the specified <paramref name="group" /> configuration callback.
     /// </summary>
     /// <param name="group">
-    /// An action that allows configuration of the <see cref="SeederGroup"/> by adding individual seeders.
+    ///     An action that allows configuration of the <see cref="SeederGroup" /> by adding individual seeders.
     /// </param>
     /// <returns>
-    /// The updated instance of <see cref="IDataSeederService"/> to allow method chaining.
+    ///     The updated instance of <see cref="IDataSeederService" /> to allow method chaining.
     /// </returns>
     IDataSeederService AddSeederGroup(Action<SeederGroup> group);
-    
+
     /// <summary>
-    /// Adds a group of seeders to the current seeder service.
+    ///     Adds a group of seeders to the current seeder service.
     /// </summary>
     /// <param name="group">
-    /// An instance of <see cref="SeederGroup"/> containing the seeders to be added.
+    ///     An instance of <see cref="SeederGroup" /> containing the seeders to be added.
     /// </param>
     /// <returns>
-    /// The current instance of <see cref="IDataSeederService"/> with the added seeder group.
+    ///     The current instance of <see cref="IDataSeederService" /> with the added seeder group.
     /// </returns>
     IDataSeederService AddSeederGroup(SeederGroup group);
-    
+
     /// <summary>
-    /// Adds remaining seeder types from the provided assembly to the data seeder service.
-    /// Ensures that only non-abstract, non-generic, and non-interface types implementing the <see cref="ISeeder"/> interface are added.
+    ///     Adds remaining seeder types from the provided assembly to the data seeder service.
+    ///     Ensures that only non-abstract, non-generic, and non-interface types implementing the <see cref="ISeeder" />
+    ///     interface are added.
     /// </summary>
     /// <param name="assembly">
-    /// The assembly from which seeder types will be collected.
+    ///     The assembly from which seeder types will be collected.
     /// </param>
     /// <exception cref="AggregateException">
-    /// Thrown when one or more seeder types fail to be instantiated.
+    ///     Thrown when one or more seeder types fail to be instantiated.
     /// </exception>
     void AddRemainderSeeders(Assembly assembly);
-    
+
     /// <summary>
-    /// Adds all unprocessed data seeder types from the provided assembly as a single group to be executed together.
+    ///     Adds all unprocessed data seeder types from the provided assembly as a single group to be executed together.
     /// </summary>
     /// <param name="assembly">
-    /// The assembly from which to collect remaining data seeder types.
+    ///     The assembly from which to collect remaining data seeder types.
     /// </param>
     /// <exception cref="AggregateException">
-    /// Thrown if there are multiple errors while adding seeders to the group.
+    ///     Thrown if there are multiple errors while adding seeders to the group.
     /// </exception>
     void AddRemainderSeedersAsOneGroup(Assembly assembly);
 }

src/CodeOfChaos.Types.DataSeeder/ISeeder.cs

@@ -8,33 +8,39 @@ namespace CodeOfChaos.Types;
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
 /// <summary>
-/// Defines a contract for a seeding mechanism that determines whether a seed process should run
-/// and executes the seeding logic if required.
+///     Defines a contract for a seeding mechanism that determines whether a seed process should run
+///     and executes the seeding logic if required.
 /// </summary>
 public interface ISeeder {
     /// <summary>
-    /// Initiates the seeding process for the implementing class.
+    ///     Initiates the seeding process for the implementing class.
     /// </summary>
-    /// <param name="logger">An instance of <see cref="ILogger"/> for logging operations.</param>
-    /// <param name="ct">A <see cref="CancellationToken"/> to observe while waiting for the task to complete. Defaults to <see cref="CancellationToken.None"/>.</param>
-    /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>
+    /// <param name="logger">An instance of <see cref="ILogger" /> for logging operations.</param>
+    /// <param name="ct">
+    ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete. Defaults to
+    ///     <see cref="CancellationToken.None" />.
+    /// </param>
+    /// <returns>A <see cref="Task" /> that represents the asynchronous operation.</returns>
     /// <remarks>
-    /// This method should first checks whether seeding should occur by calling <c>ShouldSeedAsync</c>. If seeding is not needed, it logs an informational message and returns.
-    /// If seeding is required, the method executes <c>SeedAsync</c>, respecting the provided cancellation token.
+    ///     This method should first checks whether seeding should occur by calling <c>ShouldSeedAsync</c>. If seeding is not
+    ///     needed, it logs an informational message and returns.
+    ///     If seeding is required, the method executes <c>SeedAsync</c>, respecting the provided cancellation token.
     /// </remarks>
     Task StartAsync(ILogger logger, CancellationToken ct = default);
-    
+
     /// Determines whether the seeding process should proceed or be skipped.
     /// <param name="ct">A cancellation token that can be used to cancel the operation.</param>
-    /// <return>A task representing the asynchronous operation. The task result contains a boolean indicating
-    /// whether the seeding process should proceed (true) or be skipped (false).</return>
+    /// <return>
+    ///     A task representing the asynchronous operation. The task result contains a boolean indicating
+    ///     whether the seeding process should proceed (true) or be skipped (false).
+    /// </return>
     Task<bool> ShouldSeedAsync(CancellationToken ct = default);
-    
+
     /// <summary>
-    /// Executes the seed operation for a data seeder. This method is intended to be overridden
-    /// by derived classes to implement data seeding logic.
+    ///     Executes the seed operation for a data seeder. This method is intended to be overridden
+    ///     by derived classes to implement data seeding logic.
     /// </summary>
-    /// <param name="ct">The <see cref="CancellationToken"/> that can be used to signal a request to cancel the operation.</param>
+    /// <param name="ct">The <see cref="CancellationToken" /> that can be used to signal a request to cancel the operation.</param>
     /// <returns>A task that represents the asynchronous operation.</returns>
     Task SeedAsync(CancellationToken ct = default);
 }

src/CodeOfChaos.Types.DataSeeder/OneTimeDataSeederService.cs

@@ -12,44 +12,44 @@ namespace CodeOfChaos.Types;
 // ---------------------------------------------------------------------------------------------------------------------
 public class OneTimeDataSeederService(IServiceProvider serviceProvider, ILogger<OneTimeDataSeederService> logger) : IDataSeederService {
     /// <summary>
-    /// Represents a thread-safe queue of SeederGroup objects used within the OneTimeDataSeederService
-    /// to maintain and manage seeding operations.
+    ///     Represents a thread-safe queue of SeederGroup objects used within the OneTimeDataSeederService
+    ///     to maintain and manage seeding operations.
     /// </summary>
     /// <remarks>
-    /// The <c>Seeders</c> field serves as the central storage for SeederGroups, allowing them to be
-    /// enqueued and dequeued in a controlled manner during the seeding process. This ensures
-    /// proper execution order and thread safety for concurrent operations.
+    ///     The <c>Seeders</c> field serves as the central storage for SeederGroups, allowing them to be
+    ///     enqueued and dequeued in a controlled manner during the seeding process. This ensures
+    ///     proper execution order and thread safety for concurrent operations.
     /// </remarks>
     protected readonly ConcurrentQueue<SeederGroup> Seeders = [];
-    
+
     /// <summary>
-    /// Represents a thread-safe collection of seeder types used by the OneTimeDataSeederService to track
-    /// registered data seeders. This collection ensures that each type of seeder is only added once
-    /// and prevents duplicates during the seeding process. It plays a critical role in managing
-    /// and validating the lifecycle of seeders added to the service.
+    ///     Represents a thread-safe collection of seeder types used by the OneTimeDataSeederService to track
+    ///     registered data seeders. This collection ensures that each type of seeder is only added once
+    ///     and prevents duplicates during the seeding process. It plays a critical role in managing
+    ///     and validating the lifecycle of seeders added to the service.
     /// </summary>
     protected readonly ConcurrentBag<Type> SeederTypes = [];
-    
+
     /// <summary>
-    /// Indicates whether the remainder seeders have been successfully collected.
-    /// If set to <c>true</c>, it indicates that no additional remainder seeders can
-    /// be added to the service, and attempting to do so will throw an exception.
+    ///     Indicates whether the remainder seeders have been successfully collected.
+    ///     If set to <c>true</c>, it indicates that no additional remainder seeders can
+    ///     be added to the service, and attempting to do so will throw an exception.
     /// </summary>
     protected bool CollectedRemainders;// If set to true, the remainder seeders have been collected and thus should throw an exception if any are added
 
     // -----------------------------------------------------------------------------------------------------------------
     // Methods
     // -----------------------------------------------------------------------------------------------------------------
     /// <summary>
-    /// Starts the data seeding process by executing all configured seeder groups in sequence.
-    /// Validates seeders, collects data, and manages the lifecycle of each group using scoped services.
+    ///     Starts the data seeding process by executing all configured seeder groups in sequence.
+    ///     Validates seeders, collects data, and manages the lifecycle of each group using scoped services.
     /// </summary>
     /// <param name="ct">A CancellationToken used to observe cancellation requests.</param>
     /// <returns>A Task representing the asynchronous operation.</returns>
     public async Task StartAsync(CancellationToken ct = default) {
         logger.LogInformation("DataSeederService starting...");
-        
-        await CollectAsync(ct); // If user choose the old format of adding seeders, this will be what ads the seeders to the queue
+
+        await CollectAsync(ct);// If user choose the old format of adding seeders, this will be what ads the seeders to the queue
         ct.ThrowIfCancellationRequested();// Don't throw during collection, but throw afterward
 
         // Validation has to succeed before we continue
@@ -70,16 +70,16 @@ public async Task StartAsync(CancellationToken ct = default) {
             }
 
             // Each group should have their own scope
-            await using AsyncServiceScope scope =  serviceProvider.CreateAsyncScope();
+            await using AsyncServiceScope scope = serviceProvider.CreateAsyncScope();
             IServiceProvider scopeProvider = scope.ServiceProvider;
             List<ISeeder> seeders = [];
-            
+
             while (seederGroup.SeederTypes.TryDequeue(out Type? seederType)) {
                 var seeder = (ISeeder)scopeProvider.GetRequiredService(seederType);
                 seeders.Add(seeder);
-                
+
             }
-            
+
             logger.LogDebug("ExecutionStep {step} : {count} Seeder(s) found, executing...", i++, seeders.Count);
             await Task.WhenAll(seeders.Select(seeder => seeder.StartAsync(logger, ct)));
         }
@@ -92,7 +92,7 @@ public async Task StartAsync(CancellationToken ct = default) {
     }
 
     /// <summary>
-    /// Asynchronously stops the OneTimeDataSeederService, handling any necessary cleanup or finalization logic.
+    ///     Asynchronously stops the OneTimeDataSeederService, handling any necessary cleanup or finalization logic.
     /// </summary>
     /// <param name="ct">The cancellation token to observe while awaiting the task to complete.</param>
     /// <returns>A task that completes when the service has been stopped.</returns>
@@ -101,14 +101,6 @@ public Task StopAsync(CancellationToken ct = default) {
         return Task.CompletedTask;
     }
 
-    /// <summary>
-    /// Collects seeders asynchronously to prepare for execution based on the seeding logic.
-    /// This method is intended to be overridden for custom collection logic.
-    /// </summary>
-    /// <param name="ct">A <see cref="CancellationToken"/> to observe while waiting for the task to complete.</param>
-    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-    protected virtual Task CollectAsync(CancellationToken ct = default) => Task.CompletedTask;
-
     // -----------------------------------------------------------------------------------------------------------------
     // Seeder manipulation Methods
     // -----------------------------------------------------------------------------------------------------------------
@@ -122,7 +114,7 @@ public IDataSeederService AddSeederGroup(Action<SeederGroup> group) {
         group(seeders);
         return AddSeederGroup(seeders);
     }
-    
+
     /// <inheritdoc />
     public IDataSeederService AddSeederGroup(SeederGroup group) {
         ThrowIfRemainderSeeders();
@@ -134,7 +126,7 @@ public IDataSeederService AddSeederGroup(SeederGroup group) {
 
         return this;
     }
-    
+
     /// <inheritdoc />
     public void AddRemainderSeeders(Assembly assembly) {
         Type[] types = CollectTypes(assembly);
@@ -159,7 +151,7 @@ public void AddRemainderSeeders(Assembly assembly) {
 
         CollectedRemainders = true;
     }
-    
+
     /// <inheritdoc />
     public void AddRemainderSeedersAsOneGroup(Assembly assembly) {
         Type[] types = CollectTypes(assembly);
@@ -189,6 +181,14 @@ public void AddRemainderSeedersAsOneGroup(Assembly assembly) {
         CollectedRemainders = true;
     }
 
+    /// <summary>
+    ///     Collects seeders asynchronously to prepare for execution based on the seeding logic.
+    ///     This method is intended to be overridden for custom collection logic.
+    /// </summary>
+    /// <param name="ct">A <see cref="CancellationToken" /> to observe while waiting for the task to complete.</param>
+    /// <returns>A <see cref="Task" /> representing the asynchronous operation.</returns>
+    protected virtual Task CollectAsync(CancellationToken ct = default) => Task.CompletedTask;
+
     private static Type[] CollectTypes(Assembly assembly)
         => assembly.GetTypes()
             // order is deterministic

src/CodeOfChaos.Types.DataSeeder/Seeder.cs

@@ -8,8 +8,8 @@ namespace CodeOfChaos.Types;
 // Code
 // ---------------------------------------------------------------------------------------------------------------------
 /// <summary>
-/// Represents an abstract implementation of the <see cref="ISeeder"/> interface, providing
-/// a base class for seeding operations with pre-seeding validation logic.
+///     Represents an abstract implementation of the <see cref="ISeeder" /> interface, providing
+///     a base class for seeding operations with pre-seeding validation logic.
 /// </summary>
 public abstract class Seeder : ISeeder {
     /// <inheritdoc />
@@ -25,7 +25,7 @@ public async Task StartAsync(ILogger logger, CancellationToken ct = default) {
 
     /// <inheritdoc />
     public virtual Task<bool> ShouldSeedAsync(CancellationToken ct = default) => Task.FromResult(true);
-    
+
     /// <inheritdoc />
     public abstract Task SeedAsync(CancellationToken ct = default);
 }