Come inserire il servizio nella classe (non nel componente)

Voglio iniettare un servizio in una classe che non è un componente .

Per esempio:

Myservice

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

La mia classe

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

  }
  test() {
     this.myservice.dosomething();
  }
}

Questa soluzione non funziona (penso perché MyClassnon è stata ancora istanziata).

C'è un altro modo per utilizzare un servizio in una classe (non un componente)? O considereresti il ​​mio progetto di codice inappropriato (per utilizzare un servizio in una classe che non è un componente)?

Grazie.

Injections funziona solo con classi istanziate da Angulars dependency injection (DI).

1. Devi
   • aggiungi @Injectable()a MyClasse
   • fornire MyClasscome providers: [MyClass]in un componente o NgModule.

Quando poi si inietta MyClassda qualche parte, MyServiceun'istanza viene passata a MyClassquando viene istanziata da DI (prima che venga iniettata la prima volta).

2. Un approccio alternativo consiste nel configurare un iniettore personalizzato come

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

  let myClass : MyClass = childInjector.get(MyClass);
}

In questo modo myClasssarà MyClassun'istanza, istanziata da Angulars DI, e myServiceverrà iniettata MyClassquando istanziata.
Vedi anche Ottenere la dipendenza da Injector manualmente all'interno di una direttiva

3. Un altro modo è creare tu stesso l'istanza:

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

Non una risposta diretta alla domanda, ma se stai leggendo questo SO per il motivo per cui sono questo potrebbe aiutarti ...

Diciamo che stai usando ng2-translate e vuoi davvero che la tua User.tsclasse lo abbia. Il tuo pensiero immediato è di usare DI per inserirlo, dopotutto stai facendo Angular. Ma questo è un po 'pensarci troppo, puoi semplicemente passarlo nel tuo costruttore, o renderlo una variabile pubblica che hai impostato dal componente (dove presumibilmente l'hai fatto DI).

per esempio:

import { TranslateService } from "ng2-translate";

export class User {
  public translateService: TranslateService; // will set from components.

  // a bunch of awesome User methods
}

quindi da qualche componente relativo all'utente che ha inserito TranslateService

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

Spero che questo aiuti quelli là fuori come me che stavano per scrivere un codice molto più difficile da mantenere perché a volte siamo troppo intelligenti =]

(NOTA: il motivo per cui potresti voler impostare una variabile invece di renderla parte del tuo metodo di costruzione è che potresti avere casi in cui non è necessario utilizzare il servizio, quindi essere sempre obbligato a passarlo significherebbe introdurre importazioni extra / codice che non viene mai realmente utilizzato)

Questo è un po '( molto ) hacky, ma ho pensato di condividere anche la mia soluzione. Nota che questo funzionerà solo con i servizi Singleton (iniettati nella radice dell'app, non nel componente!), Dal momento che vivono quanto la tua applicazione e c'è solo un'istanza di essi.

Primo, al tuo servizio:

@Injectable()
export class MyService {
    static instance: MyService;
    constructor() {
        MyService.instance = this;
    }

    doSomething() {
        console.log("something!");
    }
}

Quindi in qualsiasi classe:

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

Questa soluzione è utile se si desidera ridurre la confusione di codice e non si utilizzano comunque servizi non singleton.

locator.service.ts

import {Injector} from "@angular/core";

export class ServiceLocator {
    static injector: Injector;
}

app.module.ts

@NgModule({ ... })

export class AppModule {
    constructor(private injector: Injector) {
        ServiceLocator.injector = injector;
    }
 }

poney.model.ts

export class Poney {

    id: number;
    name: string;
    color: 'black' | 'white' | 'brown';

    service: PoneyService = ServiceLocator.injector.get(PoneyService); // <--- HERE !!!

    // PoneyService is @injectable and registered in app.module.ts
}

Se i metodi di servizio sono funzioni pure, un modo pulito per risolvere questo problema è avere membri statici nel servizio.

il tuo servizio

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

la tua classe

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