Same Interface used in different Repository , how can access reference

In the context of dependency injection, if you have multiple implementations of the same interface and you want to use a specific implementation in your controller, you can achieve this by configuring your dependency injection container (such as ASP.NET Core's built-in DI container) to inject the correct implementation of the interface into your controller.

Step 1: Register Implementations with Dependency Injection Container

First, you need to register your interface and its implementations with the dependency injection container. This is usually done in the Startup.cs file (for ASP.NET Core applications) within the ConfigureServices method.

public void ConfigureServices(IServiceCollection services)
{
    // Register the implementations of your interface
    services.AddTransient();
    services.AddTransient();
    // Add other services and configurations as needed
}

In this example, Implementation1 and Implementation2 are two different classes implementing IYourInterface.

Step 2: Inject the Interface into Your Controller

Next, you can inject the interface into your controller constructor. The DI container will handle the rest, providing the appropriate implementation based on your registration.

public class YourController : Controller
{
    private readonly IYourInterface _yourInterface;

    public YourController(IYourInterface yourInterface)
    {
        _yourInterface = yourInterface;
    }

    // Now you can use _yourInterface in your controller actions
}

builder.Services.AddScoped();
builder.Services.AddScoped();

 

public class MyController : Controller
{
    private readonly IFirstRepository _firstRepository;
    private readonly ISecondRepository _secondRepository;

    public MyController(IFirstRepository firstRepository, ISecondRepository secondRepository)
    {
        _firstRepository = firstRepository;
        _secondRepository = secondRepository;
    }

    // Your controller actions here...
}

1. The Dependency Injection container will resolve and provide the correct repository implementation based on the constructor parameter types.

2. Use the Correct Repository:

   You can now use _firstRepository and _secondRepository in your controller actions to access the methods and data provided by each repository. The DI container ensures that you get the appropriate repository instance based on the interface you requested in the constructor.

An interface can point to any concrete object at run time, the behavior is decided by the dependency container if you have registered your IAnimal interface with Cat then IAnimal will be replaced by an object of Cat.

builder.Services.AddScoped();

public class MyController:IController
{
private readonly IAnimal _animal;
public MyController(IAnimal animal)
{
   _animal=animal;  //animal= new Cat() by DI;
}

}