Open Generics & dependency injection in the runtime

[jmzagorski]

I read through a few issues/discussions and understand how @louthy feels about DI frameworks 😄 , and I appreciate that philosophy.

I have an application that heavily uses a DI framework to setup our services, and I find it beneficial for open generic interfaces. For example, a common interface I often create is IValidator<TCommand> where TCommand changes for each endpoint in a Web API application. I can register this service once with a DI framework, such as container.Register(typeof(IValidator<>), assemblies) without having to update the bootstrap code for new implementations. Alternatively, I can container.Register(typeof(IValidator<>), typeof(GenericValidator<>)), and the framework will create the GenericValidator<SomeModel> when needed, without requiring me to register every "Model" in the bootstrap.

I am trying to refactor our application to use Eff<TRuntime, T> when services are needed, but I find myself passing the container to the runtime constructor and using it like

public Eff<ProdRuntime<TCommand>, IValidator<TCommand>> Validator =>  Eff<ProdRuntime<TCommand>, IValidator<TCommand>>(static rt => rt.container.GetInstance<IValidator<TCommand>>());

I understand I could pass an internal "env" instead of the container as mentioned #1188, but my questions is more about open generics and eliminating the DI framework

This requires the runtime to be an open generic, such as ProdRuntime<TCommand>, so that each endpoint can create an instance of the runtime based on the model it is using. The benefit is that I don't have to create a runtime class for each model, allowing me to share many of the same services such as validation, logging, authorization, caching etc.

Are there better strategies for these open generics that could eliminate the DI framework? (I thought about replacing the interfaces with delegates, but run into the same issue)

Here is a complete example of a Runtime for background workers that caches T models, so every worker would get a new instance of the runtime with a different T model.

public readonly struct CacheRuntime<T>(Container container, CancellationToken cancelToken = default) :
    HasCancel<CacheRuntime<T>>,
    HasQuery<CacheRuntime<T>, T>,
    HasBulkCache<CacheRuntime<T>, T>
    where T : class
{
    private readonly Container container = container;

    public CacheRuntime<T> LocalCancel => new(container, new());

    public CancellationToken CancellationToken { get; } = cancelToken;

    public CancellationTokenSource CancellationTokenSource
        => CancellationTokenSource.CreateLinkedTokenSource(CancellationToken);

    public Eff<CacheRuntime<T>, ValueTask<Seq<T>>> GetAll => Eff<CacheRuntime<T>, ValueTask<Seq<T>>>(
        static rt => DbContextQuery
            .GetAll<T>(rt.container.GetInstance<DbContext>())
            .AsSeq(rt.CancellationToken));

    public Eff<CacheRuntime<T>, IBulkCacheWriter<T>> Cache =>
        Eff<CacheRuntime<T>, IBulkCacheWriter<T>>(static rt => rt.container.GetInstance<IBulkCacheWriter<T>>());

[aloslider]

What's worng with the current implementation using IoC container as a service provider?

Are there better strategies for these open generics that could eliminate the DI framework? (I thought about replacing the interfaces with delegates, but run into the same issue)

IIUC, if you eliminate usage of DI framework and its magic reflection methods like container.Register(typeof(IValidator<>), typeof(GenericValidator<>)) , then you have to specify validators for your models that your runtime provides with some HasValidator<RT, T> trait. There's no shortcuts I'm aware of.

[jmzagorski]

I appreciate the time you took to respond. Your answer is very helpful!