this.toggleAllComplete = ReactiveCommand.createFromObservable(a => {
     var allComplete = this.todos.every(t => t.completed);
     if (allComplete) {
         return this.markAllIncomplete.execute();
     } else {
         return this.markAllComplete.execute();
     }
 }, isNotSaving);

    constructor() {
        super();
        this.navigationStack = new ReactiveArray<any>();
        this.navigate = ReactiveCommand.create(vm => this._navigateImpl(vm));

        var canNavigateBack = this.navigationStack.whenAnyValue(stack => stack.length)
            .map(len => len > 0);
        this.navigateBack = ReactiveCommand.create(() => this._navigateBackImpl(), canNavigateBack);
        this.navigateAndReset = ReactiveCommand.create(vm => this._navigateAndResetImpl(vm));

        this.toProperty(
            this.navigationStack.toObservable().map(arr => arr.length > 0 ? arr[0] : null),
            vm => vm.currentViewModel
        );
    }

    constructor(todoStore: TodoStorage) {
        super([
            "areAllTodosComplete",
            "todos",
            "editedTodo",
            "newTodo",
            "status",
            "_visibleTodos",
            "remainingText"
        ]);
        this._store = todoStore;
        this.editedTodo = null;
        this.newTodo = new Todo();
        this.todos = new ReactiveArray<Todo>();
        this.areAllTodosComplete = false;
        this.completedTodos = this.todos.derived.whenAnyItemProperty().filter(t => t.completed).build();
        this.incompleteTodos = this.todos.derived.whenAnyItemProperty().filter(t => !t.completed).build();
        this.save = ReactiveCommand.createFromTask((a) => {
            return this._store.putTodos(this.todos.toArray());
        });

        var isNotSaving = this.save.isExecuting.map(executing => !executing);

        this.loadTodos = ReactiveCommand.createFromTask((a) => {
            return this._store.getTodos();
        });
        this.loadTodos.results.subscribe(todos => {
            this.todos.splice(0, this.todos.length, ...todos);
        });

        this.deleteTodo = ReactiveCommand.createFromObservable((a: Todo) => {
            var todoIndex = this.todos.indexOf(a);
            if (todoIndex >= 0) {
                this.todos.splice(todoIndex, 1);
                return this.save.execute();
            } else {
                return Observable.of(false);
            }
        });

        this.toggleTodo = ReactiveCommand.createFromObservable((todo: Todo) => {
            todo.completed = !todo.completed;
            return this.save.execute();
        }, isNotSaving);

        var hasValidNewTodo = this.whenAnyValue(vm => vm.newTodo.title)
            .map(title => this.isValidTitle(title));

        var canAddTodo = Observable.combineLatest(
            hasValidNewTodo,
            isNotSaving,
            (validTodo, isNotSaving) => validTodo && isNotSaving);

        this.addTodo = ReactiveCommand.createFromObservable((a) => {
            this.newTodo.title = this.newTodo.title.trim();
            this.todos.unshift(this.newTodo.copy());
            this.resetNewTodo();
            return this.save.execute();
        }, canAddTodo);

        this.editTodo = ReactiveCommand.create((todo: Todo) => {
            this._originalTodo = todo.copy();
            this.editedTodo = todo;
            return {};
        });

        this.finishEditing = ReactiveCommand.createFromObservable(a => {
            if (this.editedTodo) {
                this.editedTodo.title = this.editedTodo.title.trim();
                if (this.editedTodo.title.length == 0) {
                    return this.deleteTodo.execute(this.editedTodo);
                }
                this.editedTodo = null;
            }
            return this.save.execute().do(saved => {
                if (saved) {
                    this._originalTodo = null;
                    this.editedTodo = null;
                }
            });
        }, isNotSaving);

        var canUndo = this.whenAnyValue(vm => vm.editedTodo, vm => vm.todos, (e, todos) => e !== null && todos !== null);

        this.undo = ReactiveCommand.create(a => {
            if (this.editedTodo && this._originalTodo) {
                this.editedTodo.title = this._originalTodo.title;
                this.editedTodo.completed = this._originalTodo.completed;
            }
            this.editedTodo = null;
            this._originalTodo = null;
            return true;
        }, canUndo);

        var areAllComplete = this.todos.computed.every(t => t.completed);
        var hasTodos = this.todos.whenAnyValue(t => t.length).map(length => length > 0);
        var canMarkAllComplete = Observable.combineLatest(hasTodos, areAllComplete, isNotSaving, (hasTodos, complete, notSaving) => hasTodos && !complete && notSaving);
        var canMarkAllIncomplete = Observable.combineLatest(hasTodos, areAllComplete, isNotSaving, (hasTodos, complete, notSaving) => hasTodos && complete && notSaving);
        Observable.zip(hasTodos, areAllComplete, (hasTodos, complete) => hasTodos && complete)
            .subscribe(complete => {
//.........这里部分代码省略.........