TypeScript Container.createChild方法代码示例

// creates a controller given a html template string and a viewmodel instance.
function createController(template, viewModel, viewsRequireLifecycle?: boolean) {
  let childContainer = container.createChild();

  let viewFactory = viewCompiler.compile(template);

  if (viewsRequireLifecycle !== undefined) {
    for (let id in viewFactory.instructions) {
      let targetInstruction = viewFactory.instructions[id];
      for (let behaviorInstruction of targetInstruction.behaviorInstructions) {
      if (behaviorInstruction.attrName === 'repeat') {
        behaviorInstruction.viewFactory._viewsRequireLifecycle = viewsRequireLifecycle;
      }
      }
    }
  }

  let metadata = new HtmlBehaviorResource();
  function App() {
    //
  }
  metadata.initialize(childContainer, App);
  metadata.elementName = metadata.htmlName = 'app';

  let controller = metadata.create(childContainer, BehaviorInstruction.dynamic(host, viewModel, viewFactory));
  controller.automate();

  viewSlot.removeAll();
  viewSlot.add(controller.view);

  return controller;
}

 it('should not create new child Container if "childContainer" is provided', async done => {
   const settings = { childContainer: container.createChild() };
   spyOn(container, 'createChild').and.callThrough();
   spyOn(settings.childContainer, 'invoke').and.callThrough();
   await _success(() => dialogService.open(settings), done);
   expect(container.createChild).not.toHaveBeenCalled();
   expect(settings.childContainer.invoke).toHaveBeenCalled();
   done();
 });

 it('createForCurrentScope', () => {
   const container = new Container();
   const standardValidator = {};
   container.registerInstance(Validator, standardValidator);
   const childContainer = container.createChild();
   const factory = childContainer.get(ValidationControllerFactory);
   const controller = factory.createForCurrentScope();
   expect(controller.validator).toBe(standardValidator);
   expect(container.get(Optional.of(ValidationController))).toBe(null);
   expect(childContainer.get(Optional.of(ValidationController))).toBe(controller);
   const customValidator = {};
   expect(factory.createForCurrentScope(customValidator).validator).toBe(customValidator);
 });

        it('should return the key from the parent container when present', () => {
            var sut = new Parent("test"),
                parent = new Container(),
                childContainer = parent.createChild(),
                instance = {},
                wrongInstance = {};

            parent.registerInstance("test", instance);
            childContainer.registerInstance("test", wrongInstance);

            var result = sut.get(childContainer);

            expect(result).toBe(instance);
            expect(result).not.toBe(wrongInstance);
        });

  show(settings: TooltipSettings) {
    const { _container: container } = this;
    const { target, model, viewModel: tempViewModel } = settings;
    const viewModel = Origin.get(tempViewModel).moduleId;

    let host = this._renderer.getContainer();
    let instruction: CompositionContext = {
      container: this._container,
      bindingContext: {},
      overrideContext: {},
      viewResources: null,
      childContainer: this._container.createChild(),
      model: model,
      viewModel: settings.viewModel,
      viewSlot: new ViewSlot(host, true)
    };

    this._viewModel = viewModel;
    this._model = model;

    return _getViewModel(instruction, this._compositionEngine).then(returnedInstruction => {
      this._showing = invokeLifecycle(viewModel, 'canActivate', model);
      this._viewSlot = returnedInstruction.viewSlot;

      return invokeLifecycle(instruction.viewModel, 'canActivate', instruction.model)
      .then((canActivate: boolean) => {
        if (canActivate) {
          this._compositionEngine.compose(returnedInstruction)
            .then(controller => {
              this._renderer._element = host;
              this._renderer._viewSlot = returnedInstruction.viewSlot;
              this._renderer.show(settings.target);
            });
        }
      });
    });
  }