CODEWITHSUNDEEP
c#asp.net-core
Austin_Anderson
Austin_Anderson

Reputation: 940

asp.net core dependency passing dependencies along

I'm trying to inject a dependency into a class used internally in a controller,

I have 

//Startup.cs
public void ConfigureServices(IServiceCollection services){
    services.AddMvc();//IDocumentService is a WCF service from our legacy stack
    services.AddScoped(typeof(IDocumentService),typeof(DocumentServiceClient));
}
//Controller.cs
[Route("api/eci/test/[action]")]
public class Controller{
    private IDocumentService injectedDocService;
    public Controller(IDocumentService client){
        injectedDocService=client;
    }
    [HttpPost({"id"})]
    public void ingestedDocs(string id){
        new Logic(injectedDocService).ingest(id);
    }
}
//Logic.cs
public class Logic{
    private IDocumentService injectedDocServiceActualTarget;
    public Logic(IDocumentService injected2){
        injectedDocServiceActualTarget=injected2;
    }
    public void injest(string id){
        injectedDocServiceActualTarget.doWork(id);
    }
}

It seems a little redundant to have it injected to the target class's parent. Is this the right way of doing things?

Upvotes: 1

Views: 159

Answers (2)

Nkosi
Nkosi

Reputation: 247108

You should abstract the Logic behind an interface, only exposing the members that are to be used by dependents.

public interface ILogic {
    void injest(string id);
}

Have the Logic class derive from the abstraction.

//Logic.cs
public class Logic : ILogic {
    private readonly IDocumentService injectedDocServiceActualTarget;

    public Logic(IDocumentService injected2) {
        this.injectedDocServiceActualTarget=injected2;
    }

    public void injest(string id) {
        injectedDocServiceActualTarget.doWork(id);
    }
}

The Controller should now only explicitly depend on the ILogic interface

//Controller.cs
[Route("api/eci/test/[action]")]
public class Controller {
    private readonly ILogic service;

    public Controller(ILogic service) {
        this.service = service;
    }

    [HttpPost({"id"})]
    public void ingestedDocs(string id) {
        service.ingest(id);
    }
}

With that the last thing to do is to register all dependencies with the service collection.

//Startup.cs
public void ConfigureServices(IServiceCollection services){
    services.AddMvc();
    services.AddScoped<IDocumentService, DocumentServiceClient>();
    services.AddScoped<ILogic, Logic>();
}

So now when the controller is called all dependencies will be resolved and injected into their respective dependents.

Upvotes: 1

Alexey Zimarev
Alexey Zimarev

Reputation: 19610

You need to register the Logic, then inject it to the controller. DocumentService will be injected to the Logic then.

The idea behind dependency injection is to implement the IoC (inversion of control) principle. In your example, it is only partial, since you explicitly instantiate Logic in your controller. If you want to do the dependency inversion properly - all your dependencies need to be passed as constructor parameters.

Upvotes: 1

Related Questions