ASP.NET Core - Dependency Injection

My controller:

    [Route("api/[controller]")]
    [ApiController]
    public class CategoriesController : ControllerBase
    {
        private readonly IUnitOfWork unitOfWork;

        public CategoriesController(IUnitOfWork unitOfWork)
        {
            this.unitOfWork = unitOfWork;
        }

        [HttpGet]
        [Route("TestCategories")]
        public ActionResult<IEnumerable<Category>> TestCategories()
        {
            return unitOfWork.Categories.FindAll().ToList();
        }
    }

My Startup:

        public void ConfigureServices(IServiceCollection services)
        {
            services.Configure<CookiePolicyOptions>(options =>
            {
                // This lambda determines whether user consent for non-essential cookies is needed for a given request.
                options.CheckConsentNeeded = context => true;
                options.MinimumSameSitePolicy = SameSiteMode.None;
            });

            services.AddDbContext<ClassifiedAdsDbContext>(options => options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
            services.AddScoped<IUnitOfWork, UnitOfWork>();
            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
        }

I did break my app so i can understand how the codes work.

As you can see on my controller i used IUnitOfWork (Interface that comes from MyProject.Domain - class library) 

Scenario:

1. if i use the UnitOfWork class, the only thing the i need to inject (to startup.cs) is the UnitOfWork class only.
2. if i use the IUnitOfWork interface. i need to inject both (to startup.cs) IUnitOfWork interface and UnitOfWork class as well because it gives error see below.

What i know was class library has no composition root, thats why you need to inject them to the application that uses it.

My question is:

1. What is the difference of using UnitOfWork (Class that comes from MyProject.Data - class library) vs IUnitOfWork?

2. Why they often use interface(base) when doing dependency injection in constructor instead of class.

3. How IUnitOfWork works like class even its interface (interface is only declaration why it gives me implementation), as i run the api it gives me the result i wanted, but im wondering how interface has implementation based on my given example.

PS: I have read the articles from the internet (I believe, was I read articles were not enough regarding to this matter) and also microsoft documentation regarding dependency injection, but im still confused how it works, does IUnitOfWork converted to UnitOfWork.

Hoping to enlighthen me.

Sorry for my long post.

Happy Coding!

---

1 Answers