In Inversify, why to prefer Constructor/Factory injection over toDynamicValue?

问题

In InversifyJS, are there any specific advantages of following the approaches outlined in factory injection guide and constructor injection guide for injecting factories and constructors respectively over just using toDynamicValue.

回答1:

toConstructor

If you use a toConstructor you will be able to pass arguments to the constructor but you won't be able to resolve those arguments (unless you inject them as well).

container.bind<interfaces.Newable<Katana>>("Newable<Katana>")
         .toConstructor<Katana>(Katana);

toDynamicValue

If you use a toDynamicValue you will be able to pass constructor arguments to the constructor and resolve those arguments using the context.

container.bind<Katana>("Katana")
        .toDynamicValue((context: interfaces.Context) => {
             return new Katana(context.container.get("SomeDependency")); 
        });

toFactory

If you use a toFactory you will be able to pass constructor arguments to the constructor and resolve those arguments using the context but you will also be able to produce different outputs based on factory arguments.

container.bind<interfaces.Factory<Weapon>>("Factory<Weapon>")
         .toFactory<Weapon>((context: interfaces.Context) => {
             return (throwable: boolean) => {
                 if (throwable) {
                     return context.container.getTagged<Weapon>(
                         "Weapon", "throwable", true
                     );
                 } else {
                     return context.container.getTagged<Weapon>(
                         "Weapon", "throwable", false
                     );
                 }
             };
         });

来源：https://stackoverflow.com/questions/46867437/in-inversify-why-to-prefer-constructor-factory-injection-over-todynamicvalue

标签

typescript

dependency-injection

inversifyjs