COI para mecanografiado

He desarrollado un contenedor IoC llamada InversifyJS con características avanzadas como la inyección de dependencias fijaciones contextuales.

Es necesario seguir 3 pasos básicos para utilizarlo:

1. Añadir anotaciones

La API de anotación se basa en 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. Declarar fijaciones

El API se basa en la unión de 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. Resolver dependencias

La API de resolución se basa en 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 última versión (2.0.0) es compatible con muchos casos de uso:

• Los módulos del kernel
• middleware kernel
• Utilizar las clases, los literales de cadena o símbolos como identificadores de dependencia
• La inyección de valores constantes
• La inyección de constructores de clase
• La inyección de fábricas
• fábrica de automóviles
• La inyección de los proveedores (fábrica asíncrono)
• manipuladores de activación (utilizado para inyectar proxies)
• inyecciones múltiples
• encuadernaciones etiquetados
• decoradores de etiquetas personalizadas
• encuadernaciones con nombre
• encuadernaciones contextuales
• excepciones Friendly (por ejemplo, dependencias circulares)

Usted puede aprender más sobre él en https://github.com/inversify/InversifyJS

He creado la biblioteca DI para mecanografiado - huject

https://github.com/asvetliakov/huject

Ejemplo:

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

Hay un problema con las interfaces mecanografiado sin embargo, pero tengo 2 soluciones (use clase abstracta o simple como interfaz)

Por ahora, puede utilizar la inyección de dependencia en JavaScript sin la parte del COI. Depende de usted si usted escribe un resolvedor "manual", o fábricas, o lo que sea patrón DI lo prefiere.

Cuando se adopta el estándar ECMAScript 6, puede hacer que el concepto de la COI posible en JavaScript.

Hemos estado utilizando un simple contenedor de inyección de dependencias que utiliza AMD definir / requerir - como sintaxis. La implementación original es a máquina de escribir, a pesar de la entrada de blog a continuación presenta en edad JavaScript llanura.

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

Es bastante sencillo definir relaciones de dependencia sin requerir un montón de configuración y soporta una resolución de dependencia circular similar a RequireJS.

Aquí está un ejemplo sencillo:

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

});

Como alternativa, puedes usar ningún marco y utilizar la clase como recipiente con factorías de objetos como propiedades. A continuación, puede heredar esta clase de pruebas y fábricas de cambio. Este enfoque es de tipo seguro y no requieren ningún decoradores, solo registro de clases.

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;

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

algo como esto es posible:

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

@Service()
class SomeClass {

    someMethod() {
    }

}

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