Restructure solution layout by module

src/__Libraries/StellaOps.Plugin/DependencyInjection/PluginDependencyInjectionExtensions.cs

@@ -0,0 +1,93 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using StellaOps.DependencyInjection;
+using StellaOps.Plugin.Hosting;
+using StellaOps.Plugin.Internal;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace StellaOps.Plugin.DependencyInjection;
+
+public static class PluginDependencyInjectionExtensions
+{
+    public static IServiceCollection RegisterPluginRoutines(
+        this IServiceCollection services,
+        IConfiguration configuration,
+        PluginHostOptions options,
+        ILogger? logger = null)
+    {
+        if (services == null)
+        {
+            throw new ArgumentNullException(nameof(services));
+        }
+
+        if (configuration == null)
+        {
+            throw new ArgumentNullException(nameof(configuration));
+        }
+
+        if (options == null)
+        {
+            throw new ArgumentNullException(nameof(options));
+        }
+
+        var loadResult = PluginHost.LoadPlugins(options, logger);
+
+        foreach (var plugin in loadResult.Plugins)
+        {
+            PluginServiceRegistration.RegisterAssemblyMetadata(services, plugin.Assembly, logger);
+
+            foreach (var routine in CreateRoutines(plugin.Assembly))
+            {
+                logger?.LogDebug(
+                    "Registering DI routine '{RoutineType}' from plugin '{PluginAssembly}'.",
+                    routine.GetType().FullName,
+                    plugin.Assembly.FullName);
+
+                routine.Register(services, configuration);
+            }
+        }
+
+        if (loadResult.MissingOrderedPlugins.Count > 0)
+        {
+            logger?.LogWarning(
+                "Some ordered plugins were not found: {Missing}",
+                string.Join(", ", loadResult.MissingOrderedPlugins));
+        }
+
+        return services;
+    }
+
+    private static IEnumerable<IDependencyInjectionRoutine> CreateRoutines(System.Reflection.Assembly assembly)
+    {
+        foreach (var type in assembly.GetLoadableTypes())
+        {
+            if (type is null || type.IsAbstract || type.IsInterface)
+            {
+                continue;
+            }
+
+            if (!typeof(IDependencyInjectionRoutine).IsAssignableFrom(type))
+            {
+                continue;
+            }
+
+            object? instance;
+            try
+            {
+                instance = Activator.CreateInstance(type);
+            }
+            catch
+            {
+                continue;
+            }
+
+            if (instance is IDependencyInjectionRoutine routine)
+            {
+                yield return routine;
+            }
+        }
+    }
+}