Angular 4 如何使用 NgComponentOutlet 将数据传递到动态组件

Question

我发现了这个类似的问题。 angular 4+ 为 ngComponentOutlet 动态创建的组件分配 @Input

但是已经快一个月了。 有什么改变吗？

基本上，我按照本指南创建了一个动态组件： https://angular.io/docs/ts/latest/cookbook/dynamic-component-loader.html

通过这种方法，我可以为动态组件分配一个值： (<AdComponent>componentRef.instance).data = adItem.data;

我仍然无法使用开箱即用的 NgComponentOutlet 为动态组件赋值吗？ （ https://angular.io/docs/ts/latest/api/common/index/NgComponentOutlet-directive.html ）

Answer 1

您可以传递这样的自定义注入器 - https://github.com/angular/angular/issues/16373#issuecomment-306544456

这有点像黑客，所以我们最终使用这个库 -

https://www.npmjs.com/package/ng-dynamic-component

像魅力一样工作！

Answer 2

在我的例子中，我在组件中使用ngBaseDef.inputs.data。

见例子：

import {Component, Injectable, Input} from '@angular/core';
import {NgbActiveModal, NgbModal} from "@ng-bootstrap/ng-bootstrap";
import {ExampleComponent } from "../components/modals/moder-info/example.component";


@Component({
  selector: 'modal-template',
  template: `
    <div class="modal-header">
      <h4 class="modal-title" [innerText]="title"></h4>
      <button type="button" class="close" aria-label="Close" (click)="close()">
        <span aria-hidden="true">&times;</span>
      </button>
    </div>
    <div class="modal-body">
      <ng-content *ngComponentOutlet="childComponent;"></ng-content>
    </div>
    <div class="modal-footer">
      <button type="button" class="btn btn-outline-dark" (click)="close()">Close</button>
    </div>
  `
})
export class ModalTemplate {
  @Input() title;
  @Input() onClose;
  @Input() childComponent;

  constructor(public activeModal: NgbActiveModal) {}

  close() {
    this.activeModal.dismiss('close');
    this.onClose();
  }
}

export interface ModalServiceOptions {
  data: any;
  title: string
  onClose: any,
  componentName: string
}


@Injectable({
  providedIn: 'root'
})
export class ModalService {
  constructor(private mService: NgbModal) {}

  open(options: ModalServiceOptions) {
    let types = {'example': ExampleComponent };
    let modal = this.mService.open(ModalTemplate, {size: 'lg'});

    modal.componentInstance.title = options.title;
    modal.componentInstance.onClose = options.onClose;

    let component = types[options.componentName];

    component.ngBaseDef.inputs.data = options.data;
    modal.componentInstance.childComponent = types[options.componentName];
  }
}

ExampleComponent

import {Component, Input, OnInit} from '@angular/core';

@Component({
  selector: 'example-component',
  templateUrl: './example.component.html',
  styleUrls: ['./example.component.sass']
})
export class ExampleComponent implements OnInit {
  @Input() data;

  constructor() {
    let dataOfConstructor: any = this.constructor;
    let data = dataOfConstructor.ngBaseDef.inputs.data;
    console.log('data:', data); // Here is my data, i injected it above
  }

  ngOnInit() {
  }

}

祝你今天愉快！ 希望能帮助到你！

Answer 3

基本上，有两种方法可以实现动态注入。

1. 通过构造函数注入值，使用自定义（或全局）注入器： *ngComponentOutlet="myComponent; injector: myInjector ，其中myInjector是您要使用的注入器（如果默认注入器正常 - 通过添加从父上下文中获取它public myInjector: Injector in your parent component's constructor). 这对我来说不是一个选择，因为我想保持我的动态（子）组件的构造函数干净。

2. 创建组件时调用的回调，并在该回调中分配您的@Input值并手动订阅您的@Output 。 现在， ngComponentOutlet不提供任何回调功能，因此您可能不得不重新发明轮子——创建一个支持回调的ngComponentOutlet指令。 而这正是该解决方案的全部内容。

我创建了一个自定义指令myComponentOutlet ( https://github.com/angular/angular/issues/15360#issuecomment-1070420494 ) - ngComponentOutlet的可自定义模拟。 希望它最终会进入 Angular 的 src。

这是指令：

import {
  AfterViewInit,
  ComponentFactoryResolver,
  ComponentRef,
  Directive,
  ElementRef,
  EventEmitter,
  Injector,
  Input,
  OnDestroy,
  Output,
  Type,
  ViewContainerRef
} from '@angular/core';

/*
  USAGE:

    <div myComponentOutlet
           [component]="inner.component"
           [injector]="inner.injector"
           (create)="componentCreated($event)"></div>
 */

@Directive({
  selector: '[myComponentOutlet]',
})
export class MyComponentOutletDirective<T> implements AfterViewInit, OnDestroy {

  @Input() component: Type<T>;
  @Input() injector: Injector;
  @Output() create = new EventEmitter<ComponentRef<T>>();
  @Output() destroy = new EventEmitter<ComponentRef<T>>();

  private componentRef: ComponentRef<T>;

  constructor(
    private viewContainerRef: ViewContainerRef,
    private resolver: ComponentFactoryResolver,
    private elRef: ElementRef,
    private globalInjector: Injector
  ) {
    this.injector = globalInjector;
  }

  ngAfterViewInit() {
    const injector = this.injector || this.globalInjector;
    const factory = this.resolver.resolveComponentFactory(this.component);
    this.componentRef = this.viewContainerRef.createComponent(factory, 0, injector);

    this.elRef.nativeElement.appendChild(this.componentRef.location.nativeElement);
    this.create?.emit(this.componentRef);
  }

  ngOnDestroy(): void {
    this.destroy?.emit(this.componentRef);
  }
}

这是用法：

<div myComponentOutlet
           [component]="inner.component"
           [injector]="inner.injector"
           (create)="componentCreated($event)"></div>

根据自己的需要调整

它不像<div *ngComponentOutlet="myComponent; inputs:[...]; outputs:[...]"></div>那样健壮，但它确实不错，而且非常干净而且可以工作。