IOC pentru typescript

Am dezvoltat un container IoC numit InversifyJS cu caracteristici avansate de injecție de dependență, cum ar fi legăturile contextuale.

Trebuie să urmați 3 pași de bază se utilizează:

1. Adăugați adnotări

API-ul de adnotare este bazat pe Angular 2.0:

import { injectable, inject } from "inversify";

@injectable()
class Katana implements IKatana {
    public hit() {
        return "cut!";
    }
}

@injectable()
class Shuriken implements IShuriken {
    public throw() {
        return "hit!";
    }
}

@injectable()
class Ninja implements INinja {

    private _katana: IKatana;
    private _shuriken: IShuriken;

    public constructor(
        @inject("IKatana") katana: IKatana,
        @inject("IShuriken") shuriken: IShuriken
    ) {
        this._katana = katana;
        this._shuriken = shuriken;
    }

    public fight() { return this._katana.hit(); };
    public sneak() { return this._shuriken.throw(); };

}

2. legări declare

API-ul de legare se bazează pe Ninject:

import { Kernel } from "inversify";

import { Ninja } from "./entities/ninja";
import { Katana } from "./entities/katana";
import { Shuriken} from "./entities/shuriken";

var kernel = new Kernel();
kernel.bind<INinja>("INinja").to(Ninja);
kernel.bind<IKatana>("IKatana").to(Katana);
kernel.bind<IShuriken>("IShuriken").to(Shuriken);

export default kernel;

3. dependențe Rezolvarea

Rezoluția API-ul se bazează pe Ninject:

import kernel = from "./inversify.config";

var ninja = kernel.get<INinja>("INinja");

expect(ninja.fight()).eql("cut!"); // true
expect(ninja.sneak()).eql("hit!"); // true

Cea mai recentă versiune (2.0.0) suportă multe cazuri de utilizare:

• modulelor de kernel
• Kernel middleware
• Utilizați clase, un sir de caractere sau simboluri ca identificatori de dependență
• Injectarea de valori constante
• Injectarea de constructori de clasă
• Injectarea de fabrici
• fabrica Auto
• Injectarea de furnizori (fabrica asincronă)
• Stivuitoare de activare (folosit pentru a injecta proxy-uri)
• preparate injectabile Multi
• legări Tagged
• decoratori etichete personalizate
• legăturile cu numele
• legăturile contextuale
• excepții Friendly (de exemplu, dependențele circulare)

Puteți afla mai multe despre el la https://github.com/inversify/InversifyJS

Am creat biblioteca DI pentru dactilografiat - huject

https://github.com/asvetliakov/huject

Exemplu:

import {Container, FactoryMethod, ConstructorInject, Inject} from 'huject';
class FirstService {
   public constructor(param: number) {}
}
class SecondService {
}

@ConstructorInject
class MyController {
    @Inject
    public service: FirstService;

    public second: SecondService;
    public constructor(service: SecondService) {
        this.second = service;
    }
    ...
}
container.setAllowUnregisteredResolving(true);
container.register(FirstService, [10]); // Register constructor arguments

// FirstService and SecondService will be resolved for container instance
let controller = container.resolve(MyController);

Există o problemă cu interfețe typescript deși, dar am 2 rezolvări (folosesc clasă abstractă sau simplu ca interfață)

Pentru moment, puteți folosi dependența de injectare în JavaScript fără partea IOC. Depinde de tine dacă ai scrie un rezolvator „manual“, sau fabrici, sau orice model DI preferați.

Atunci când se adoptă standardul ECMAScript 6, se poate face conceptul de IOC posibil în JavaScript.

Am folosit un recipient simplu de injecție de dependență, care utilizează AMD defini / necesita - cum ar fi sintaxa. Implementarea original este dactilografiat, deși postul de blog de mai jos prezintă în JavaScript simplu vechi.

http://blog.coolmuse.com/2012/11/11/a-simple-javascript-dependency-injection-container/

Este destul de simplu pentru a defini relații de dependență, fără a necesita o grămadă de configurare și acceptă o rezoluție de dependență circulară similară cu requirejs.

Iată un exemplu simplu:

// create the kernel
var kernel = new ServiceKernel();

// define service1
kernel.define("service1", function() {

    // service1 has a function named foo
    return {
        foo: function () { return "foo"; }
    }

});

// define service2, which depends on service1
kernel.define("service2", ["service1"], function(service1) {

    // service2 has a function named foobar
    return {
        foobar : function() { return service1.foo() + "bar"; }
    }

});

// get service2 instance 
var service2 = kernel.require("service2");
service2.foobar();  // returns "foobar"

// get both service1 and service2 instances
kernel.require(["service1", "service2"], function(service1, service2) {

    alert(service1.foo() + service2.foobar()); // displays foofoobar

});

Ca alternativă, puteți utiliza doar un cadru și de a folosi clasa ca recipient cu fabrici de obiecte ca proprietăți. Puteți moșteni apoi această clasă în teste și fabrici de schimbare. Această abordare este de tip în condiții de siguranță și nu necesită nici un decoratori, doar înregistrarea claselor.

class B {
    echo() {
        alert('test');
    }   
}

class A {
    constructor(private b: B) {
        b.echo();
    }
}

class Container {
    A = () => new A(this.B());
    B = singleton(() => new B()); 
}

var c = new Container();
var a = c.A();

// singleton helper:

function memoize<T>(factory: () => T): () => T  {
    var memo: T = null;
    return function () {
        if(!memo) {
            memo = factory();
        }
        return memo;
    };
}

var singleton = memoize;

checkout https://github.com/typestack/typedi

ceva de genul acest lucru este posibil:

import "reflect-metadata";
import {Service, Container} from "typedi";

@Service()
class SomeClass {

    someMethod() {
    }

}

let someClass = Container.get(SomeClass);
someClass.someMethod();