[](https://www.codefactor.io/repository/github/odonno/reduxsimple)

| Package| Versions|

| -------| --------|

| ReduxSimple|[](https://www.nuget.org/packages/ReduxSimple/)|

| ReduxSimple.Entity|[](https://www.nuget.org/packages/ReduxSimple.Entity/)|

| Package| Versions|

| ---------------------------| ---------------------------------------------------------------------------------------------------------------------------------------|

| ReduxSimple|[](https://www.nuget.org/packages/ReduxSimple/)|

| ReduxSimple.Entity|[](https://www.nuget.org/packages/ReduxSimple.Entity/)|

| ReduxSimple.Uwp|[](https://www.nuget.org/packages/ReduxSimple.Uwp/)|

| ReduxSimple.Uwp.RouterStore|[](https://www.nuget.org/packages/ReduxSimple.Uwp.RouterStore/)|

| ReduxSimple.Uwp.DevTools|[](https://www.nuget.org/packages/ReduxSimple.Uwp.DevTools/)|

| ReduxSimple.Uwp.DevTools|[](https://www.nuget.org/packages/ReduxSimple.Uwp.DevTools/)|

Like the original Redux library, you will have to initialize a new`State` when creating a`Store` + you will create`Reducer` functions each linked to an`Action` which will possibly update this`State`.

Like the original Redux library, you will have to initialize a new`State` when creating a`Store` + you will create`Reducer` functions each linked to an`Action` which will possibly update this`State`.

In your app, you can:

*`Dispatch` new`Action` to change the`State`

* and listen to events/changes using the`Subscribe` method

-`Dispatch` new`Action` to change the`State`

- and listen to events/changes using the`Subscribe` method

You will need to follow the following steps to create your own Redux Store:

(state,action)=>state.With(new {Pages=state.Pages.Add(action.PageName) })

),

On<GoBackAction,RootState>(

{

varnewPages=state.Pages.RemoveAt(state.Pages.Length-1);

returnstate.With(new {

returnstate.With(new {

CurrentPage=newPages.LastOrDefault(),

});

}

),

On<ResetAction,RootState>(

state=>state.With(new {

state=>state.With(new {

CurrentPage=string.Empty,

Pages=ImmutableArray<string>.Empty

})

Store.Select(state=>state.CurrentPage)

.Where(currentPage=>currentPage==nameof(Page1))

.UntilDestroyed(this)

.Subscribe(_=>

{

<summary>Reducers</summary>

<br>

Reducers are pure functions used to create a new`state` once an`action` is triggered.

Reducers are pure functions used to create a new`state` once an`action` is triggered.

(state,action)=>state.With(new {Pages=state.Pages.Add(action.PageName) })

),

On<GoBackAction,RootState>(

{

varnewPages=state.Pages.RemoveAt(state.Pages.Length-1);

returnstate.With(new {

returnstate.With(new {

CurrentPage=newPages.LastOrDefault(),

});

}

),

On<ResetAction,RootState>(

state=>state.With(new {

state=>state.With(new {

CurrentPage=string.Empty,

Pages=ImmutableArray<string>.Empty

})

The`CreateSubReducers` function helps you to create sub-reducers. This function has a few requirements:

* a`Selector` - to be able to access the value of the current nested state

* a`Reducer` - to explicitly detail how to update the parent state given a new value for the nested state

* and the list of reducers using`On` pattern

- a`Selector` - to be able to access the value of the current nested state

- a`Reducer` - to explicitly detail how to update the parent state given a new value for the nested state

- and the list of reducers using`On` pattern

First you need to create a new state lens for feature/nested states:

Based on what you need, you can observe the entire state or just a part of it.

Note that every selector is a*memoized selector* by design, which means that a next value will only be subscribed if there is a difference with the previous value.

Note that every selector is a_memoized selector_ by design, which means that a next value will only be subscribed if there is a difference with the previous value.

Simple selectors are like functions but the main benefits are that they can be reused in multiple components and they can be reused to create other selectors.

Simple selectors are like functions but the main benefits are that they can be reused in multiple components and they can be reused to create other selectors.

publicstaticISelectorWithoutProps<RootState,string>SelectCurrentPage=CreateSelector(

You can also use variables out of the store to create a new selector.

You can also use variables out of the store to create a new selector.

publicstaticISelectorWithProps<RootState,string,bool>SelectIsPageSelected=CreateSelector(

When you work with asynchronous tasks (side effects), you can follow the following rule:

* Create 3 actions - a start action, a`fulfilled` action and a`failed` action

* Reduce/Handle response on`fulfilled` action

* Reduce/Handle error on`failed` action

- Create 3 actions - a start action, a`fulfilled` action and a`failed` action

- Reduce/Handle response on`fulfilled` action

- Reduce/Handle error on`failed` action

Here is a concrete example.

()=>Store.ObserveAction<GetTodosAction>()

.Select(_=>_todoApi.GetTodos())

.Switch()

.Select(todos=>

.Select(todos=>

{

{

Todos=todos.ToImmutableList()

};

})

.Catch(e=>

.Catch(e=>

{

returnObservable.Return(

Store.Select()

.Subscribe(_=>

{

});

Store.ObserveUndoneAction()

.Subscribe(_=>

{

});

Store.ObserveReset()

.Subscribe(_=>

{

});

When dealing with entities, you often repeat the same process to add, update and remove entity from your collection state. With the`ReduxSimple.Entity` package, you can simplify the management of entities using the following pattern:

1. Start creating an`EntityState` and an`EntityAdapter`

1. Start creating an`EntityState` and an`EntityAdapter`

publicclassTodoItemEntityState :EntityState<TodoItem,int>


Sometimes, it can be hard to debug your application. So there is a perfect tool called Redux DevTools which help you with that:

Sometimes, it can be hard to debug your application. So there is a perfect tool called Redux DevTools which help you with that:

* list all dispatched actions

* payload of the action and details of the new state after dispatch

* differences between previous and next state

* replay mechanism (time travel)

- list all dispatched actions

- payload of the action and details of the new state after dispatch

- differences between previous and next state

- replay mechanism (time travel)

* Observe partial state[#7](https://github.com/Odonno/ReduxSimple/pull/7)

*`Reset()` method on`ReduxStore`[#14](https://github.com/Odonno/ReduxSimple/pull/14)

* XML documentation of C# classes and attributes[#16](https://github.com/Odonno/ReduxSimple/pull/16)

- Observe partial state[#7](https://github.com/Odonno/ReduxSimple/pull/7)

-`Reset()` method on`ReduxStore`[#14](https://github.com/Odonno/ReduxSimple/pull/14)

- XML documentation of C# classes and attributes[#16](https://github.com/Odonno/ReduxSimple/pull/16)

* Improvements on sub-reducers, with State lenses[#75](https://github.com/Odonno/ReduxSimple/pull/75)

- Improvements on sub-reducers, with State lenses[#75](https://github.com/Odonno/ReduxSimple/pull/75)