理解angular2中的依赖注入

Question

Here is a code snippet

@Component({
     ... : ...
     providers: [MyService]
})
export class MyComponent{

     constructor(private _myService : MyService){
     }

     someFunction(){
          this._myService.getSomething();
     }
}

And Here is my understanding/question how it works in angular2/typescript.

• A singleton object will be created whenever we write MyService in providers .
• Why to give it in a constructor? Can we do it anywhere else?
• whoever calls the constructor (javascript engine maybe), how would it know what to pass in to the arguments
• or I am getting it wrong, it is not even a argument?

EDIT

• what if i provide providers: [MyService] at two controller. Will it create a new instance or fetch from one?

Answer 1

• provider: [ ... ] specifies the scope of the single instance maintained for each provider. The scope is the component where the type is added to the providers: [ ... ] and its descendants (as long as they don't override it with another provider with the same key). Listing a provider in bootstrap(AppComponent, [SomeProvider]) makes it globally available, again as long as not shadowed by a provider on a component.

• Angular2 only supports contructor injections. There are other strategies but they are considered problematic.

• Angular analyzes the contructor parameter to know what parameters need to be passed in when an instance is created, acquires appropriate instances from its providers or parent providers and passes them in.
  For this to work classes need to be decorated with @Injectable() if they are not components, directives or pipes.

• DI (Dependency injection) only passes instances to constructor parameters for instances it created itself. For each instance it creates, it checks the constructor parameters and acquires the matching instances from itself (providers) and passes them in. If one of these dependencies itself again needs constructor parameters, this goes recursively until all dependencies are resolve.
  Jasmine doesn't pass instances to the constructor itself, it has to delegate it to DI instead.

Update to your "Edit"

If the same service is added at different places bootstrap(...) , providers: [...] then a single instance is maintained per each provider.

When a class requests a dependency (by a constructor parameter) the DI looks upwards towards bootstrap() and returns the instance of the first provider it finds. (this is why providers on components shadow providers of ancestor components or bootstrap(...)

Short: yes, two providers of the same service result in two different instance.