updated examples

Author: basedalexander

examples/javascript/use-factory-with-injections.js

@@ -1,8 +1,10 @@
 import { Container, Injectable } from 'container-ioc';
 
-const container = new Container();
+const TService = Symbol('IService');
+
+const TManager = Symbol('IManager');
 
-@Injectable(['IUserFactory'])
+@Injectable([TService])
 class App {
     constructor(service) {
         this.service = service;
@@ -12,15 +14,20 @@ class App {
 @Injectable()
 class Service {}
 
+@Injectable()
+class Manager {}
+
+const container = new Container();
+
 container.register([
     { token: App, useClass: App },
-    { token: 'IService', useClass: Service },
+    { token: TManager, useClass: Manager },
     {
-        token: 'IUseFactory',
-        useFactory: (service) => {
-            return service;
+        token: TService,
+        useFactory: (manager) => {
+            return manager;
         },
-        inject: ['IService']
+        inject: ['IConfig']
     }
 ]);
 

examples/javascript/use-factory.js

@@ -1,22 +1,24 @@
 import { Container, Injectable } from 'container-ioc';
 
-const container = new Container();
+const TService = Symbol('IService');
 
-@Injectable(['IUseFactory'])
+@Injectable([TService])
 class App {
-    constructor(service) {
-        this.service = service;
-    }
+    constructor(service) {}
 }
 
-class Service {}
+const container = new Container();
 
 container.register([
     { token: App, useClass: App },
     {
-        token: 'IUseFactory',
+        token: TService,
         useFactory: () => {
-            return new Service();
+            return {
+                serve () {
+                    // do stuff
+                }
+            };
         }
     }
 ]);

examples/typescript/alternative-syntax.ts

@@ -1,19 +1,21 @@
 import { Container, Injectable } from 'container-ioc';
 
-const container = new Container();
-
 interface IService {
     [key: string]: any;
 }
 
-@Injectable(['IService'])
+const TSerivice = Symbol('IService');
+
+@Injectable([TSerivice])
 class App {
     constructor(private service: IService) {}
 }
 
+const container = new Container();
+
 container.register([
     { token: App, useClass: App },
-    { token: 'IService', useValue: {}}
+    { token: TSerivice, useValue: {}}
 ]);
 
 const app = container.resolve(App);

examples/typescript/life-time-control.ts

@@ -1,10 +1,10 @@
 import { Container, Injectable, LifeTime } from 'container-ioc';
 
-const container = new Container();
-
 @Injectable()
 class A {}
 
+const container = new Container();
+
 container.register({ token: A, useClass: A, lifeTime: LifeTime.PerRequest });
 
 const instance1 = container.resolve(A);

examples/typescript/use-factory-with-injections.ts

@@ -1,28 +1,41 @@
-import { Container, Injectable, Inject } from 'container-ioc';
+/* tslint:disable: no-unused-expression max-classes-per-file*/
 
-const container = new Container();
+import { Container, Injectable, Inject } from 'container-ioc';
 
 interface IService {
     [key: string]: any;
 }
 
+interface IManager {
+    [key: string]: any;
+}
+
+const TService = Symbol('IService');
+
+const TManager = Symbol('IManager');
+
 @Injectable()
 class App {
-    constructor(@Inject('IUseFactory') private service: IService) {}
+    constructor(@Inject(TService) private service: IService) {}
 }
 
 @Injectable()
-class Service {}
+class Service implements IService {}
+
+@Injectable()
+class Manager implements IManager {}
+
+const container = new Container();
 
 container.register([
     { token: App, useClass: App },
-    { token: 'IService', useClass: Service },
+    { token: TManager, useClass: Manager },
     {
-        token: 'IUseFactory',
-        useFactory: (service: IService) => {
-            return service;
+        token: TService,
+        useFactory: (manager: IManager) => {
+            return manager;
         },
-        inject: ['IService']
+        inject: [TManager]
     }
 ]);
 

examples/typescript/use-factory.ts

@@ -2,23 +2,25 @@ import { Container, Injectable, Inject } from 'container-ioc';
 
 /* tslint:disable: no-unused-expression max-classes-per-file*/
 
-const container = new Container();
-
 interface IService {
     [key: string]: any;
 }
 
+const TService = Symbol('IService');
+
 @Injectable()
 class App {
-    constructor(@Inject('IUseFactory') private service: IService) {}
+    constructor(@Inject(TService) private service: IService) {}
 }
 
-class Service {}
+class Service implements IService {}
+
+const container = new Container();
 
 container.register([
     { token: App, useClass: App },
     {
-        token: 'IUseFactory',
+        token: TService,
         useFactory: () => {
             return new Service();
         }