在运行时获取通用和抽象 class 的实例

Question

I have an abstract implementation in the ClassLibrary2 and I also have the EntryPointLibrary where I inject the dependencies..

Code in ClassLibrary2:

public abstract class BaseApplicationDbContext<TEntity> : DbContext, IDisposable
    where TEntity : BaseEntity
{
    public BaseApplicationDbContext(DbContextOptions options)
        : base(options)
    {
    }


    public virtual DbSet<TEntity> Entity { get; set; }


    public abstract Task HandleSomething(BaseEntity baseEntity);
}



public class BaseEntity
{
    public int Id { get; set; }
    public string Name { get; set; }
}

So I have a generic and abstract DbContext to be implemented in the EntryPointLibrary and I also have an entity with base things.

Then I also have a Handler class which will receive and handle asynchronous messages (via pubsub):

public class Handler
{
    private readonly IServiceProvider _serviceProvider;

    public Handler(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public async Task TreatTheMessage(string jsonMessage)
    {
        //Notes:
        //----- This is a simple example, but for my real implementation I can't get an instance of BaseApplicationDbContext from the ctor
        //----- This library doesn't have acesse to the EntryPointLibrary, so I don't have access to the Entity class neither the ApplicationDbContext class, but I need to get the ApplicationDbContext instance here. The EntryPointLibrary is the entry point
        using var scope = _serviceProvider.CreateScope();
        using var applicationDbContext = scope.ServiceProvider.GetService<BaseApplicationDbContext<BaseEntity>>();

        //Convert from json to BaseEntity
        BaseEntity baseEntity = new BaseEntity
        {
            Id = 1,
            //....
        };

        await applicationDbContext.HandleSomething(baseEntity);

    }
}

Then in the EntryPointLibrary I have 3 entities where the Entity.cs is extending the BaseEntity (from library2) and is being used to setup the generic: (Note that I have the implementation of an abstract method where I will receice the BaseEntity with value from the Handler class)

public class ApplicationDbContext : BaseApplicationDbContext<Entity>
{
    public ApplicationDbContext(DbContextOptions options)
        : base(options)
    {
    }

    public override async Task HandleSomething(BaseEntity baseEntity)
    {
        var entityWithSubEntities = Entity
             .Include(x => x.SubEntity1)
             .Include(x => x.SubEntity2);
    }
}

public class Entity : BaseEntity
{
    public SubEntity1 SubEntity1 { get; set; }
    public SubEntity2 SubEntity2 { get; set; }
}

And in the Program.cs file I am injecting the dependencies:

class Program
{
    static void Main(string[] args)
    {
        //setup our DI
        var serviceProvider = new ServiceCollection()
            .AddPubSubAsHostedService() //This is to subscribe a PubSub which will fire the Handler class from ClassLibrary2 when a Message is comming in
            .AddDbContext<ApplicationDbContext>((serviceProvider, dbOptionsBuilder) =>
            {
                dbOptionsBuilder.UseNpgsql("dbConnectionString");
            })
            .AddScoped<BaseApplicationDbContext<Entity>, ApplicationDbContext>()
            .BuildServiceProvider();


        Console.WriteLine("Hello World!");
    }
}

Question: In the Handler class how can I get the instance of the BaseApplicationDbContext which is being implemented by the ApplicationDbContext and using the Entity class? -> this following line is returning null:

using var applicationDbContext = scope.ServiceProvider.GetService<BaseApplicationDbContext<BaseEntity>>();

Answer 1

There's a couple problems here. First, the MS DI library is quite limited in terms of inheritance and registering open generic types. It's a bare-bones DI, originally designed with the idea that people would use a "real DI" in production apps, but that usually doesn't happen (and often can't happen, unfortunately).

The other problem is that the code is designed assuming generic variance holds for classes, which just isn't the case. Eg, this code will fail to compile :

BaseApplicationDbContext<Entity> context = null;
BaseApplicationDbContext<BaseEntity> baseContext = context;

So, even ignoring the DI limitations (for now), what you're trying to do just won't work. You can't have an instance of BaseApplicationDbContext<Entity> and treat it as an instance of BaseApplicationDbContext<BaseEntity> .

First, I'd take a step back and reconsider the design. Do you really need a BaseEntity ? Or a BaseApplicationDbContext ? If this complexity is necessary , then fine; but do not create abstractions without needing to. Premature abstraction only causes complexity; it doesn't solve any real problems (it only attempts to solve future problems, and may or may not have the correct solution).

But, assuming that the design is solid and appropriate, then you'll need to solve this by using interfaces. Interfaces allow multiple implementations, and as a bonus they can also allow generic variance.

Eg :

public interface IEntityHandler
{
    Task HandleSomething(BaseEntity baseEntity);
}
    
public class BaseApplicationDbContext<TEntity> : IEntityHandler
    where TEntity : BaseEntity
{
    ...
}

Then you can use IEntityHandler instead.

Or, using generic variance to increase type safety ( fiddle ):

public interface IEntityHandler<in TEntity>
{
    Task HandleSomething(TEntity entity);
}
    
public class BaseApplicationDbContext<TEntity> : IEntityHandler<TEntity>
    where TEntity : BaseEntity
{
    ...
    public abstract Task HandleSomething(TEntity entity);
}

Once you get the shape of what you want working, then attack the DI side of it. You'll need to register and resolve your own interface type; the MS DI won't register it for you.