Du CIO pour tapuscrit

J'ai développé un conteneur IoC appelé InversifyJS avec des fonctions d'injection de dépendance avancées telles que les liaisons contextuelles.

Vous devez suivre 3 étapes de base pour l' utiliser:

1. Ajouter des annotations

L'API d'annotation est basée sur angulaire 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. liaisons Declare

L'API de liaison est basée sur 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. Résolution des dépendances

L'API de résolution est basée sur Ninject:

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

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

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

La dernière version (2.0.0) supporte de nombreux cas d'utilisation:

• Les modules du noyau
• middleware noyau
• Utiliser les classes, les chaînes littérales ou des symboles comme des identificateurs de dépendance
• Injection de valeurs constantes
• L'injection de constructeurs de classe
• L'injection d'usines
• usine automobile
• L'injection de fournisseurs (usine async)
• Chariot d'activation (utilisé pour injecter des procurations)
• injections multiples
• fixations tag
• décorateurs de marque personnalisée
• fixations nommées
• fixations contextuelles
• exceptions amicales (par exemple les dépendances circulaires)

Vous pouvez en apprendre davantage à ce sujet à https://github.com/inversify/InversifyJS

J'ai créé pour la bibliothèque DI tapuscrit - huject

https://github.com/asvetliakov/huject

Exemple:

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);

Il y a un problème avec les interfaces tapuscrit bien, mais j'ai 2 solutions de contournement (utiliser la classe abstraite ou simple interface)

Pour l'instant, vous pouvez utiliser l'injection de dépendance en JavaScript sans la partie du CIO. Il est à vous si vous écrivez un résolveur « manuel », ou des usines, ou tout autre modèle DI que vous préférez.

Lorsque la norme ECMAScript 6 est adopté, il peut rendre le concept de la COI possible en JavaScript.

Nous avons utilisé simple conteneur d'injection de dépendance qui utilise AMD définir / require - comme la syntaxe. La mise en œuvre originale est dactylographiée, bien que le billet de blog il présente ci-dessous dans la vieille plaine JavaScript.

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

Il est assez simple de définir des relations de dépendance sans nécessiter un tas de configuration, et supporte une résolution de dépendance circulaire similaire à requirejs.

Voici un exemple simple:

// 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

});

Sinon, vous pouvez simplement utiliser sans cadre et utiliser la classe comme conteneur avec des usines d'objets comme des propriétés. Vous pouvez ensuite hériter de cette classe dans les tests et les usines de changement. Cette approche est de type sûr et ne nécessitent pas de décorateurs, juste inscription des classes.

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;

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

quelque chose comme cela est possible:

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

@Service()
class SomeClass {

    someMethod() {
    }

}

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