2015-05-07 12 views
6

Ho una classe genitore in cui desidero iniettare alcuni moduli, quindi ho alcune classi derivate in cui vorrei utilizzare questi moduli iniettati. Tuttavia nella classe derivata è necessario chiamare super() senza parametri, quindi i moduli iniettati nella classe genitore non sono definiti. Come si può fare?Come iniettare in una classe genitore in Aurelia?

import {inject} from 'aurelia-framework'; 
import {HttpClient} from 'aurelia-http-client'; 

@inject (HttpClient) 
export class Parent{ 
    constructor(module){ 
     //this constructor is called from derived class without parameters, 
     //so 'module' is undefined !! 
     this.injectedmodule = module; 
    } 
} 


export class ClassA extends Parent{ 
    constructor(){ 
     super(); 
     this.injectedmodule.get() // injectedmodule is null !!! 
    } 
} 

risposta

8

Beh, appena trovato la soluzione, il modulo è in realtà iniettato nella classe derivata e passato al genitore attraverso super() chiamata:

import {inject} from 'aurelia-framework'; 
import {HttpClient} from 'aurelia-http-client'; 

@inject (HttpClient) 
export class Parent{ 
    constructor(module){ 
     this.injectedmodule = module; 
    } 
} 


export class ClassA extends Parent{ 
    constructor(module){ 
     super(module); 
     this.injectedmodule.get() // ok !!! 
    } 
} 
+0

commento rimosso, si trasferisce a rispondere. –

+0

eccellente risposta tizio –

+1

E se fosse necessario iniettare qualcosa in Classe A, la Classe inietta prima o dopo l'iniezione del genitore? – Larsi

6

La raccomandazione generale è di evitare l'ereditarietà, se possibile. Utilizzare invece la composizione. In questo caso:

import {inject} from 'aurelia-framework'; 
import {HttpClient} from 'aurelia-http-client'; 

@inject (HttpClient) 
export class Parent{ 
    constructor(module){ 
     this.injectedmodule = module; 
    } 
} 

@inject(Parent) 
export class ClassA { 
    constructor(parent){ 
     this.parent = parent; 
     this.parent.injectedmodule.get() // ok !!! 
    } 
} 
+1

perché evitare l'ereditarietà? –

+1

https://en.wikipedia.org/wiki/Composition_over_inheritance – pungggi

+0

@MatthewJamesDavis ci sono molti motivi per evitare le gerarchie di ereditarietà _deep_. Tuttavia, l'implementazione di più interfacce, che possono essere eseguite attraverso la composizione e la delega, non è problematica. I problemi nascono da ipotesi su comportamenti difficili da mantenere e impossibili da documentare a livello di tipo nella maggior parte delle lingue. Questo diventa più fastidioso man mano che aumenta la profondità della gerarchia. Ci sono molti altri motivi per evitare l'ereditarietà eccessiva. –

1

C'è un sito web che spiegano, per me, un bel modo per farlo https://ilikekillnerds.com/2016/11/injection-inheritance-aurelia/

Ecco l'esempio:

import {inject} from 'aurelia-framework'; 
import {Router} from 'aurelia-router'; 

@inject(Router) 
export class Parent { 
    constructor(router) { 
     this.router = router; 
    } 
} 


import {Parent} from './parent'; 

export class Child extends Parent { 
    constructor(...rest) { 
     super(...rest); 
    } 
} 
Problemi correlati