Betreff <any> Fang die Subscribe-und Abmelde-Methoden

Question

Ich möchte eine RXJS Betreff zu zwingen, nur einen Teilnehmer auf einmal zu haben. und ich möchte die Anzahl der Abonnements zählen die Bedingung

import { Subject } from 'rxjs/Subject'; 


/** 
* FormDialogActionModel 
*/ 
export class FormDialogActionModel { 
    public $customAction: Subject<CustomAction> = new Subject<CustomAction>(); 

    private positiveActionSubscribers: number = 0; 
    private customActionSubscribers: number = 0; 
    private $positiveAction: Subject<Object> = new Subject<Object>();  
    private internalToken = 'FORM-DIALOG-SERVICE-GET-POSITIVE-ACTION-WITHOUT-TRIGGERING-GET-RESTRICTIONS'; 

    /** 
    * This get method was created to force the number of subscribers to 1 
    */ 
    public get $$positiveAction(): Subject<Object> { 
     this.positiveActionSubscribers ++; 
     if(this.positiveActionSubscribers > 1){ 
      throw new Error('Somebody already subscribed to a positive action. You cannot subscribe to it again until the subscribes unsubscribes');    
     } 

     return this.$positiveAction;  
    } 

    public unSubscribePositiveAction(){ 
     this.positiveActionSubscribers --; 
    } 

    public getPositiveAction(token){ 
     if(token != this.internalToken){ 
      throw new Error('The get mothod getPositiveAction was created only for form-dialog.service'); 
     } 

     return this.$positiveAction; 
    } 
} 

export interface CustomAction { 
    data: Object; 
    customActionIdentifier: string; 
} 

Gibt es eine Möglichkeit zur Durchsetzung der abonnieren Ereignis cachen und increse den Zähler und abmelden es decrese? Ich mag der andere clases nicht wissen, was hinter geschieht und diese gezwungen wird, nur ein Teilnehmer auf Zeit, die sauber aussieht

Answer 1

Eine mögliche Lösung zu haben recht ist Gegenstand Klasse zu erweitern und diese Implementierung anstelle

import { Subject } from 'rxjs/Subject'; 
import { Observer } from 'rxjs/Observer'; 
import { Observable } from 'rxjs/Observable'; 
import { PartialObserver } from 'rxjs/Observer'; 
import { Subscription } from 'rxjs/Subscription'; 

export class RxSingleSubject<T> extends Subject<T>{ 

    constructor(destination?: Observer<T>, source?: Observable<T>) { 
     super(destination, source); 
    } 

    subscribe(observerOrNext?: PartialObserver<T> | ((value: T) => void), error?: (error: any) => void, complete?:() => void): Subscription { 
     if(this.observers.length == 1){ 
      throw new Error("RxjsSingleSubject does not support more then one subscriber.");    
     } 

     return super.subscribe(observerOrNext, error, complete); 
    } 
}