C# Store.Dispatch方法代码示例

        public void should_prvide_way_to_create_deep_hierarchy_of_reducers()
        {
            var originReducer = new SimpleReducer<Address>().When<SetOrigin>((s, e) => e.newAddress);
            var destinationReducer = new CompositeReducer<Destination>()
                .Part(s => s.deliver,
                    new SimpleReducer<DeliveryMethod>().When<BehindSchedule>((s, a) => DeliveryMethod.REGULAR)
                        .When<SetDelivery>((_, a) => a.method))
                .Part(s => s.addr, new SimpleReducer<Address>().When<SetDestination>((s, a) => a.newAddress));
            var orderReducer = new CompositeReducer<Order>()
                .Part(s => s.origin, originReducer)
                .Part(s => s.destination, destinationReducer);
            var store = new Store<Order>(orderReducer);
            store.Dispatch(new SetOrigin {newAddress = new Address {streetNr = "Laugavegur 26", city = "Reykjavík"}});
            store.Dispatch(new SetDestination {newAddress = new Address {streetNr = "5th Avenue", city = "New York"}});
            store.Dispatch(new SetDelivery {method = DeliveryMethod.GUARANTEED});

            store.Dispatch(new BehindSchedule());

            Assert.AreEqual(new Order
            {
                origin = new Address {streetNr = "Laugavegur 26", city = "Reykjavík"},
                destination =
                    new Destination
                    {
                        addr = new Address {streetNr = "5th Avenue", city = "New York"},
                        deliver = DeliveryMethod.REGULAR
                    }
            }, store.GetState());
        }

        public void should_prvide_way_to_combine_reducers()
        {
            var topicReducer = new SimpleReducer<string>().When<TopicSet>((s, e) => e.topic);
            var visibilityReducer = new SimpleReducer<bool>().When<FilterVisibility>((s, e) => e.visible);
            var reducer = new CompositeReducer<AppStore>(() => new AppStore {redditTopic = "react", visibility = false})
                .Part(s => s.redditTopic, topicReducer)
                .Part(s => s.visibility, visibilityReducer);
            var store = new Store<AppStore>(reducer);
            store.Dispatch(new TopicSet {topic = "Redux is awesome"});
            store.Dispatch(new FilterVisibility {visible = true});

            Assert.AreEqual(new AppStore {redditTopic = "Redux is awesome", visibility = true}, store.GetState());
        }

        public async void should_allow_for_passing_parameters_to_async_actions()
        {
            var storeReducerReached = 0;
            var reducer = new SimpleReducer<List<string>>(() => new List<string> {"a"}).When<SomeAction>((s, e) =>
            {
                storeReducerReached += 1;
                return s;
            });
            var store = new Store<List<string>>(reducer);

            var action1 = store.asyncAction<LoginInfo, int>(async (dispatcher, store2, msg) =>
            {
                await Task.Delay(300);
                Assert.That(msg.username, Is.EqualTo("John"));
                dispatcher(new SomeAction());
                return 112;
            });
            var result = await store.Dispatch(action1(new LoginInfo
            {
                username = "John"
            }));

            Assert.That(storeReducerReached, Is.EqualTo(1));
            Assert.That(result, Is.EqualTo(112));
        }

        public void should_allow_middleware_to_hook_into_dispatching()
        {
            var storeReducerReached = 0;
            var reducer = new SimpleReducer<List<string>>().When<SomeAction>((s, e) =>
            {
                storeReducerReached += 1;
                return s;
            });
            var store = new Store<List<string>>(reducer);
            var middlewareCounter = 0;
            store.Middleware(
                s => next => action =>
                {
                    middlewareCounter += 3;
                    Assert.That(middlewareCounter, Is.EqualTo(3));
                    next(action);
                    middlewareCounter += 3000;
                    Assert.That(middlewareCounter, Is.EqualTo(3333));
                },
                s => next => action =>
                {
                    middlewareCounter += 30;
                    Assert.That(middlewareCounter, Is.EqualTo(33));
                    Assert.That(storeReducerReached, Is.EqualTo(0));
                    next(action);
                    Assert.That(storeReducerReached, Is.EqualTo(1));
                    middlewareCounter += 300;
                    Assert.That(middlewareCounter, Is.EqualTo(333));
                }
                );

            store.Dispatch(new SomeAction());
            Assert.That(middlewareCounter, Is.EqualTo(3333));
            Assert.That(storeReducerReached, Is.EqualTo(1));
        }

        public void Should_only_push_the_last_state_before_subscription()
        {
            var sut = new Store<int>(1, Reducers.Replace);
            var mockObserver = new MockObserver<int>();

            sut.Dispatch(new FakeAction<int>(2));
            sut.Subscribe(mockObserver);

            CollectionAssert.AreEqual(new[] { 2 }, mockObserver.Values);
        }

        public void should_notify_subscribers_while_they_are_subscribed()
        {
            var reducer = new SimpleReducer<List<string>>(() => new List<string> {"Use ReduxVVM"});
            var store = new Store<List<string>>(reducer);

            var changed = 0;
            var unsub = store.Subscribe(state =>
            {
                Assert.NotNull(state);
                changed += 1;
            });

            store.Dispatch(new ItemAdded {item = "Read the Redux docs"});
            store.Dispatch(new ItemAdded {item = "Read the Redux docs"});

            Assert.That(changed, Is.EqualTo(2));
            unsub();
            store.Dispatch(new ItemAdded {item = ""});

            Assert.That(changed, Is.EqualTo(2));
        }

        public void should_register_root_reducer_with_builder()
        {
            var reducer = new SimpleReducer<List<string>>(() => new List<string> {"Use ReduxVVM"})
                .When<ItemAdded>((state, action) =>
                {
                    var newSatte = new List<string>(state);
                    newSatte.Add(action.item);
                    return newSatte;
                })
                .Get();
            var store = new Store<List<string>>(reducer);
            store.Dispatch(new ItemAdded {item = "Read the Redux docs"});

            CollectionAssert.AreEqual(store.GetState(), new List<string> {"Use ReduxVVM", "Read the Redux docs"});
        }

        public void Should_push_state_to_end_of_queue_on_nested_dispatch()
        {
            var sut = new Store<int>(1, Reducers.Replace);
            var mockObserver = new MockObserver<int>();
            sut.Subscribe(val =>
            {
                if (val < 5)
                {
                    sut.Dispatch(new FakeAction<int>(val + 1));
                }
                mockObserver.OnNext(val);
            });

            CollectionAssert.AreEqual(new[] { 1, 2, 3, 4, 5 }, mockObserver.Values);
        }

        public void Middleware_should_be_called_for_each_action_dispatched()
        {
            var numberOfCalls = 0;
            Middleware<int> spyMiddleware = store => next => action =>
            {
                numberOfCalls++;
                return next(action);
            };

            var sut = new Store<int>(1, Reducers.Replace, spyMiddleware);
            var mockObserver = new MockObserver<int>();
            
            sut.Subscribe(mockObserver);
            sut.Dispatch(new FakeAction<int>(2));

            Assert.AreEqual(1, numberOfCalls);
            CollectionAssert.AreEqual(new[] { 1, 2 }, mockObserver.Values);
        }

        public async void all_in_one_example(){
            var reducer = new SimpleReducer<AppState>()
                .When<LoginStarted>((status, action) => {
                    status.Username = action.Username;
                    status.Token = "";
                    status.Status = LoginStatus.LoginInProgress;
                    return status;
                })
                .When<LoginSucceeded>((status, action) => {
                    status.Token = action.Token;
                    status.Status = LoginStatus.LoggedIn;
                    return status;
                })
                .When<LoginFailed>((status, action) => {
                    status.Status = LoginStatus.NotLoggedIn;
                    return status;
                });

            var store = new Store<AppState>(reducer);

            var loginAsyncAction = store.asyncAction(async(dispatch, getState) => {
                dispatch(new LoginStarted{Username = "John Doe"});

                // faking authentication of user
                await Task.Delay(500);
                var authenticated = new Random().Next() % 2 == 0;

                if (authenticated) {
                    dispatch(new LoginSucceeded{Token = "1234"});
                } else {
                    dispatch(new LoginFailed());
                }
                return  authenticated;
            });

            var logged = await store.Dispatch(loginAsyncAction);

            if (logged){
                Assert.That(store.GetState().Status, Is.EqualTo(LoginStatus.LoggedIn));
            } else {
                Assert.That(store.GetState().Status, Is.EqualTo(LoginStatus.NotLoggedIn));
            }
        }

        public async void should_allow_for_async_execution_of_code()
        {
            var storeReducerReached = 0;
            var reducer = new SimpleReducer<List<string>>(() => new List<string> {"a"}).When<SomeAction>((s, e) =>
            {
                storeReducerReached += 1;
                return s;
            });
            var store = new Store<List<string>>(reducer);

            var result = await store.Dispatch(store.asyncAction<int>(async (dispatcher, store2) =>
            {
                await Task.Delay(300);
                Assert.That(store2()[0], Is.EqualTo("a"));
                dispatcher(new SomeAction());
                return 112;
            }));

            Assert.That(storeReducerReached, Is.EqualTo(1));
            Assert.That(result, Is.EqualTo(112));
        }

        public void should_register_root_reducer()
        {
            Reducer<List<string>> reducer = (List<string> state, Object action) =>
            {
                if (action.GetType() == typeof (InitStoreAction)) return new List<string> {"Use ReduxVVM"};

                var newState = new List<string>(state);

                switch (action.GetType().Name)
                {
                    case "ItemAdded":
                        var concreteEv = (ItemAdded) action;
                        newState.Add(concreteEv.item);
                        break;
                    default:
                        break;
                }
                return newState;
            };
            var store = new Store<List<string>>(reducer);
            store.Dispatch(new ItemAdded {item = "Read the Redux docs"});

            CollectionAssert.AreEqual(store.GetState(), new List<string> {"Use ReduxVVM", "Read the Redux docs"});
        }

        public void should_return_same_state_when_command_not_for_that_reducer()
        {
            var reducer = new SimpleReducer<List<string>>(() => new List<string> {"Use ReduxVVM"});
            var store = new Store<List<string>>(reducer);
            store.Dispatch(new ItemAdded {item = "Read the Redux docs"});

            CollectionAssert.AreEqual(store.GetState(), new List<string> {"Use ReduxVVM"});
        }

        public void GetState_should_return_the_latest_state()
        {
            var sut = new Store<int>(1, Reducers.Replace);

            sut.Dispatch(new FakeAction<int>(2));

            Assert.AreEqual(2, sut.GetState());
        }