Skip to main content

Dependency Injection (DI) FAQs - Angular

What Is a Dependency?
When module X in an application needs module Y to run, then module Y is a dependency of module X. 
What Is Dependency Injection (DI)?
Dependency Injection is a powerful pattern for managing code dependencies. DI is a way to create objects that depend upon other objects.

Angular has its own DI framework pattern, and you really can't build an Angular application without Dependency injection (DI).

A DI system supplies the dependent objects when it creates an instance of an object.
Let us take an example of a CAR. The CAR consists of following things -
1.      Wheel
2.      Headlight
3.      Outer door
4.      Inner door
5.      Glass
6.      Window
7.      Fuel level sensor

So to complete the CAR, we need those eight and so many things.

In this example, we need to require total seven and many more classes to build a fully functional CAR.
1.      Car class
2.      Wheel class
3.      Headlight class
4.      Outer door class
5.      Inner door class
6.      Glass class
7.      Window class
8.      Fuel level sensor class

Let’s see what happen, without Dependency Injection (DI)
To complete the CAR class, we need to import all eight classes here and make one fully functional CAR.

Now, here we have created eight classes instance in the constructor of CAR class.

Note that, the CAR class is totally dependent on these eight classes. Otherwise, it will not complete the CAR.

We are creating the instances in the CAR constructor. So Wheel, Headlight, Outer door, Inner door, Glass, Window, and Fuel are not decoupled from the CAR class.

Let’s see what happen, with Dependency Injection (DI)
If we are using Dependency Injection then, we do not need to create the instances in the constructor.

First, we need to provide all the dependencies to the “app.module.ts” class -
import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';

//Import App Component
import { AppComponent } from './app.component';

//Import CAR classes.
import {Wheel} from './car/wheel';
import {Headlight} from './car/headlight';
import {Glass} from './car/glass';
import {InnerDoor} from './car/inner-door';
import {OuterDoor} from './car/outer-door';
import {Window} from './car/window';
import {FuelLevel} from './car/fuel-level';

