Injecting dependencies into dynamically loaded .dll (.net core)

Question

Similar to How to Inject Dependencies to Dynamically Loaded Assemblies, I want to inject dependencies into classes from dynamically loaded assemblies. Is this possible with the .NET 6.0 DI Container? If so, how? If not, is there a light-weight IOC container that can you might recommend? (Not adding a 2nd IOC system to the project would be preferred.) (Note: there will be only 2-4 maximum possible dependencies to inject, so a fake injection system with if/switch statements could be acceptable.)
One challenge: ILogger<> typically expects a type, but the loading .dll has no compile-time knowledge of the types in the dynamically loaded assemblies, and vice-versa. I could use the non-generic ILogger interface, but am not sure if that works with DI.

EDIT: Expanding example, as requested:

Given: All potential dependencies to inject come from the Microsoft.Extensions.Hosting nuget package. The two we initially expect to use are ILogging<> and IConfiguration.

Type desiredClass = <Type found in the dynamically loaded assembly>;
//The below line does not inject dependencies.  I am trying to find out what will.
object classInstace = Activator.CreateInstance(desiredClass); 
MethodInfo selectedMethod = desiredClass.GetMethods
    .Single(m=>m.Name=="Execute" && m.GetParameters().All(p=>p.IsOptional));
//Schedule the method in HangFire
RecurringJob.AddOrUpdate(
    () => selectedMethod!.Invoke(
        ClassInstance,
        Array.Empty<object?>(),
        scheduleForThisTask);

Answer 1

I found a very ugly way to get this done, and very much hope there is a cleaner way to accomplish this. (Please let there be a built-in way to do this that I have missed.)

Create an extension method GetInjectedObject for IService Provider:

public static object GetInjectedObject(this IServiceProvider serviceProvider, Type type)
{
    //Dependency injection the ugly way
    //Find the constructor that asks for the most injected parameters
    var constructor = type.GetConstructors().Where(cn =>
            cn.GetParameters().All(par => serviceProvider.GetServices(par.ParameterType).Any()))
        .OrderByDescending(cn => cn.GetParameters().Length).FirstOrDefault();
    if (null == constructor)
        throw new Exception($"Type {type.Name} does not have a constructor without non-injectible parameters.");
    //Get the needed parameters from the IServiceProvider
    var constructorParameters =
        constructor.GetParameters().Select(par => serviceProvider.GetService(par.ParameterType)).ToArray();
    //Create the object with the parameters
    var classInstance = Activator.CreateInstance(type, constructorParameters);
    return classInstance;
}

and then create the objects like this:

_classInstance = serviceProvider.GetInjectedObject(Class);

Answer 2

Perhaps I misunderstood the problem, might it work for you to:

• Have an assembly shared by the loading assembly (i.e. your Composition Root) and the dynamically loaded assembly? This assembly could contain an interface that dynamically loaded types must implement. (you might already have a shared assembly)
• Load the dynamically loaded assembly at startup at the point that you're still wiring the DI Container?

In that case I expect an interface similar to:

namespace MySharedAssembly
{
    public interface ITask
    {
        void Execute(TaskSchedule schedule);
    }

    public class TaskSchedule { ... }
}

In the dynamically loaded assembly:

namespace MyDynamicAssembly
{
    public class HelloWorldTask : ITask
    {
        public void Execute(TaskSchedule schedule)
        {
            Console.WriteLine("Hello world!");
        }
    }
}

By doing so, you can:

• Easily find all types in the dynamically loaded assembly by the ITask interface.
• Register them by their concrete type in the DI Container.
• Resolve them by their concrete type when needed, while their dependencies are injected by the DI Container.

For instance:

string dynamicallyLoadedAssemblyPath = "c:\\...\etc\etc\myAssembly.dll";

// Load plugin assembly
Assembly assembly =
    Assembly.Load(AssemblyName.GetAssemblyName(dynamicallyLoadedAssemblyPath));

// Load plugin types
Type plugins = assembly.GetExportedTypes().Where(typeof(ITask).IsAssignableFrom);

// Register plugins in DI Container
foreach (var plugin in plugins)
{
    services.AddTransient(plugin, plugin);
}

// Add jobs after container was constructed
IServiceProvider provider = ...
foreach (var plugin in plugins)
{
    var scheduleForThisTask = GetSchedule(plugin);
    RecurringJob.AddOrUpdate(() =>
    {
        // It might be important to execute each task in its own scope.
        using (var scope = provider.CreateScope())
        {
            var task = (ITask)scope.ServiceProvider.GetRequiredService(plugin);
            task.Execute(scheduleForThisTask);
        }
    }
}