Top 17 Dependency Injection Interview Questions And Answers

Question 1

What is _Dependency Injection_?

Accepted Answer

**Dependency injection** makes it easy to create loosely coupled components, which typically means that components consume functionality defined by interfaces without having any first-hand knowledge of which implementation classes are being used.

*Dependency injection* makes it easier to change the behaviour of an application by changing the components that implement the interfaces that define application features. It also results in components that are easier to isolate for unit testing.

Question 2

What is IoC (DI) Container?

Accepted Answer

A **Dependency Injection** container, sometimes, referred to as **DI container** or **IoC container**, is a framework that helps with DI. It 
* _creates_ and 
* _injects_

dependencies for us automatically.

Question 3

What is _Inversion of Control_?

Accepted Answer

The **`Inversion-of-Control` (IoC)** pattern, is about providing _any kind_ of `callback` (which controls reaction), instead of acting ourself directly (in other words, inversion and/or redirecting control to the external handler/controller).

Inversion of Controls is also about separating concerns.

* **Without IoC**: You have a **laptop** computer and you accidentally break the screen. And darn, you find the same model laptop screen is nowhere in the market. So you're stuck.

* **With IoC**: You have a **desktop** computer and you accidentally break the screen. You find you can just grab almost any desktop monitor from the market, and it works well with your desktop.

Your desktop successfully implements IoC in this case. It accepts a variety type of monitors, while the laptop does not, it needs a specific screen to get fixed.

Question 4

What are some _advantages_ of using Dependency Injection

Accepted Answer

**Dependency injection** is basically providing the objects that an object needs (its dependencies) instead of having it construct them itself. When using dependency injection, objects are given their dependencies _at run time rather than compile time (car manufacturing time)_.

- It allows your code to be more loosely coupled because classes do not have hard-coded dependencies
- Decoupling the creation of an object (in other words, separate usage from the creation of an object)
- Making isolation in unit testing possible/easy. It is harder to isolate components in unit testing without dependency injection.
- **Explicitly** defining dependencies of a class
- Facilitating good design like the single responsibility principle (SRP) for example
- Promotes _Code to an interface, not to implementation_ principle
- Enabling switching/ability to replace dependencies/implementations quickly (`DbLogger` instead of `ConsoleLogger` for example)

Question 5

What exactly is IoC and DI? How are they related?

Accepted Answer

The **`Inversion-of-Control` (IoC)** pattern, is about providing _any kind_ of `callback` (which "implements" and/or controls reaction), instead of acting ourselves directly (in other words, inversion and/or redirecting control to the external handler/controller).

> For example, rather than having the application call the implementations provided by a _library_ (also know as _toolkit_), a _framework_ calls the implementations provided by the application.

The **`Dependency-Injection` (DI)** pattern is a more specific version of IoC pattern, where implementations are passed into an object through constructors/setters/service lookups, which the object will 'depend' on in order to behave correctly.

> Every `DI` implementation can be considered `IoC`, but one should not call it `IoC`, because implementing Dependency-Injection is harder than callback (Don't lower your product's worth by using the general term "IoC" instead).

* **IoC without using DI**, for example, would be the Template pattern because the implementation can only be changed through sub-classing.
* **DI frameworks** are designed to make use of DI and can define interfaces (or Annotations in Java) to make it easy to pass in the implementations.
* **IoC containers** are DI frameworks that can work outside of the programming language. In some, you can configure which implementations to use in metadata files (e.g. XML) which are less invasive.

Question 6

Explain the IoC (DI) Container service lifetimes?

Accepted Answer

When we register services in a container, we need to set the lifetime that we want to use. The service lifetime controls how long a result object will live after it has been created by the container.

There are three lifetimes that can be used with Microsoft Dependency Injection Container, they are:

- **Transient** — Services are created **each time they are requested**. It gets a new instance of the injected object, on each request of this object. For each time you inject this object is injected in the class, it will create a new instance.
- **Scoped** — Services are created **on each request** (once per request). This is most recommended for WEB applications. So for example, if during a request you use the same dependency injection, in many places, you will use the same instance of that object, it will make reference to the same memory allocation.
- **Singleton** — Services are created **once for the lifetime of the application**. It uses the same instance for the whole application.

