So fügen Sie einen Service in die Klasse ein (keine Komponente)

Ich möchte einen Dienst in eine Klasse einfügen, die keine Komponente ist .

Zum Beispiel:

Myservice

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

Meine Klasse

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

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

Diese Lösung funktioniert nicht (ich denke, weil sie MyClassnoch nicht instanziiert wurde).

Gibt es eine andere Möglichkeit, einen Dienst in einer Klasse (nicht in einer Komponente) zu verwenden? Oder würden Sie mein Code-Design als unangemessen betrachten (um einen Dienst in einer Klasse zu verwenden, die keine Komponente ist)?

Vielen Dank.

Injections funktioniert nur mit Klassen, die durch Angulars Dependency Injection (DI) instanziiert werden.

1. Du brauchst
   • @Injectable()zu MyClassund hinzufügen
   • bieten MyClasswie providers: [MyClass]in einer Komponente oder NgModule.

Wenn Sie dann MyClassirgendwo injizieren , wird eine MyServiceInstanz übergeben, MyClasswenn sie von DI instanziiert wird (bevor sie das erste Mal injiziert wird).

2. Ein alternativer Ansatz besteht darin, einen benutzerdefinierten Injektor wie zu konfigurieren

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

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

Dieser Weg myClassist eine MyClassInstanz, die von Angulars DI instanziiert wird und bei Instanziierung myServiceinjiziert wird MyClass.
Siehe auch Abhängigkeiten von Injector manuell innerhalb einer Direktive abrufen

3. Eine weitere Möglichkeit besteht darin, die Instanz selbst zu erstellen:

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

Keine direkte Antwort auf die Frage, aber wenn Sie diese SO aus dem Grund lesen, aus dem ich bin, kann dies helfen ...

Angenommen , Sie verwenden ng2-translate und möchten wirklich, dass Ihre User.tsKlasse es hat. Du denkst sofort, du sollst DI verwenden, um es einzufügen, schließlich machst du Angular. Aber das ist eine Art Überdenken, Sie können es einfach in Ihrem Konstruktor übergeben oder es zu einer öffentlichen Variablen machen, die Sie von der Komponente festgelegt haben (in der Sie es vermutlich DI gemacht haben).

z.B:

import { TranslateService } from "ng2-translate";

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

  // a bunch of awesome User methods
}

dann von einer benutzerbezogenen Komponente, die TranslateService injiziert hat

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

Hoffentlich hilft das denen da draußen wie mir, die viel schwieriger schreiben wollten, um Code zu pflegen, weil wir manchmal zu schlau sind =]

(HINWEIS: Der Grund, warum Sie möglicherweise eine Variable festlegen möchten, anstatt sie zu einem Teil Ihrer Konstruktormethode zu machen, besteht darin, dass Sie den Dienst möglicherweise nicht verwenden müssen. Wenn Sie ihn also immer übergeben müssen, müssen Sie zusätzliche Importe einführen / Code, der nie wirklich benutzt wird)

Das ist irgendwie ( sehr ) hackig, aber ich dachte, ich würde auch meine Lösung teilen. Beachten Sie, dass dies nur mit Singleton-Diensten funktioniert (injiziert im App-Stammverzeichnis, nicht in der Komponente!), Da diese so lange wie Ihre Anwendung ausgeführt werden und es immer nur eine Instanz davon gibt.

Erstens in Ihrem Dienst:

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

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

Dann in jeder Klasse:

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

Diese Lösung ist gut, wenn Sie die Code-Unordnung reduzieren möchten und ohnehin keine Nicht-Singleton-Dienste verwenden.

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
}

Wenn Ihre Servicemethoden reine Funktionen sind, besteht eine saubere Möglichkeit, dies zu lösen, darin, statische Mitglieder in Ihrem Service zu haben.

dein Dienst

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

deine Klasse

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