Création angulaire d'instances nommées de fournisseurs

Question

En Angulaire, j'ai un service pour accéder à un cache. Le service fonctionne à peu près comme ça (mais avec beaucoup plus de comportement asynchrone).

@Injectable() 
export class Cache { 

    cache : CacheTable; 

    constructor(
    protected name : string 
) { 
    this.cache = this.getTable(name); 
    } 

    put(id:string, data:any):void { this.cache.put(id, data); } 
    get(id:string):any { return this.cache.get(id); } 

    getTable(name : string) : CacheTable; 

} 

Maintenant, j'ai un certain nombre de services comme UserService qui aimeraient avoir un Cache correspondant à new Cache('user');. Un autre service appelé ImageService devrait fonctionner avec une instance de Cache correspondant à new Cache('image');

Pour cela, je voudrais créer une usine pour fournir ces:

// file: custom-caches.ts 

import { Provider } from '@angular/core'; 
import { Cache } from '../cache/cache'; 

export let userCache : Provider = { 
    provide: Cache, 
    useFactory:() => new Cache('user') 
}; 

export let imageCache : Provider = { 
    provide: Cache, 
    useFactory:() => new Cache('image') 
}; 

Comment pourrais-je aller sur l'enregistrement et l'utilisation de chacun de ces services ? Autant que je sache, ils sont tous enregistrés comme 'Cache'.

// file: my.module.ts 

@NgModule({ 
    providers: [userCache, imageCache] 
}) 
export class MyModule {} 

(Cela concerne my other question)

Answer 1

Comme suggéré par @ghetolay je InjectionToken et a pu créer avec succès plusieurs fournisseurs désignés comme des instances factoried:

// file: custom-caches.ts 

import { Provider } from '@angular/core'; 
import { Cache } from '../cache/cache'; 

export const UserCache = new InjectionToken('userCache'); 

export let userCacheProvider : Provider = { 
    provide: UserCache, 
    useFactory:() => new Cache('user') 
}; 

export const ImageCache = new InjectionToken('imageCache'); 

export let imageCacheProvider : Provider = { 
    provide: ImageCache, 
    useFactory:() => new Cache('image') 
}; 

_

// file: my.module.ts 

@NgModule({ 
    providers: [userCacheProvider, imageCacheProvider] 
}) 
export class MyModule {} 

_

// file : UserService 

@Injectable() 
export class UserService { 
    constructor(
    @Inject(UserCache) private cache : Cache 
) {} 
} 

UserCache et ImageCache sont les jetons maintenant pour ces instances de fournisseur.