![https://i.stack.imgur.com/M0le5.jpg](https://i.stack.imgur.com/M0le5.jpg)

Question 7

How can you create your own _Scope_ for a _Scoped_ object in .NET?

Accepted Answer

Scoped lifetime actually means that within a created “scope” objects will be the same instance. It just so happens that within .Net Core, it wraps a request within a “scope”, but you can actually create scopes manually. For example : Consider: ```cs public void ConfigureServices(IServiceCollection services) { services.AddScoped(); var serviceProvider = services.BuildServiceProvider(); var serviceScopeFactory = serviceProvider.GetRequiredService(); IMyScopedService scopedOne; IMyScopedService scopedTwo; using (var scope = serviceScopeFactory.CreateScope()) { scopedOne = scope.ServiceProvider.GetService(); } using (var scope = serviceScopeFactory.CreateScope()) { scopedTwo = scope.ServiceProvider.GetService(); } Debug.Assert(scopedOne != scopedTwo); } ``` In this example, the two scoped objects aren’t the same because created each object within their own _scope_.

Question 8

Why do I need an IoC container as opposed to straightforward DI code?

Accepted Answer

Compare this:

```csharp
var svc = new ShippingService(new ProductLocator(), 
   new PricingService(), new InventoryService(), 
   new TrackingRepository(new ConfigProvider()), 
   new Logger(new EmailLogger(new ConfigProvider())));
```

over this:

```csharp
var svc = IoC.Resolve<IShippingService>();
```

Your dependencies chain can become nested, and it quickly becomes unwieldy to wire them up manually. Even with factories, the duplication of your code is just not worth it.

Question 9

What are some _best practices_ for implementing services for DI?

Accepted Answer

When designing services for dependency injection:

- Avoid stateful, static classes and members. Avoid creating a global state by designing apps to use singleton services instead.
- Avoid direct instantiation of dependent classes within services. Direct instantiation couples the code to a particular implementation.
- Make services small, well-factored, and easily tested.

If a class _has many injected dependencies_, it might be a sign that the class has too many responsibilities and violates the Single Responsibility Principle (SRP). Attempt to refactor the class by moving some of its responsibilities into new classes.

Question 10

When to use _Transient_ vs _Scoped_ vs _Singleton_ DI service lifetimes?

Accepted Answer

**Transient**

- they are created every time _per code request_
- they will use **more memory** & Resources and can have a **negative** impact on performance
- a new instance is provided every time a service instance is requested whether it is in the scope of the same HTTP request or across different HTTP requests,
- use this for the **lightweight** service with little or **no state**
- if you're only doing computation, for instance, that can be transient scoped because you're not exhausting anything by having multiple copies
- use a transient scope unless you have a good, explicit reason to make it a singleton. That would be the reasons like maintaining state, utilizing limited resources efficiently

**Scoped**

- a better option when you want to maintain the state within a _request_,
- It is equivalent to a singleton in the current scope 
- in MVC it creates one instance for each HTTP request, but it uses the same instance in the other calls within the same web request
- normally we will use this for SQL connection, which means it will create and dispose the SQL connection per request

**Singleton**

- memory leaks in these services will build up over time,
- also memory efficient as they are created once reused everywhere,
- use you when need to maintain an application-wide state,
- singletons are best when you're utilizing limited resources, like sockets and connections. If you end up having to create a new socket every time the service is injected (transient), then you'll quickly run out of sockets and then performance really will be impacted
- If something needs to persist past one particular operation, then transient won't work, because you'll have no state, because it will essentially start over each time it's injected

Application configuration or parameters, Logging Service caching of data is some of the examples where you can use singletons.

Top 17 Dependency Injection Interview Questions

What is Dependency Injection?

What is IoC (DI) Container?

Why do I need an IoC container as opposed to straightforward DI code?

What is Inversion of Control?

What exactly is IoC and DI? How are they related?

Explain the IoC (DI) Container service lifetimes?

What are some advantages of using Dependency Injection

How can you create your own Scope for a Scoped object in .NET?

Do I need Dependency Injection in Node.js and how to deal with it?

What is the Dependency Inversion Principle (DIP) and why is it important?

What are some disadvantages of Dependency Injection?

When using DI in Controller shall I call `IDisposable` on any injected service?

When to use Transient vs Scoped vs Singleton DI service lifetimes?

What are some best practices for implementing services for DI?

Explain what is Object Lifetime Management when using DI?

How to Dispose resources with Dependency Injection?

What's the difference between the Dependency Injection and Service Locator patterns?

Top 17 Dependency Injection Interview Questions

What is Dependency Injection?

What is IoC (DI) Container?

Why do I need an IoC container as opposed to straightforward DI code?

What is Inversion of Control?

What exactly is IoC and DI? How are they related?

Explain the IoC (DI) Container service lifetimes?

What are some advantages of using Dependency Injection

How can you create your own Scope for a Scoped object in .NET?

Do I need Dependency Injection in Node.js and how to deal with it?

What is the Dependency Inversion Principle (DIP) and why is it important?

What are some disadvantages of Dependency Injection?

When using DI in Controller shall I call IDisposable on any injected service?

When to use Transient vs Scoped vs Singleton DI service lifetimes?

What are some best practices for implementing services for DI?

Explain what is Object Lifetime Management when using DI?

How to Dispose resources with Dependency Injection?

What's the difference between the Dependency Injection and Service Locator patterns?

When using DI in Controller shall I call `IDisposable` on any injected service?