TypeScript Injector.get方法代碼示例

export function useInjector() {
  var injector:Injector;

//#enddocregion injector
/*
//#docregion injector-no-new
  // Cannot 'new' an Injector like this!
  var injector = new Injector([Car, Engine, Tires, Logger]);
//#enddocregion injector-no-new
*/

//#docregion injector
  //#docregion injector-create-and-call
  injector = Injector.resolveAndCreate([Car, Engine, Tires, Logger]);
  //#docregion injector-call
  var car = injector.get(Car);
 //#enddocregion injector-call
 //#enddocregion injector-create-and-call
  car.description = 'Injector';

  var logger = injector.get(Logger);
  logger.log('Injector car.drive() said: '+car.drive());

  return car;
}

export const authorize = (to: ComponentInstruction, from: ComponentInstruction, params: Object = {}) =>
{
  let injector: Injector = appInjector();
  //let router: Router = injector.get(Router);
  let user$: Observable<User> = injector.get(UserService).user$
  let projects$: Observable<Array<Project>> = injector.get(ProjectsService).projects$

  // checks
  let authorized = false;
  let checkToken = tokenNotExpired(null, localStorage.getItem('token'))
  let checkRole$ = user$.map(user => user.role === 'admin' || user.role === params['checkRole'])
  let checkGroup$ = projects$
    .flatMap(project => project)
    .filter(project => project.url === to.urlPath)
    .zip(user$)
    .map(merged => merged[0].groups.map(projectsGroup => merged[1].groups.indexOf(projectsGroup) !== -1))
    .flatMap(merged => merged)

  Observable
    .merge(checkRole$, checkGroup$)
    .filter(check => check === true)
    .subscribe
    (
      (check: boolean) => authorized = check,
      err => console.error // maybe redirect to custom 4xx page here...
    )

  return new Promise((resolve) => resolve(checkToken && authorized))
}

	beforeEach(() => {
		injector = Injector.resolveAndCreate([
			BaseRequestOptions,
			MockBackend,
			provide(Http, {
				useFactory: (connectionBackend: ConnectionBackend, defaultOptions: BaseRequestOptions) => {
					return new Http(connectionBackend, defaultOptions);
				},
				deps: [
					MockBackend,
					BaseRequestOptions
				]
			}),
			provide(Icon, {
				useFactory: (http: Http) => {
					return new Icon(http);
				},
				deps: [
					Http
				]
			})
		]);
		backend = injector.get(MockBackend);
		store = injector.get(Icon);
		response = new Response(
			new ResponseOptions({body: SVG_GLYPH_HTML})
		);
		glyph = createGlyphNode();
	});

export const checkAuth = (next: ComponentInstruction, previous: ComponentInstruction) => {
    let injector: Injector = appInjector(); // get the stored reference to the injector
    let auth: Auth = injector.get(Auth);
    let router: Router = injector.get(Router);
    let location: Location = injector.get(Location);

    // return a boolean or a promise that resolves a boolean
    return new Promise((resolve, reject) => {

        if (auth.check()) {
            // already login, redirect to default page
            if (next.urlPath == 'login' || next.urlPath == 'signup') {
                router.navigate(['/Home']);	// r
                // window.location.href = 'index.html';
                resolve(false);
            }
            // show the page
            else {
                resolve(true);
            }
        } else {
            // not login; show the login page
            if (next.urlPath == 'login' || next.urlPath == 'signup') {
                resolve(true);
            }
            // restrict the page
            else {
                router.navigate(['/Login']); // r
                // window.location.href = 'login.html';
                resolve(false);
            }
        }
    });
};

    beforeEach(() => {

      injector = Injector.resolveAndCreate([
        provideStore({ counter1: counterReducer, counter2: counterReducer, counter3: counterReducer }, { counter1: 0, counter2: 1 })
      ]);

      store = injector.get(Store);
      dispatcher = injector.get(Dispatcher);
    });

 beforeEach(() => {
     injector = Injector.resolveAndCreate([
         HTTP_PROVIDERS,
         GithubComponent,
         GithubService,
         Config
     ]);
     component = injector.get(GithubComponent);
     service = injector.get(GithubService);
     sinon.spy(service, "searchRepositories");
 });

 beforeEach(() => {
     injector = ReflectiveInjector.resolveAndCreate([
         HTTP_PROVIDERS,
         // Provide a mocked (fake) backend for Http
         provide(XHRBackend, {useClass: MockBackend}),
         TRANSLATE_PROVIDERS
     ]);
     backend = injector.get(XHRBackend);
     translate = injector.get(TranslateService);
     // sets the connection when someone tries to access the backend with an xhr request
     backend.connections.subscribe((c: MockConnection) => connection = c);
 });

    return CanActivate((to: ComponentInstruction, from: ComponentInstruction, target = ['/']) => {
        let injector: Injector = appInjector(); // Get the stored reference to the application injector
        let tokenService: TokenService = injector.get(TokenService);
        let router: Router = injector.get(Router);

        if (tokenService.token)
            return true;

        router.navigate(['/Login', { target }]);
        
        return false;
    });

 var prepare = (loaderClass: Function) => {
     injector = Injector.resolveAndCreate([
         HTTP_PROVIDERS,
         // Provide a mocked (fake) backend for Http
         provide(XHRBackend, {useClass: MockBackend}),
         provide(TranslateLoader, {useClass: loaderClass}),
         TranslateService
     ]);
     backend = injector.get(XHRBackend);
     translate = injector.get(TranslateService);
     // sets the connection when someone tries to access the backend with an xhr request
     backend.connections.subscribe((c: MockConnection) => connection = c);
 };

 let prepare = ((handlerClass: Function) => {
     injector = ReflectiveInjector.resolveAndCreate([
         HTTP_PROVIDERS,
         // Provide a mocked (fake) backend for Http
         provide(XHRBackend, {useClass: MockBackend}),
         TRANSLATE_PROVIDERS,
         provide(MissingTranslationHandler, {useClass: handlerClass})
     ]);
     backend = injector.get(XHRBackend);
     translate = injector.get(TranslateService);
     missingTranslationHandler = injector.get(MissingTranslationHandler);
     // sets the connection when someone tries to access the backend with an xhr request
     backend.connections.subscribe((c: MockConnection) => connection = c);
 });