usingstaticMyApp.App;// static reference on top of your fileStore.Dispatch(newNavigateAction{PageName="Page1"});Store.Dispatch(newNavigateAction{PageName="Page2"});Store.Dispatch(newGoBackAction());

usingstaticMyApp.App;// static reference on top of your fileStore.ObserveAction<NavigateAction>().Subscribe(_=>{// TODO : Handle navigation});Store.Select(state=>state.CurrentPage).Where(currentPage=>currentPage==nameof(Page1)).Subscribe(_=>{// TODO : Handle event when the current page is now "Page1"});

Reducers on action

returnnewList<On<RootState>>{On<NavigateAction,RootState>((state,action)=>state.With(new{Pages=state.Pages.Add(action.PageName)})),On<GoBackAction,RootState>(        state=>{varnewPages=state.Pages.RemoveAt(state.Pages.Length-1);returnstate.With(new{CurrentPage=newPages.LastOrDefault(),Pages=newPages});}),On<ResetAction,RootState>(        state=>state.With(new{CurrentPage=string.Empty,Pages=ImmutableArray<string>.Empty}))};

Sub-reducers aka feature reducers

publicstaticIEnumerable<On<RootState>>CreateReducers(){varcounterReducers=Counter.Reducers.CreateReducers();varticTacToeReducers=TicTacToe.Reducers.CreateReducers();vartodoListReducers=TodoList.Reducers.CreateReducers();varpokedexReducers=Pokedex.Reducers.CreateReducers();returnCreateSubReducers(counterReducers.ToArray(),SelectCounterState).Concat(CreateSubReducers(ticTacToeReducers.ToArray(),SelectTicTacToeState)).Concat(CreateSubReducers(todoListReducers.ToArray(),SelectTodoListState)).Concat(CreateSubReducers(pokedexReducers.ToArray(),SelectPokedexState));}

Full state

Store.Select().Subscribe(state=>{// Listening to the full state (when any property changes)});

Inline function

Store.Select(state=>state.CurrentPage).Subscribe(currentPage=>{// Listening to the "CurrentPage" property of the state (when only this property changes)});

Simple selectors

publicstaticISelectorWithoutProps<RootState,string>SelectCurrentPage=CreateSelector((RootStatestate)=>state.CurrentPage);publicstaticISelectorWithoutProps<RootState,ImmutableArray<string>>SelectPages=CreateSelector((RootStatestate)=>state.Pages);Store.Select(SelectCurrentPage).Subscribe(currentPage=>{// Listening to the "CurrentPage" property of the state (when only this property changes)});

Reuse selectors - without props

publicstaticISelectorWithoutProps<RootState,bool>SelectHasPreviousPage=CreateSelector(SelectPages,(ImmutableArray<string>pages)=>pages.Count()>1);

Reuse selectors - with props

publicstaticISelectorWithProps<RootState,string,bool>SelectIsPageSelected=CreateSelector(SelectCurrentPage,(stringcurrentPage,stringselectedPage)=>currentPage==selectedPage);

Store.Select(SelectIsPageSelected,"mainPage").Subscribe(isMainPageSelected=>{// TODO});

Combine selectors

Store.Select(CombineSelectors(SelectGameEnded,SelectWinner)).Subscribe(x=>{var(gameEnded,winner)=x;// TODO});

The 3-actions pattern

publicclassGetTodosAction{}publicclassGetTodosFulfilledAction{publicImmutableList<Todo>Todos{get;set;}}publicclassGetTodosFailedAction{publicintStatusCode{get;set;}publicstringReason{get;set;}}

Store.Dispatch(newGetTodosAction());

Create and register effect

publicstaticEffect<RootState>GetTodos=CreateEffect<RootState>(()=>Store.ObserveAction<GetTodosAction>().Select(_=>_todoApi.GetTodos()).Switch().Select(todos=>{returnnewGetTodosFulfilledAction{Todos=todos.ToImmutableList()};}).Catch(e=>{returnObservable.Return(newGetTodosFailedAction{StatusCode=e.StatusCode,Reason=e.Reason});}),true// indicates if the ouput of the effect should be dispatched to the store);

Store.RegisterEffects(GetTodos);

Enable time travel

sealedpartialclassApp{publicstaticreadonlyReduxStore<RootState>Store;staticApp(){Store=newReduxStore<RootState>(CreateReducers(),true);}}

Go back in time...

if(Store.CanUndo){Store.Undo();}

Store.Select().Subscribe(_=>{// TODO : Handle event when the State changed// You can observe the previous state generated or...});Store.ObserveUndoneAction().Subscribe(_=>{// TODO : Handle event when an Undo event is triggered// ...or you can observe actions undone});

...And then rewrite history

Start a new timeline

// Dispatch the next actionsStore.Dispatch(newNavigateAction{PageName="Page1"});Store.Dispatch(newNavigateAction{PageName="Page2"});if(Store.CanUndo){// Go back in time (Page 2 -> Page 1)Store.Undo();}// Dispatch a new action (Page 1 -> Page 3)Store.Dispatch(newNavigateAction{PageName="Page3"});

Stay on the same timeline of events

// Dispatch the next actionsStore.Dispatch(newNavigateAction{PageName="Page1"});Store.Dispatch(newNavigateAction{PageName="Page2"});if(Store.CanUndo){// Go back in time (Page 2 -> Page 1)Store.Undo();}if(Store.CanRedo){// Go forward (Page 1 -> Page 2)Store.Redo();}

Store.Reset();

Store.ObserveReset().Subscribe(_=>{// TODO : Handle event when the Store is reset// (example: flush navigation history and restart from login page)});

publicclassTodoItemEntityState:EntityState<TodoItem,int>{}publicstaticclassEntities{publicstaticEntityAdapter<TodoItem,int>TodoItemAdapter=EntityAdapter<TodoItem,int>.Create(item=>item.Id);}

publicclassTodoListState{publicTodoItemEntityStateItems{get;set;}publicTodoFilterFilter{get;set;}}

On<CompleteTodoItemAction,TodoListState>((state,action)=>{returnstate.With(new{Items=TodoItemAdapter.UpsertOne(new{action.Id,Completed=true},state.Items)});})

privatestaticreadonlyISelectorWithoutProps<RootState,TodoItemEntityState>SelectItemsEntityState=CreateSelector(SelectTodoListState,    state=>state.Items);privatestaticreadonlyEntitySelectors<RootState,TodoItem,int>TodoItemSelectors=TodoItemAdapter.GetSelectors(SelectItemsEntityState);

publicstaticISelectorWithoutProps<RootState,List<TodoItem>>SelectItems=TodoItemSelectors.SelectEntities;

publicclassRootState:IBaseRouterState{publicRouterStateRouter{get;set;}publicstaticRootStateInitialState=>newRootState{Router=RouterState.InitialState};}

For UWP

protectedoverridevoidOnLaunched(LaunchActivatedEventArgse){// TODO : Initialize rootFrame// Enable router store featureStore.EnableRouterFeature(rootFrame);}

For UWP

publicstaticreadonlyReduxStore<RootState>Store=newReduxStore<RootState>(CreateReducers(),RootState.InitialState,true);

awaitStore.OpenDevToolsAsync();