Modo corretto per smaltire un dispositivo monouso all'interno di un osservabile

Question

Ho un HTTPService che restituisce un Observable<NSData>. Il mio obiettivo è comporre quel servizio in un altro servizio, ServiceA che trasforma i dati per il mio caso d'uso. L'utilizzo di Observable.create in RxSwift 2.0.0-rc.0 in ServiceA è abbastanza semplice. La mia domanda è come gestire correttamente il monouso restituito dalla sottoscrizione dello HTTPService.

Se non si esegue alcuna operazione, viene visualizzato il messaggio di compilazione in cui viene indicato result of call is unused: http://git.io/rxs.ud. Capisco dalla lettura che se non faccio niente è probabile ok: (dove xs accennato sotto è let xs: Observable<E> ....

In caso xs termina in modo prevedibile con Completato o Messaggio di errore, non la manipolazione di sottoscrizione monouso non colerà alcuna risorsa , ma è ancora preferito così perché in quell'elemento modo di calcolo è terminato al momento prevedibile.

Così qui è come attualmente sto rivolgo, e anche il luogo dove mi chiedo se sto facendo questo correttamente o se ho incompreso qualcosa

public struct ServiceA{ 

    public static func changes() -> Observable<ChangeSet>{ 
     return Observable.create{ observable in 

      // return's Observable<NSData> 
      let request = HTTPService.get("https://httpbin.org/get") 

      let disposable = request.subscribe(
       onNext: { data in 
        // Do more work to transform this data 
        // into something meaningful for the application. 
        // For example purposes just use an empty object 
        observable.onNext(ChangeSet()) 
        observable.onCompleted() 
       }, 

       onError:{ error in 
        observable.onError(error) 
       }) 

      // Is this the right way to deal with the 
      // disposable from the subscription in this situation? 
      return AnonymousDisposable{ 
       disposable.dispose() 
      } 
     } 
    } 
} 

Answer 1

Come documentation dice

sottoscrivere funzione restituisce un abbonamento usa e getta che può essere utilizzato per annullare il calcolo e risorse gratuite.
Il modo preferito per terminare queste chiamate fluide è utilizzando .addDisposableTo (disposeBag) o in qualche modo equivalente. Quando lo sconto disposeBag viene deallocato, l'abbonamento sarà automaticamente eliminato.

In realtà il vostro esempio guarda bene in termini di regole, ma loos piuttosto male;) (Inoltre sarebbe bene, se si sarebbe solo restituire questo disposable):

public static func changes() -> Observable<ChangeSet>{ 
     return Observable.create{ observable in 

      // return's Observable<NSData> 
      let request = HTTPService.get("https://httpbin.org/get") 

      return request.subscribe(
       onNext: { data in 
        // Do more work to transform this data 
        // into something meaningful for the application. 
        // For example purposes just use an empty object 
        observable.onNext(ChangeSet()) 
        observable.onCompleted() 
       }, 

       onError:{ error in 
        observable.onError(error) 
        }) 
} 

Ma come si si restituendo Observeble Mi chiedo, perché non usi l'operatore map?

Nel tuo esempio, sarebbe qualcosa di simile:

public static func changes() -> Observable<ChangeSet> { 
    return HTTPService.get("https://httpbin.org/get") 
         .map(ChangeSet.init) 
}