TypeScript core.ReflectiveInjector类代码示例

 /**
  * Helper methods to add ComponentClass(like modal backdrop) with options
  * of type ComponentOptionsClass to element next to application root
  * or next to provided instance of view container
  * @param ComponentClass - @Component class
  * @param ComponentOptionsClass - options class
  * @param options - instance of options
  * @param contextInjector - injector to resolve root view container (any injector except root injector will fit)
  * @returns {ComponentRef<T>} - returns ComponentRef<T>
  */
 public appendNextToRoot<T>(ComponentClass:Type<T>,
                            ComponentOptionsClass:any,
                            options:any,
                            contextInjector:Injector):ComponentRef<T> {
   let location = this.getRootViewContainerRef(contextInjector);
   let providers = ReflectiveInjector.resolve([
     {provide: ComponentOptionsClass, useValue: options}
   ]);
   return this.appendNextToLocation(ComponentClass, location, providers);
 }

  beforeEach(function() {
    routeSet$ = new Subject<Match>();
    spyOn(router, 'replace');
    spyOn(observer, 'next');
    const injector = ReflectiveInjector.resolveAndCreate([
      provide(Router, { useValue: router })
    ]);

    redirect = injector.resolveAndInstantiate(RedirectHook);
  });

  beforeEach(function() {
    routerInstruction$ = new Subject<Match>();
    const injector = ReflectiveInjector.resolveAndCreate([
      PARAMS_PROVIDERS,
      provide(RouterInstruction, { useValue: routerInstruction$ })
    ]);

    routeParams$ = injector.get(RouteParams);
    queryParams$ = injector.get(QueryParams);
  });

    beforeEach(function () {
        const injector = ReflectiveInjector.resolveAndCreate([
            ShopEffects,
            MOCK_EFFECTS_PROVIDERS,
            // Mock out other dependencies (like Http) here
        ]);

        shop = injector.get(ShopEffects);
        updates$ = injector.get(MockStateUpdates);
    });

 useInjectors(): void {
     let injector: any = ReflectiveInjector.resolveAndCreate([
         ViewPortService,
         provide('OtherSizeService', {useFactory: (viewport: any) => {
             return viewport.determineService();
         }, deps: [ViewPortService]})
     ]);
     let sizeService: any = injector.get('OtherSizeService');
     sizeService.run();
 }

 it('should infer type', () => {
   // #docregion InjectionToken
   const BASE_URL = new InjectionToken<string>('BaseUrl');
   const injector =
       ReflectiveInjector.resolveAndCreate([{provide: BASE_URL, useValue: 'http://localhost'}]);
   const url = injector.get(BASE_URL);
   // here `url` is inferred to be `string` because `BASE_URL` is `InjectionToken<string>`.
   expect(url).toBe('http://localhost');
   // #enddocregion
 });

 beforeEach(() => {
   var injector = ReflectiveInjector.resolveAndCreate(
       [{provide: ResponseOptions, useClass: BaseResponseOptions}, MockBackend]);
   backend = injector.get(MockBackend);
   var base = new BaseRequestOptions();
   sampleRequest1 = new Request(base.merge(new RequestOptions({url: 'https://google.com'})));
   sampleResponse1 = new Response(new ResponseOptions({body: 'response1'}));
   sampleRequest2 = new Request(base.merge(new RequestOptions({url: 'https://google.com'})));
   sampleResponse2 = new Response(new ResponseOptions({body: 'response2'}));
 });

 beforeEach(() => {
   let injector = ReflectiveInjector.resolveAndCreate([
     ROUTER_FAKE_PROVIDERS,
     // Angulartics2 relies on router for virtual page view tracking
     Angulartics2, Angulartics2Segment, AnalyticsService
   ]);
   analyticsService = injector.get(AnalyticsService);
   analyticsService.devMode(false);
   segment = injector.get(Angulartics2Segment);
 });

  beforeEach(() => {
    onerrorSpy = jasmine.createSpy('onerror');
    superHandler = spyOn(ErrorHandler.prototype, 'handleError');

    const injector = ReflectiveInjector.resolveAndCreate([
      { provide: ErrorHandler, useClass: ReportingErrorHandler },
      { provide: WindowToken, useFactory: () => ({ onerror: onerrorSpy }) }
    ]);
    handler = injector.get(ErrorHandler);
  });

function createInjector(initialUrl: string) {
  return ReflectiveInjector.resolveAndCreate([
      DocumentService,
      { provide: LocationService, useFactory: () => new MockLocationService(initialUrl) },
      { provide: ConnectionBackend, useClass: MockBackend },
      { provide: RequestOptions, useClass: BaseRequestOptions },
      { provide: Logger, useClass: MockLogger },
      Http,
  ]);
}