Dans les exemples ci-dessus, l'objet Subscription retourné par la méthode subscribe est simplement ignoré.

Unsubscribe dans ngOnDestroy

On profite généralement du "Lifecycle Hook" ngOnDestroy pour déclencher l'unsubscribe.

private _bookListSubscription: Subscription;
​
constructor(private _bookRepository: BookRepository) {
}
​
ngOnInit() {
    this._bookListSubscription = this._bookRepository.getBookList()
        .subscribe(bookList => this.bookList = bookList);
}
​
ngOnDestroy() {
    this._bookListSubscription.unsubscribe();
}

Et par précaution dans le cas où la subscription est créé plus tard.

ngOnDestroy() {
    if (this._bookListSubscription != null) {
        this._bookListSubscription.unsubscribe();
    }
}

L'inconvénient de cette approche est sa verbosité. Elle en devient "error-prone".

Unsubscribe avec l'opérateur takeUntil

export class BookSearchComponent implements OnDestroy, OnInit {
​
    bookList: Book[];
​
    private _isDead$ = new Subject();
​
    constructor(private _bookRepository: BookRepository) {
    }
​
    ngOnInit() {
        this._bookRepository.getBookList()
            .pipe(takeUntil(this._isDead$))
            .subscribe(bookList => this.bookList = bookList);
    }
​
    ngOnDestroy() {
        this._isDead$.next();
    }
​
}

Exemple

​https://github.com/wishtack/wishtack-book-shop/tree/7-unsubscribe-using-take-until​

Unsubscribe avec le Pipe async

Dans les cas les plus simples, cette approche est la plus adaptée car c'est la moins verbeuse est la plus réactive.

Le "pipe" async permet de préparer l'Observable dans le composant et laisser la vue subscribe quand elle en a besoin et si elle en a besoin.

export class BookSearchComponent {
​
    bookList$: Observable<Book[]>;
​
    constructor(private _bookRepository: BookRepository) {
        this.bookList$ = this._bookRepository.getBookList();
    }
​
}

Remarquez que l'on se permet de créer l'Observable directement dans le constructeur. En effet, tant que l'on ne subscribe pas, aucun traitement n'est déclenché.

A éviter

export class BookSearchComponent {
​
    bookList$ = this._bookRepository.getBookList();
​
    constructor(private _bookRepository: BookRepository) {
    }
​
}

Fonctionnement du "pipe" async

<wt-book-preview
        *ngFor="let book of bookList$ | async"
        [book]="book"></wt-book-preview>

Le "pipe" async subscribe à l'Observable bookList$ et permet de mettre à jour la vue en conséquence.

A la destruction de l'élément (e.g. : "toggle" de la liste via *ngIf), le "pipe" async unsubscribe automagiquement.

Gotcha

En essayant d'afficher le nombre de "book" en créant un autre Observable :

export class BookSearchComponent {
​
    bookCount$: Observable<number>;
    bookList$: Observable<Book[]>;
​
    constructor(private _bookRepository: BookRepository) {
        this.bookList$ = this._bookRepository.getBookList();
        this.bookCount$ = this.bookList$.pipe(map(bookList => bookList.length));
    }
​
}

<div>{{ bookCount$ | async }}</div>
​
<wt-book-preview
        *ngFor="let book of bookList$ | async"
        [book]="book"></wt-book-preview>

shareReplay

Le comportement souhaité est le suivant :

• Tant qu'il n'y a aucun appel à subscribe (explicite ou implicite via async), le traitement ne doit pas s'exécuter.

• Au premier subscribe, le traitement doit être déclenché.

• Les subscribes supplémentaires ne doivent pas redéclencher le traitement mais simplement attendre le résultat.

• Les souscripteurs qui arrivent après la récupération du résultat doivent récupérer la dernière valeur obtenue.

L'intégralité de se traitement se fait simplement avec l'opérateur shareReplay en lui indiquant en paramètre la taille du buffer de mémorisation. Un buffer de taille 1 va mémoriser la dernière valeur.

Le problème décrit au paragraphe précédent est alors résolu ainsi :

export class BookSearchComponent {
​
    bookCount$: Observable<number>;
    bookList$: Observable<Book[]>;
​
    constructor(private _bookRepository: BookRepository) {
        this.bookList$ = this._bookRepository.getBookList()
            .pipe(shareReplay(1));
        this.bookCount$ = this.bookList$.pipe(map(bookList => bookList.length));
    }
​
}

Gestion d'erreurs

Pour capturer les erreurs et détecter la fin du traitement (i.e. try / catch / finally), il suffit d'utiliser les opérateurs catchError et finalize.

EMPTY est une constante contenant un Observable vide. Vous êtes libres de retourner un Observable contenant des données (de secours) provenant d'une autre source (cache etc...).

import { EMPTY, Observable } from 'rxjs';
import { catchError, finalize, map, shareReplay } from 'rxjs/operators';
​
this.bookList$ = this._bookRepository.getBookList()
    .pipe(
        catchError(error => {
            console.error(error);
            return EMPTY;
        }),
        finalize(() => {
            console.log('Done!');
        }),
        shareReplay(1)
    );

Exemple

​https://github.com/wishtack/wishtack-book-shop/tree/8-unsubscribe-using-async-pipe​

Pour reproduire l'erreur ci-dessus, vous pouvez bloquer le domaine de l'API sur Chrome via le menu décrit ci-dessous.

RxScavenger

​https://blog.wishtack.com/2018/05/30/handle-rxjs-subscriptions-properly-using-rx-scavenger/​