我有一系列的数据对象，它们都继承自同一个基类。

export interface DataObjectBase {
    type: string;
    /* ... other shared fields */
}

export interface DataObjectA extends DataObjectBase { /* ... */ }
export interface DataObjectB extends DataObjectBase { /* ... */ }
export interface DataObjectC extends DataObjectBase { /* ... */ }

对象类型由每个对象上存在的'type'属性的值标识。例如，如果一个对象的type属性是"A"，我就可以安全地将其强制转换为DataObjectA。
对于这些对象类型中的每一种，我都有一个组件。这些组件都继承自同一个基类，因此也有共享的@Input()和@Output()绑定，但也可能有自己的显式绑定。
例如：

export class MyComponentBase<T extends DataObjectBase> {
    @Input() public data: T;
    @Input() public someValue: string;
    @Input() public someOtherValue: number;
    @Output() public someOtherValueChanged: EventEmitter<number>;
    @Output() public someEvent: EventEmitter<string>;
}

@Component({selector: 'component-a', templateUrl: './component-a.template.html'})
export class MyComponentA extends MyComponentBase<DataObjectA> { /* ... */ }

@Component({selector: 'component-b', templateUrl: './component-b.template.html'})
export class MyComponentB extends MyComponentBase<DataObjectB> { /* ... */ }

@Component({selector: 'component-c', templateUrl: './component-c.template.html'})
export class MyComponentC extends MyComponentBase<DataObjectC> { /* ... */ }

每个子类化的组件都有自己的模板，并使用内部绑定做不同的事情。
在我的主机组件中，我使用ngSwitch来交换基于数据的组件实现，然而，我发现我需要实现大量重复的绑定样板：

<ng-container [ngSwitch]="data.type">
    <component-a
        *ngSwitchCase="'A'"
        #object
        [data]="data"
        [someValue]="someValue"
        [(someOtherValue)]="someOtherValue"
        (someEvent)="onSomeEvent($event)"></component-a>
    <component-b
        *ngSwitchCase="'B'"
        #object
        [data]="data"
        [someValue]="someValue"
        [(someOtherValue)]="someOtherValue"
        (someEvent)="onSomeEvent($event)"></component-a>
    <component-c
        *ngSwitchCase="'C'"
        #object
        [data]="data"
        [someValue]="someValue"
        [(someOtherValue)]="someOtherValue"
        (someEvent)="onSomeEvent($event)"></component-a>
</ng-container>

我希望能够将重复的#object [data]="data" [someValue]="someValue" [(someOtherValue)]="someOtherValue" (someEvent)="onSomeEvent($event)"简化为类似[sharedBindings]的东西，这样我就可以做更多的事情：

<ng-container [ngSwitch]="data.type">
    <component-a *ngSwitchCase="'A'" [sharedBindings]></component-a>
    <component-b *ngSwitchCase="'B'" [sharedBindings]></component-b>
    <component-c *ngSwitchCase="'C'" [sharedBindings] [cSpecificValue]="foo"></component-c>
</ng-container>

有比这更多的绑定，我已经有大约12个不同的组件和计数。尽可能保持组件无状态意味着这变得越来越麻烦。如何避免重复所有这些绑定？
我尝试创建一个使用to @HostBinding绑定到值的指令：

@Directive({selector: '[sharedBindings]'})
export class SharedBindingsDirective {
    @Input('sharedBindings') public component: MyComponentBase;

    @HostBinding('data')
    public get data(): DataObjectBase {
        return this.component.data;
    }
}

但是，当然，您似乎无法绑定到@Input或@Output属性（我也无法想象在主机组件中也表示#object的方法，以便可以将其作为@ViewChild访问）。
有没有什么方法可以在保持组件本身的多态性的同时合并或折叠重复的绑定？