C#.Net Core 2 DI，如何使用 class 注册接口，该接口也采用与构造函数相同的接口作为参数（装饰器）

Question

I have a Repository that implement a IRepository interface. I have created a CachedRepository that also implement IRepository but it take a IRepository as constructor argument. Also, I know that I will eventually create an Oracle11Repository that inherit Repository to override some Repository method.

My objectif is to be able to swap these 3 Repositorys in the startup.cs without modifying the rest of the app.

How can I register the IRepository to use CachedRepository, specifying that the CachedRepository must use the Repository as is own IRepository?

Obviously, i got the error "A circular dependency was detected for the service of type 'IRepository'"

Or maybe it's my approch that is not correct?

//Repository.cs
public class Repository : IRepository
{
        private readonly IDbConnectionFactory dbFactory;
        private readonly ILogger<Repository> logger;

        public AssessmentRepository(IDbConnectionFactory dbFactory, ILogger<Repository> logger, IConfiguration configuration)
        {
            this.dbFactory = dbFactory;
            this.logger = logger;
        }

        public async Task<PagedEnvelope<SearchResult>> Search(string term)
        {}
}

//CachedRepository.cs
public class Repository : IRepository
{
        private IRepository repos;
        private readonly ILogger<Repository> logger;
        private IMemoryCache cache;

        public CachedREpository(IRepository repos, ILogger<Repository> logger,  IMemoryCache cache, IConfiguration configuration)
        {
            this.repos = repos;
            this.logger = logger;
            ConfigureCache(cache, configuration);
        }

        public async Task<PagedEnvelope<SearchResult>> Search(string term)
        {
            // If not in cache, call repos.Search(term) then cache and return 
        }
}

//Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    //...
    services.AddTransient<IRepository, CachedRepository>();
}

Answer 1

It looks to me like you need to set up Repository as a base class for your functionality, and a base interface that will make bases consistent for future injection, so a rename and a new interface might be in order. So lets say your database is SQL, and your Repository class declaration would become

public class SqlRepository : IRepositoryBase
{
    // SQL Specific Search Method
}

and the base repository interface is now

public interface IRepositoryBase
{
    public Task<PagedEnvelope<SearchResult>> Search(string term);
}

You now have an implementation specific to your SQL access and an interface for injection, and then you inject it into your CachedRepository class like below.

public class CachedRepository : IRepository
{
    private IRepositoryBase _reposBase;
    private IMemoryCache _cache;

    public CachedREpository(IRepositoryBase reposBase,   
                        IMemoryCache cache, 
                        IConfiguration configuration)
    {
        this._reposBase = reposBase;
        this._cache = cache;
        // Note I took the logger out, you have it in the _reposBase object now. 
        ConfigureCache(cache, configuration);
    }

    public async Task<PagedEnvelope<SearchResult>> Search(string term)
        {
            // If not in cache, call _reposBase.Search(term) then cache and return 
        }

}  

Now in your Startup class, you can use 2 injections to configure it how you want it:

//Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    //...
    // Set up injection for Base first
    services.AddTransient<IRepositoryBase, SqlRepository>();

    // Then set up injection for your Cached repo
    services.AddTransient<IRepository, CachedRepository>();
}

Now you have some flexibility built in, because to change to an Oracle DB, you just create the Oracle repository base:

public class OracleRepository : IRepositoryBase
{
    // Oracle Specific Search Method
}

and then in your DI container just change the line

services.AddTransient<IRepositoryBase, SqlRepository>();

to

 services.AddTransient<IRepositoryBase, OracleRepository>();

and you've switched database implementations by adding 1 new DB class, and then changing 1 line in startup, and this leaves your caching behavior alone.

Above discusses switching your base database, but you could of course change the level up as well, so CachedRepository can be switched out for anything that implements the IRepository interface, so you get the flexibility built into that layer as well.

From what I read of your question I think I understand and this appears to solve your problem. No more circular dependency.

Please comment if not, hope this helps!

Answer 2

I finaly find a way to acheive that.

//Startup.cs
public void ConfigureServices(IServiceCollection services)
{
  //...
  // Register a concrete implementation so DI know how to construct it with dependency
  services.AddTransient<Oracle11Repository>();

  // Register a call back to tell specific IRepository to inject
  services.AddTransient<IRepository>(sp =>
                new CachedRepository(
                    sp.GetService<Oracle11Repository>(),
                    sp.GetService<ILogger<CachedRepository>>(),
                    sp.GetService<IMemoryCache>(),
                    sp.GetService<IConfiguration>())
  );

Now it would be nice to not have to specify all others constructors arguments since they are all registred.