Multi-provider angolare 2 per l'esportazione delle dipendenze della dipendenza

Question

Sto per utilizzare un multi-provider per esportare le dipendenze della mia dipendenza insieme a se stesso, in modo che possano essere iniettate in un componente contemporaneamente.

Per un componente

import {Component} from 'angular2/core'; 
import { FOO_PROVIDERS } from './foo'; 

@Component({ 
    selector: 'app', 
    providers: [FOO_PROVIDERS] 
}) 
export class App {} 

il following

import {Inject, Injectable, provide} from 'angular2/core'; 
import {Http, HTTP_PROVIDERS} from 'angular2/http'; 

export class Foo { 
    constructor(@Inject(Http) http) {} 
} 

export const FOO_PROVIDERS = [ 
    provide(Foo, { useClass: Foo, multi: true }), 
    provide(Foo, { useValue: HTTP_PROVIDERS, multi: true }) 
]; 

si tradurrà in

Nessun provider per HTTP! (App -> Foo -> Http)

E this

import {Inject, provide} from 'angular2/core'; 
import {Http, HTTP_PROVIDERS} from 'angular2/http'; 

class Foo { 
    constructor(@Inject(Http) http) {} 
} 

export const FOO_PROVIDERS = [Foo, HTTP_PROVIDERS]; 

funzionerà bene, mentre mi aspetto che facciano il lavoro simile.

C'è un uso corretto per multi-provider in questo caso?

Answer 1

Al momento della registrazione provide(Foo, ...), di quanto si può

constructor(foo:Foo) 

con multi: true vieni superato tutti i fornitori registrate come Foo

constructor(foo:any) 

Con

export const FOO_PROVIDERS = [ 
    provide(Foo, { useClass: Foo, multi: true }), 
    provide(Foo, { useValue: HTTP_PROVIDERS, multi: true }) 
]; 

e

constructor(@Inject(Foo) foo:Foo[]) 

si otterrebbe passato a foo una matrice contenente un'istanza di Foo e come seconda voce di un elenco di fornitori (questi contenuti in HTTP_PROVIDERS)

aggiornamento

Forse si hanno aspettative diverse di cosa dovrebbe accadere. Non vedo come @Inject(Http) http è correlato qui. HTTP_PROVIDERS è registrato solo come valore per Foo. Il valore che si ottiene a useValue è irrilevante quando i provider vengono risolti. DI ricerca provider per Foo e ha passato il valore assegnato e non si preoccupa affatto di quel valore. Nel tuo esempio non esiste un provider per , pertanto Foo non è stato in grado di ottenere l'iniezione Http.Si avrebbe bisogno di registrare Http, che è fatto quando si aggiunge HTTP_PROVIDERS direttamente ai fornitori (non in useValue) perché HTTP_PROVIDERS contiene Http (che equivale a provide(Http, {useClass: Http})

Update2

// An injected service that itself needs to get passed in a dependency 
@Injectable() 
class Foo { 
    constructor(private http:Http); 
} 

// container for a bunch of dependencies  
@Injectable() 
class MyProviders { 
    // add everything you want to make available in your components 
    constructor(public foo:Foo, public bar:Bar, ...); 
} 

class MyComponent { 
    // inject just MyProviders and use the dependencies it provides 
    constructor(private providers: MyProviders) { 
    // access provided values 
    providers.foo.doSomething(); 
    providers.bar.doSomethingElse(); 
    } 
} 

// Add all providers to allow DI to resolve all above dependencies 
bootstrap(AppComponent, [HTTP_PROVIDERS, Foo, Bar]); 

}