wysyłanie wielu działań w jednym efekcie

Question

Chciałbym diapatch dwie akcje w jednym efekcie. Obecnie mam zadeklarować dwa efekty, aby osiągnąć w ten sposób:

// first effect 
    @Effect() action1$ = this.actions$ 
    .ofType(CoreActionTypes.MY_ACTION) 
    .map(res => { 
     return { type: "ACTION_ONE"} 
    }) 
    .catch(() => Observable.of({ 
     type: CoreActionTypes.MY_ACTION_FAILED 
    })); 

    // second effect 
    @Effect() action2$ = this.actions$ 
    .ofType(CoreActionTypes.MY_ACTION) 
    .map(res => { 
     return { type: "ACTION_TWO"} 
    }) 
    .catch(() => Observable.of({ 
     type: CoreActionTypes.MY_ACTION_FAILED 
    })); 

to możliwe, aby mieć jedną akcję, być źródłem dwóch działań poprzez pojedynczy efekt?

Answer 1

mergeMap Można wybrać dla asynchronicznej lub concatMap do synchronizacji

@Effect() action$ = this.actions$ 
    .ofType(CoreActionTypes.MY_ACTION) 
    .mergeMap(() => Observable.from([{type: "ACTION_ONE"} , {type: "ACTION_TWO"}])) 
    .catch(() => Observable.of({ 
     type: CoreActionTypes.MY_ACTION_FAILED 
    })); 

Answer 2

Można użyć switchMap i Observable.of.

@Effect({ dispatch: true }) action$ = this.actions$ 
    .ofType(CoreActionTypes.MY_ACTION) 
    .switchMap(() => Observable.of(
     // subscribers will be notified 
     {type: 'ACTION_ONE'} , 
     // subscribers will be notified (again ...) 
     {type: 'ACTION_TWO'} 
    )) 
    .catch(() => Observable.of({ 
     type: CoreActionTypes.MY_ACTION_FAILED 
    })); 

kwestie wydajności:

Zamiast wysyłania wielu działań, które będą spust wszyscy abonenci tyle razy, ile wysyłką, może warto spojrzeć w redux-batched-actions.

Umożliwia to ostrzeżenie subskrybentów tylko wtedy, gdy wszystkie te działania zostały zastosowane do sklepu.

Na przykład:

@Effect({ dispatch: true }) action$ = this.actions$ 
    .ofType(CoreActionTypes.MY_ACTION) 
    // subscribers will be notified only once, no matter how many actions you have 
    // not between every action 
    .map(() => batchActions([ 
     doThing(), 
     doOther() 
    ])) 
    .catch(() => Observable.of({ 
     type: CoreActionTypes.MY_ACTION_FAILED 
    })); 

Answer 3

można również wykorzystać uruchamiać() i() store.next

zrobić pozwala dołączyć wywołania zwrotnego do zaobserwowania bez wpływu na inne podmioty/wymiana możliwe do zaobserwowania

np.

@Effect() action1$ = this.actions$ 
.ofType(CoreActionTypes.MY_ACTION) 
.do(myaction => this.store.next({type: 'ACTION_ONE'})) 
.switchMap((myaction) => Observable.of(
    {type: 'ACTION_TWO'} 
)) 
.catch(() => Observable.of({ 
    type: CoreActionTypes.MY_ACTION_FAILED 
})); 

(trzeba będzie odniesienie do sklepu w swojej klasie efekty)

Answer 4

@Effect() loadInitConfig$ = this.actions$ 
    .ofType(layout.ActionTypes.LOAD_INIT_CONFIGURATION) 
    .map<Action, void>(toPayload) 
    .switchMap(() => this.settingsService.loadInitConfiguration() 
     .mergeMap((data:any) => { 
      return [ 
       new layout.LoadInitConfigurationCompleteAction(data.settings), 
       new meetup.LoadInitGeolocationCompleteAction(data.geolocation) 
      ]; 
     }) 
     .catch(error => Observable.of(new layout.LoadInitConfigurationFailAction({ error }))) 
    );