TypeScript Subscription.add方法代碼示例

    return Observable.create(o => {
      const disposables = new Subscription()
      log.debug(
        `Subscribing to topic [${topic}]. Is connected [${this.isConnected}]`
      )

      if (!this.isConnected) {
        o.error(
          new Error(
            `Session not connected, can\'t subscribe to topic [${topic}]`
          )
        )
        return disposables
      }

      let subscription
      this.autobahn.session
        .subscribe(topic, (response: Array<any>) => {
          this.logResponse(topic, response)
          o.next(response[0])
        })
        .then(
          sub => {
            // subscription succeeded, subscription is an instance of autobahn.Subscription
            log.verbose(`subscription acked on topic [${topic}]`)
            subscription = sub
          },
          (error: Error) => {
            // subscription failed, error is an instance of autobahn.Error
            log.error(`Error on topic ${topic}`, error)
            o.error(error)
          }
        )

      disposables.add(
        new Subscription(() => {
          if (!subscription) {
            return
          }
          try {
            this.autobahn.session
              .unsubscribe(subscription)
              .then(
                gone =>
                  log.verbose(`Successfully unsubscribing from topic ${topic}`),
                err => log.error(`Error unsubscribing from topic ${topic}`, err)
              )
          } catch (err) {
            log.error(`Error thrown unsubscribing from topic ${topic}`, err)
          }
        })
      )
      return disposables
    })

 .subscribe(limitCheckResult => {
   if (limitCheckResult) {
     const request = serviceClient
       .createRequestResponseOperation(
         'executeTrade',
         executeTradeRequest
       )
       .publish()
       .refCount()
     disposables.add(
       Observable.merge(
         request
           .map(dto => {
             const trade = tradeMapper.mapFromTradeDto(dto.Trade)
             log.info(
               `execute response received for: ${executeTradeRequest}. Status: ${trade.status}`,
               dto
             )
             return createExecuteTradeResponse(trade)
           })
           // if we never receive a response, mark request as complete
           .timeout(
             EXECUTION_REQUEST_TIMEOUT_MS,
             Scheduler.asap.schedule(() =>
               createExecuteTradeResponseForError(
                 'Trade execution timeout exceeded',
                 executeTradeRequest
               )
             )
           ),
         // show timeout error if request is taking longer than expected
         Observable.timer(EXECUTION_CLIENT_TIMEOUT_MS)
           .map(() =>
             createExecuteTradeResponseForError(
               'Trade execution timeout exceeded',
               executeTradeRequest
             )
           )
           .takeUntil(request)
       ).subscribe(o)
     )
   } else {
     o.next(
       createExecuteTradeResponseForError(
         'Credit limit exceeded',
         executeTradeRequest
       )
     )
   }
 })

 constructor(userName: string, autobahn: AutobahnConnectionProxy) {
   this.disposables = new Subscription()
   Guard.isDefined(autobahn, 'autobahn required')
   Guard.isString(userName, 'userName required')
   this.userName = userName
   this.autobahn = autobahn
   this.connectionStatusSubject = new BehaviorSubject(ConnectionStatus.idle)
   this.connectionTypeMapper = new ConnectionTypeMapper()
   this.connectCalled = false
   this.isConnected = false
   this.autoDisconnectDisposable = new SerialSubscription()
   this.connectionUrl = ''
   this.connectionType = ConnectionType.Unknown
   this.disposables.add(this.autoDisconnectDisposable)
 }