crear - servicios angular 6

Cómo inyectar servicio en clase(no componente)

Question

Quiero inyectar servicio en clase que no sea componente.

Por ejemplo

Myservice

import {Injectable} from ''@angular/core'';
@Injectable()
export class myService{
dosomething(){
//implementation
}
}

Mi clase

import { myService } from ''./myService''
export class MyClass{
constructor(private myservice:myService){
}
test(){
this.myservice.dosomething();
}
}

esta solución no funciona (creo que porque MyClass aún no se ha instanciado).

¿Hay otra forma de usar el servicio en clase (no componente)? o está mal cómo diseño el código (para usar el servicio en una clase, no en un componente)

Gracias.

Answer 1

Esto es algo ( muy ) hacky, pero pensé que también compartiría mi solución. Tenga en cuenta que esto solo funcionará con los servicios Singleton (¡inyectados en la raíz de la aplicación, no componente!), Ya que viven tanto tiempo como su aplicación, y solo hay una instancia de ellos.

Primero, a su servicio:

@Injectable()
export class MyService {
static instance: MyService;
constructor() {
MyService.instance = this;
}
doSomething() {
console.log("something!");
}
}

Luego en cualquier clase:

export class MyClass {
constructor() {
MyService.instance.doSomething();
}
}

Esta solución es buena si desea reducir el desorden de código y, de todos modos, no está utilizando servicios no únicos.

Answer 2

Las inyecciones solo funcionan con clases instaladas por la inyección de dependencia de Angulares (DI).

1. Necesitas
   • agregue @Injectable() a MyClass y
   • proporcionar MyClass como providers: [MyClass] en un componente o NgModule.

Cuando luego inyecta MyClass algún lugar, una instancia de MyService se pasa a MyClass cuando DI la instancia (antes de que se inyecte la primera vez).

2. Un enfoque alternativo es configurar un inyector personalizado como

constructor(private injector:Injector) {
let resolvedProviders = ReflectiveInjector.resolve([MyClass]);
let childInjector = ReflectiveInjector.fromResolvedProviders(resolvedProviders, this.injector);
let myClass : MyClass = childInjector.get(MyClass);
}

De esta forma, myClass será una instancia de MyClass , instanciada por Angulars DI, y myService se inyectará en MyClass cuando se instancia.
Consulte también Obtener dependencia del inyector manualmente dentro de una directiva

3. Otra forma es crear la instancia usted mismo:

constructor(ms:myService)
let myClass = new MyClass(ms);

Answer 3

No es una respuesta directa a la pregunta, pero si está leyendo este SO por la razón que soy, esto puede ayudar ...

Digamos que estás usando ng2-translate y realmente quieres que tu clase User.ts tenga. Tu pensamiento inmediato es usar DI para ponerlo, estás haciendo Angular después de todo. Pero eso es pensarlo demasiado, simplemente puede pasarlo en su constructor o convertirlo en una variable pública que configuró desde el componente (donde presumiblemente lo hizo DI).

p.ej:

import { TranslateService } from "ng2-translate";
export class User {
public translateService: TranslateService; // will set from components.
// a bunch of awesome User methods
}

luego de algún componente relacionado con el usuario que inyectó TranslateService

addEmptyUser() {
let emptyUser = new User("", "");
emptyUser.translateService = this.translateService;
this.users.push(emptyUser);
}

Espero que esto ayude a aquellos que, como yo, estaban a punto de escribir código mucho más difícil de mantener porque a veces somos demasiado inteligentes =]

(NOTA: la razón por la que es posible que desee establecer una variable en lugar de hacerla parte de su método de constructor es que podría tener casos en los que no necesita usar el servicio, por lo que siempre se requiere que lo transfiera significaría introducir importaciones adicionales / código que nunca se usa realmente)

Answer 4

Si sus métodos de servicio son funciones puras, una forma limpia de resolver esto es tener miembros estáticos en su servicio.

tu servicio

import {Injectable} from ''@angular/core'';
@Injectable()
export class myService{
public static dosomething(){
//implementation => doesn''t use `this`
}
}

Tu clase

export class MyClass{
test(){
MyService.dosomething(); //no need to inject in constructor
}
}