Typescript için IOC

İçeriği temel bağlamaları gibi gelişmiş bağımlılık enjeksiyon özellikleri ile InversifyJS denilen bir IoC kapsayıcı geliştirdik.

Sen izlemeniz gereken 3 temel adımı kullanmak için:

1. ek açıklamalar ekleme

Ek açıklama API Eğik 2.0 dayanmaktadır:

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. Declare bağlamaları

bağlama API Ninject dayanmaktadır:

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. Çöz bağımlılıkları

çözünürlük API Ninject dayanmaktadır:

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

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

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

son sürümü (2.0.0) pek çok kullanım örneğini destekler:

• Çekirdek modülleri
• Çekirdek katman
• bağımlılık tanımlayıcı olarak sınıfları, dize hazır veya Sembol kullanın
• sabit değerleri enjeksiyonu
• sınıf inşaatçı Enjeksiyon
• fabrikaların Enjeksiyon
• Oto fabrikası
• sağlayıcıların Enjeksiyon (zaman uyumsuz fabrika)
• Aktivasyon yükleyiciler (proxy enjekte etmek için kullanılır)
• çok enjeksiyonları
• Tagged bağlamaları
• Özel etiketi dekoratörler
• Adlandırılan bağlamaları
• Bağlamsal bağlamaları
• Dostu istisnalar (örneğin Dairesel bağımlılıklar)

Sen bu konuda daha fazla bilgi edinebilirsiniz https://github.com/inversify/InversifyJS

Ben typescript için DI kütüphane oluşturduk - huject

https://github.com/asvetliakov/huject

Örnek:

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

Orada typescript arayüzleri ile ilgili bir sorun olsa, ama ben 2 geçici çözümleri (arayüz olarak soyut veya basit sınıf kullanın)

Şimdilik, IOC parçası olmadan JavaScript bağımlılık enjeksiyon kullanabilirsiniz. Bu bir "el" çözümleyicinizi veya fabrikalar, ya da her türlü DI desen tercih yazma olsun size kalmıştır.

ECMAScript 6 standart kabul edildiğinde, JavaScript IOC kavramı mümkün kılabilir.

Biz gerektiren / AMD tanımlamak kullanan basit bir bağımlılık enjeksiyon konteyner kullanıyorum - sözdizimi gibi. Blog yazısı aşağıda düz eski JavaScript bunu sunar rağmen orijinal uygulama, daktilo olduğunu.

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

Bu konfigürasyonda bir demet gerektirmeden bağımlılık ilişkilerini tanımlamak için oldukça düzgün ve requirejs benzer döngüsel bağımlılık çözünürlüğü destekliyor.

İşte basit bir örnek:

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

});

Alternatif sadece hayır çerçeve kullanmak ve özellikleri gibi nesne fabrikaları ile kapsayıcı olarak sınıfını kullanabilirsiniz. Daha sonra test ve değişim fabrikalarında bu sınıfı devralabilir. Bu yaklaşım güvenli yazıp herhangi dekoratörler, sınıfların sadece kayıt gerektiren kalmamasıdır.

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;

çıkış https://github.com/typestack/typedi

Böyle bir şey mümkündür:

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

@Service()
class SomeClass {

    someMethod() {
    }

}

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