//AppModule class with @NgModule decorator.
  //Static, This is the compiler configuration
  //declarations is used for configure the selectors.
  declarations: [

  //Composability and Grouping
  // imports used for composing NgModules together.
  imports: [
  //Runtime or injector configuration
  //providers is used for runtime injector configuration.
  providers: [Wheel, Headlight, Glass, InnerDoor, OuterDoor, Window, FuelLevel],

  //bootstrapped entry component
  bootstrap: [AppComponent]
export class AppModule { }

In providers array, we need to provide all eight dependencies.

Then, In the CAR class, inject those dependencies into CAR constructor –
import {Wheel} from './car/wheel';
import {Headlight} from './car/headlight';
import {Glass} from './car/glass';
import {InnerDoor} from './car/inner-door';
import {OuterDoor} from './car/outer-door';
import {Window} from './car/window';
import {FuelLevel} from './car/fuel-level';

export class Car {
    constructor(public wheel: Wheel,
                public headlight: Headlight,
                public glass: Glass,
                public innerdoor: InnerDoor,
                public outerdoor: OuterDoor,
                public window: Window,
                public fuellevel: FuelLevel) {}


When CAR instance is created at that time, also all the other instances of other classes are also created.

What Is Dependency Injection pattern?
DI is an application design pattern and you really cannot build an Angular application without dependency injection (DI).

For more detail, refer the above questions.

What Is Injectors?
A service is just a class in Angular until you register with an Angular dependency injector.

The injector is responsible for creating angular service instances and injecting them into classes.

You rarely create an injector yourself and Angular creates automatically during the bootstrap process.

Angular doesn't know automatically how you want to create instances of your services or injector. You must configure it by specifying providers for every service. Actually, providers tell the injector how to create the service and without a provider not able to create the service.

Bootstrap defines the components that should be bootstrapped when this module is bootstrapped. The components listed here will automatically be added to entryComponents.

Explore in detail by using above questions, What Is an entryComponents?

What Are @Injectable providers?
The @Injectable decorator identifies services and other classes that are intended to be injected. It can also be used to configure a provider for those services.

To inject the service into a component, Angular provides an Injector decorator: @Injectable().
A provider defines the set of injectable objects that are available in the injector of this module.

The @Injectable decorator marks a class as available to an injector for instantiation. An injector reports an error when trying to instantiate a class that is not marked as @Injectable.

Injectors are also responsible for instantiating components. At the run-time the injectors can read class metadata in the JavaScript code and use the constructor parameter type information to determine what things to inject.

Injectable decorator and metadata -
  providedIn?: Type<any> | 'root' | null
  factory: () => any

To inject the service into a component, Angular provides an Injector decorator: @Injectable().
Here we configure a provider for CustomerService using the @Injectable decorator on the class.

We have the following steps to create a Service-
1.      Create the service class
2.      Define the metadata with a decorator
3.      Import what we need.

In the above example, providedIn tells Angular that the root injector is responsible for creating an instance of the CustomerService.

The Angular CLI sets up provider automatically when you generating a new service.

Why @Inject()?
The @Inject is a special technique for letting Angular knows that a parameter must be injected.

Inject decorator and metadata-
  token: any

When @Inject () is not present, Injector will use the type annotation of the parameter.
import { Component, OnInit, Inject } from '@angular/core';
import { HttpClient } from '@angular/common/http';

  selector: 'app-customer',
  templateUrl: './customer.component.html',
  styleUrls: ['./customer.component.css']

export class CustomerComponent implements OnInit {

  constructor(@Inject(HttpClient) private http) {
    // use this.http which is the Http provider.

  ngOnInit(){ }

At this point, @Inject is a manual way of specifying this lookup token, followed by the lowercase http argument to tell Angular what to assign it against.

What Is Hierarchical Dependency Injectors?
Angular has a Hierarchical Dependency Injection system. There is actually a tree of injectors that parallel an application's component tree. You can reconfigure the injectors at any level of that component tree.

What Is Injector tree?
In the Dependency Injection guide, you learned how to configure a dependency injector and how to retrieve dependencies where you need them.

An application may have multiple injectors. An Angular application is a tree of components. Each component instance has its own injector. The tree of components parallels the tree of injectors.

Three level component tree – 

What Is Injector bubbling?
Refer the above questions.
By Anil Singh | Rating of this article (*****)

Popular posts from this blog

39 Best Object Oriented JavaScript Interview Questions and Answers

Most Popular 37 Key Questions for JavaScript Interviews. What is Object in JavaScript? What is the Prototype object in JavaScript and how it is used? What is "this"? What is its value? Explain why "self" is needed instead of "this". What is a Closure and why are they so useful to us? Explain how to write class methods vs. instance methods. Can you explain the difference between == and ===? Can you explain the difference between call and apply? Explain why Asynchronous code is important in JavaScript? Can you please tell me a story about JavaScript performance problems? Tell me your JavaScript Naming Convention? How do you define a class and its constructor? What is Hoisted in JavaScript? What is function overloadin

List of Countries, Nationalities and their Code In Excel File

Download JSON file for this List - Click on JSON file    Countries List, Nationalities and Code Excel ID Country Country Code Nationality Person 1 UNITED KINGDOM GB British a Briton 2 ARGENTINA AR Argentinian an Argentinian 3 AUSTRALIA AU Australian an Australian 4 BAHAMAS BS Bahamian a Bahamian 5 BELGIUM BE Belgian a Belgian 6 BRAZIL BR Brazilian a Brazilian 7 CANADA CA Canadian a Canadian 8 CHINA CN Chinese a Chinese 9 COLOMBIA CO Colombian a Colombian 10 CUBA CU Cuban a Cuban 11 DOMINICAN REPUBLIC DO Dominican a Dominican 12 ECUADOR EC Ecuadorean an Ecuadorean 13 EL SALVADOR

25 Best Vue.js 2 Interview Questions and Answers

What Is Vue.js? The Vue.js is a progressive JavaScript framework and used to building the interactive user interfaces and also it’s focused on the view layer only (front end). The Vue.js is easy to integrate with other libraries and others existing projects. Vue.js is very popular for Single Page Applications developments. The Vue.js is lighter, smaller in size and so faster. It also supports the MVVM ( Model-View-ViewModel ) pattern. The Vue.js is supporting to multiple Components and libraries like - ü   Tables and data grids ü   Notifications ü   Loader ü   Calendar ü   Display time, date and age ü   Progress Bar ü   Tooltip ü   Overlay ü   Icons ü   Menu ü   Charts ü   Map ü   Pdf viewer ü   And so on The Vue.js was developed by “ Evan You ”, an Ex Google software engineer. The latest version is Vue.js 2. The Vue.js 2 is very similar to Angular because Evan You was inspired by Angular and the Vue.js 2 components looks like -

React | Encryption and Decryption Data/Text using CryptoJs

To encrypt and decrypt data, simply use encrypt () and decrypt () function from an instance of crypto-js. Node.js (Install) Requirements: 1.       Node.js 2.       npm (Node.js package manager) 3.       npm install crypto-js npm   install   crypto - js Usage - Step 1 - Import var   CryptoJS  =  require ( "crypto-js" ); Step 2 - Encrypt    // Encrypt    var   ciphertext  =  CryptoJS . AES . encrypt ( JSON . stringify ( data ),  'my-secret-key@123' ). toString (); Step 3 -Decrypt    // Decrypt    var   bytes  =  CryptoJS . AES . decrypt ( ciphertext ,  'my-secret-key@123' );    var   decryptedData  =  JSON . parse ( bytes . toString ( CryptoJS . enc . Utf8 )); As an Example,   import   React   from   'react' ; import   './App.css' ; //Including all libraries, for access to extra methods. var   CryptoJS  =  require ( "crypto-js" ); function   App () {    var   data

.NET Core MVC Interview Questions and Answers

» OOPs Interview Questions Object Oriented Programming (OOP) is a technique to think a real-world in terms of objects. This is essentially a design philosophy that uses a different set of programming languages such as C#... Posted In .NET » .Net Constructor Interview Questions A class constructor is a special member function of a class that is executed whenever we create new objects of that class. When a class or struct is created, its constructor is called. A constructor has exactly the same name as that of class and it does not have any return type… Posted In .NET » .NET Delegates Interview Questions Delegates are used to define callback methods and implement event handling, and they are declared using the "delegate" keyword. A delegate in C# is similar to function pointers of C++, but C# delegates are type safe… Posted In .NET » ASP.Net C# Interview Questions C# was developed by Microsoft and is used in essentially all of their products. It is mainly used for